bfd/elf64-ppc.c

   1 /* PowerPC64-specific support for 64-bit ELF.
   2    Copyright (C) 1999-2016 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_can_gc_sections 1
  76 #define elf_backend_can_refcount 1
  77 #define elf_backend_rela_normal 1
  78 #define elf_backend_default_execstack 0
  79
  80 #define bfd_elf64_mkobject                    ppc64_elf_mkobject
  81 #define bfd_elf64_bfd_reloc_type_lookup       ppc64_elf_reloc_type_lookup
  82 #define bfd_elf64_bfd_reloc_name_lookup       ppc64_elf_reloc_name_lookup
  83 #define bfd_elf64_bfd_merge_private_bfd_data  ppc64_elf_merge_private_bfd_data
  84 #define bfd_elf64_bfd_print_private_bfd_data  ppc64_elf_print_private_bfd_data
  85 #define bfd_elf64_new_section_hook            ppc64_elf_new_section_hook
  86 #define bfd_elf64_bfd_link_hash_table_create  ppc64_elf_link_hash_table_create
  87 #define bfd_elf64_get_synthetic_symtab        ppc64_elf_get_synthetic_symtab
  88 #define bfd_elf64_bfd_link_just_syms          ppc64_elf_link_just_syms
  89
  90 #define elf_backend_object_p                  ppc64_elf_object_p
  91 #define elf_backend_grok_prstatus             ppc64_elf_grok_prstatus
  92 #define elf_backend_grok_psinfo               ppc64_elf_grok_psinfo
  93 #define elf_backend_write_core_note           ppc64_elf_write_core_note
  94 #define elf_backend_create_dynamic_sections   ppc64_elf_create_dynamic_sections
  95 #define elf_backend_copy_indirect_symbol      ppc64_elf_copy_indirect_symbol
  96 #define elf_backend_add_symbol_hook           ppc64_elf_add_symbol_hook
  97 #define elf_backend_check_directives          ppc64_elf_before_check_relocs
  98 #define elf_backend_notice_as_needed          ppc64_elf_notice_as_needed
  99 #define elf_backend_archive_symbol_lookup     ppc64_elf_archive_symbol_lookup
 100 #define elf_backend_check_relocs              ppc64_elf_check_relocs
 101 #define elf_backend_gc_keep                   ppc64_elf_gc_keep
 102 #define elf_backend_gc_mark_dynamic_ref       ppc64_elf_gc_mark_dynamic_ref
 103 #define elf_backend_gc_mark_hook              ppc64_elf_gc_mark_hook
 104 #define elf_backend_gc_sweep_hook             ppc64_elf_gc_sweep_hook
 105 #define elf_backend_adjust_dynamic_symbol     ppc64_elf_adjust_dynamic_symbol
 106 #define elf_backend_hide_symbol               ppc64_elf_hide_symbol
 107 #define elf_backend_maybe_function_sym        ppc64_elf_maybe_function_sym
 108 #define elf_backend_always_size_sections      ppc64_elf_func_desc_adjust
 109 #define elf_backend_size_dynamic_sections     ppc64_elf_size_dynamic_sections
 110 #define elf_backend_hash_symbol               ppc64_elf_hash_symbol
 111 #define elf_backend_init_index_section        _bfd_elf_init_2_index_sections
 112 #define elf_backend_action_discarded          ppc64_elf_action_discarded
 113 #define elf_backend_relocate_section          ppc64_elf_relocate_section
 114 #define elf_backend_finish_dynamic_symbol     ppc64_elf_finish_dynamic_symbol
 115 #define elf_backend_reloc_type_class          ppc64_elf_reloc_type_class
 116 #define elf_backend_finish_dynamic_sections   ppc64_elf_finish_dynamic_sections
 117 #define elf_backend_link_output_symbol_hook   ppc64_elf_output_symbol_hook
 118 #define elf_backend_special_sections          ppc64_elf_special_sections
 119 #define elf_backend_merge_symbol_attribute    ppc64_elf_merge_symbol_attribute
 120
 121 /* The name of the dynamic interpreter.  This is put in the .interp
 122    section.  */
 123 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
 124
 125 /* The size in bytes of an entry in the procedure linkage table.  */
 126 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
 127
 128 /* The initial size of the plt reserved for the dynamic linker.  */
 129 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
 130
 131 /* Offsets to some stack save slots.  */
 132 #define STK_LR 16
 133 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
 134 /* This one is dodgy.  ELFv2 does not have a linker word, so use the
 135    CR save slot.  Used only by optimised __tls_get_addr call stub,
 136    relying on __tls_get_addr_opt not saving CR..  */
 137 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
 138
 139 /* TOC base pointers offset from start of TOC.  */
 140 #define TOC_BASE_OFF    0x8000
 141 /* TOC base alignment.  */
 142 #define TOC_BASE_ALIGN  256
 143
 144 /* Offset of tp and dtp pointers from start of TLS block.  */
 145 #define TP_OFFSET       0x7000
 146 #define DTP_OFFSET      0x8000
 147
 148 /* .plt call stub instructions.  The normal stub is like this, but
 149    sometimes the .plt entry crosses a 64k boundary and we need to
 150    insert an addi to adjust r11.  */
 151 #define STD_R2_0R1      0xf8410000      /* std   %r2,0+40(%r1)       */
 152 #define ADDIS_R11_R2    0x3d620000      /* addis %r11,%r2,xxx@ha     */
 153 #define LD_R12_0R11     0xe98b0000      /* ld    %r12,xxx+0@l(%r11)  */
 154 #define MTCTR_R12       0x7d8903a6      /* mtctr %r12                */
 155 #define LD_R2_0R11      0xe84b0000      /* ld    %r2,xxx+8@l(%r11)   */
 156 #define LD_R11_0R11     0xe96b0000      /* ld    %r11,xxx+16@l(%r11) */
 157 #define BCTR            0x4e800420      /* bctr                      */
 158
 159 #define ADDI_R11_R11    0x396b0000      /* addi %r11,%r11,off@l  */
 160 #define ADDIS_R2_R2     0x3c420000      /* addis %r2,%r2,off@ha  */
 161 #define ADDI_R2_R2      0x38420000      /* addi  %r2,%r2,off@l   */
 162
 163 #define XOR_R2_R12_R12  0x7d826278      /* xor   %r2,%r12,%r12   */
 164 #define ADD_R11_R11_R2  0x7d6b1214      /* add   %r11,%r11,%r2   */
 165 #define XOR_R11_R12_R12 0x7d8b6278      /* xor   %r11,%r12,%r12  */
 166 #define ADD_R2_R2_R11   0x7c425a14      /* add   %r2,%r2,%r11    */
 167 #define CMPLDI_R2_0     0x28220000      /* cmpldi %r2,0          */
 168 #define BNECTR          0x4ca20420      /* bnectr+               */
 169 #define BNECTR_P4       0x4ce20420      /* bnectr+               */
 170
 171 #define LD_R12_0R2      0xe9820000      /* ld    %r12,xxx+0(%r2) */
 172 #define LD_R11_0R2      0xe9620000      /* ld    %r11,xxx+0(%r2) */
 173 #define LD_R2_0R2       0xe8420000      /* ld    %r2,xxx+0(%r2)  */
 174
 175 #define LD_R2_0R1       0xe8410000      /* ld    %r2,0(%r1)      */
 176 #define LD_R2_0R12      0xe84c0000      /* ld    %r2,0(%r12)     */
 177 #define ADD_R2_R2_R12   0x7c426214      /* add   %r2,%r2,%r12    */
 178
 179 #define LIS_R2          0x3c400000      /* lis %r2,xxx@ha         */
 180 #define ADDIS_R2_R12    0x3c4c0000      /* addis %r2,%r12,xxx@ha  */
 181 #define ADDIS_R12_R2    0x3d820000      /* addis %r12,%r2,xxx@ha  */
 182 #define ADDIS_R12_R12   0x3d8c0000      /* addis %r12,%r12,xxx@ha */
 183 #define LD_R12_0R12     0xe98c0000      /* ld    %r12,xxx@l(%r12) */
 184
 185 /* glink call stub instructions.  We enter with the index in R0.  */
 186 #define GLINK_CALL_STUB_SIZE (16*4)
 187                                         /* 0:                           */
 188                                         /*  .quad plt0-1f               */
 189                                         /* __glink:                     */
 190 #define MFLR_R12        0x7d8802a6      /*  mflr %12                    */
 191 #define BCL_20_31       0x429f0005      /*  bcl 20,31,1f                */
 192                                         /* 1:                           */
 193 #define MFLR_R11        0x7d6802a6      /*  mflr %11                    */
 194                                         /*  ld %2,(0b-1b)(%11)          */
 195 #define MTLR_R12        0x7d8803a6      /*  mtlr %12                    */
 196 #define ADD_R11_R2_R11  0x7d625a14      /*  add %11,%2,%11              */
 197                                         /*  ld %12,0(%11)               */
 198                                         /*  ld %2,8(%11)                */
 199                                         /*  mtctr %12                   */
 200                                         /*  ld %11,16(%11)              */
 201                                         /*  bctr                        */
 202 #define MFLR_R0         0x7c0802a6      /*  mflr %r0                    */
 203 #define MTLR_R0         0x7c0803a6      /*  mtlr %r0                    */
 204 #define SUB_R12_R12_R11 0x7d8b6050      /*  subf %r12,%r11,%r12         */
 205 #define ADDI_R0_R12     0x380c0000      /*  addi %r0,%r12,0             */
 206 #define SRDI_R0_R0_2    0x7800f082      /*  rldicl %r0,%r0,62,2         */
 207
 208 /* Pad with this.  */
 209 #define NOP             0x60000000
 210
 211 /* Some other nops.  */
 212 #define CROR_151515     0x4def7b82
 213 #define CROR_313131     0x4ffffb82
 214
 215 /* .glink entries for the first 32k functions are two instructions.  */
 216 #define LI_R0_0         0x38000000      /* li    %r0,0          */
 217 #define B_DOT           0x48000000      /* b     .              */
 218
 219 /* After that, we need two instructions to load the index, followed by
 220    a branch.  */
 221 #define LIS_R0_0        0x3c000000      /* lis   %r0,0          */
 222 #define ORI_R0_R0_0     0x60000000      /* ori   %r0,%r0,0      */
 223
 224 /* Instructions used by the save and restore reg functions.  */
 225 #define STD_R0_0R1      0xf8010000      /* std   %r0,0(%r1)     */
 226 #define STD_R0_0R12     0xf80c0000      /* std   %r0,0(%r12)    */
 227 #define LD_R0_0R1       0xe8010000      /* ld    %r0,0(%r1)     */
 228 #define LD_R0_0R12      0xe80c0000      /* ld    %r0,0(%r12)    */
 229 #define STFD_FR0_0R1    0xd8010000      /* stfd  %fr0,0(%r1)    */
 230 #define LFD_FR0_0R1     0xc8010000      /* lfd   %fr0,0(%r1)    */
 231 #define LI_R12_0        0x39800000      /* li    %r12,0         */
 232 #define STVX_VR0_R12_R0 0x7c0c01ce      /* stvx  %v0,%r12,%r0   */
 233 #define LVX_VR0_R12_R0  0x7c0c00ce      /* lvx   %v0,%r12,%r0   */
 234 #define MTLR_R0         0x7c0803a6      /* mtlr  %r0            */
 235 #define BLR             0x4e800020      /* blr                  */
 236
 237 /* Since .opd is an array of descriptors and each entry will end up
 238    with identical R_PPC64_RELATIVE relocs, there is really no need to
 239    propagate .opd relocs;  The dynamic linker should be taught to
 240    relocate .opd without reloc entries.  */
 241 #ifndef NO_OPD_RELOCS
 242 #define NO_OPD_RELOCS 0
 243 #endif
 244
 245 #ifndef ARRAY_SIZE
 246 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
 247 #endif
 248
 249 static inline int
 250 abiversion (bfd *abfd)
 251 {
 252   return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
 253 }
 254
 255 static inline void
 256 set_abiversion (bfd *abfd, int ver)
 257 {
 258   elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
 259   elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
 260 }
 261 \f
 262 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
 263
 264 /* Relocation HOWTO's.  */
 265 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
 266
 267 static reloc_howto_type ppc64_elf_howto_raw[] = {
 268   /* This reloc does nothing.  */
 269   HOWTO (R_PPC64_NONE,          /* type */
 270          0,                     /* rightshift */
 271          3,                     /* size (0 = byte, 1 = short, 2 = long) */
 272          0,                     /* bitsize */
 273          FALSE,                 /* pc_relative */
 274          0,                     /* bitpos */
 275          complain_overflow_dont, /* complain_on_overflow */
 276          bfd_elf_generic_reloc, /* special_function */
 277          "R_PPC64_NONE",        /* name */
 278          FALSE,                 /* partial_inplace */
 279          0,                     /* src_mask */
 280          0,                     /* dst_mask */
 281          FALSE),                /* pcrel_offset */
 282
 283   /* A standard 32 bit relocation.  */
 284   HOWTO (R_PPC64_ADDR32,        /* type */
 285          0,                     /* rightshift */
 286          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 287          32,                    /* bitsize */
 288          FALSE,                 /* pc_relative */
 289          0,                     /* bitpos */
 290          complain_overflow_bitfield, /* complain_on_overflow */
 291          bfd_elf_generic_reloc, /* special_function */
 292          "R_PPC64_ADDR32",      /* name */
 293          FALSE,                 /* partial_inplace */
 294          0,                     /* src_mask */
 295          0xffffffff,            /* dst_mask */
 296          FALSE),                /* pcrel_offset */
 297
 298   /* An absolute 26 bit branch; the lower two bits must be zero.
 299      FIXME: we don't check that, we just clear them.  */
 300   HOWTO (R_PPC64_ADDR24,        /* type */
 301          0,                     /* rightshift */
 302          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 303          26,                    /* bitsize */
 304          FALSE,                 /* pc_relative */
 305          0,                     /* bitpos */
 306          complain_overflow_bitfield, /* complain_on_overflow */
 307          bfd_elf_generic_reloc, /* special_function */
 308          "R_PPC64_ADDR24",      /* name */
 309          FALSE,                 /* partial_inplace */
 310          0,                     /* src_mask */
 311          0x03fffffc,            /* dst_mask */
 312          FALSE),                /* pcrel_offset */
 313
 314   /* A standard 16 bit relocation.  */
 315   HOWTO (R_PPC64_ADDR16,        /* type */
 316          0,                     /* rightshift */
 317          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 318          16,                    /* bitsize */
 319          FALSE,                 /* pc_relative */
 320          0,                     /* bitpos */
 321          complain_overflow_bitfield, /* complain_on_overflow */
 322          bfd_elf_generic_reloc, /* special_function */
 323          "R_PPC64_ADDR16",      /* name */
 324          FALSE,                 /* partial_inplace */
 325          0,                     /* src_mask */
 326          0xffff,                /* dst_mask */
 327          FALSE),                /* pcrel_offset */
 328
 329   /* A 16 bit relocation without overflow.  */
 330   HOWTO (R_PPC64_ADDR16_LO,     /* type */
 331          0,                     /* rightshift */
 332          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 333          16,                    /* bitsize */
 334          FALSE,                 /* pc_relative */
 335          0,                     /* bitpos */
 336          complain_overflow_dont,/* complain_on_overflow */
 337          bfd_elf_generic_reloc, /* special_function */
 338          "R_PPC64_ADDR16_LO",   /* name */
 339          FALSE,                 /* partial_inplace */
 340          0,                     /* src_mask */
 341          0xffff,                /* dst_mask */
 342          FALSE),                /* pcrel_offset */
 343
 344   /* Bits 16-31 of an address.  */
 345   HOWTO (R_PPC64_ADDR16_HI,     /* type */
 346          16,                    /* rightshift */
 347          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 348          16,                    /* bitsize */
 349          FALSE,                 /* pc_relative */
 350          0,                     /* bitpos */
 351          complain_overflow_signed, /* complain_on_overflow */
 352          bfd_elf_generic_reloc, /* special_function */
 353          "R_PPC64_ADDR16_HI",   /* name */
 354          FALSE,                 /* partial_inplace */
 355          0,                     /* src_mask */
 356          0xffff,                /* dst_mask */
 357          FALSE),                /* pcrel_offset */
 358
 359   /* Bits 16-31 of an address, plus 1 if the contents of the low 16
 360      bits, treated as a signed number, is negative.  */
 361   HOWTO (R_PPC64_ADDR16_HA,     /* type */
 362          16,                    /* rightshift */
 363          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 364          16,                    /* bitsize */
 365          FALSE,                 /* pc_relative */
 366          0,                     /* bitpos */
 367          complain_overflow_signed, /* complain_on_overflow */
 368          ppc64_elf_ha_reloc,    /* special_function */
 369          "R_PPC64_ADDR16_HA",   /* name */
 370          FALSE,                 /* partial_inplace */
 371          0,                     /* src_mask */
 372          0xffff,                /* dst_mask */
 373          FALSE),                /* pcrel_offset */
 374
 375   /* An absolute 16 bit branch; the lower two bits must be zero.
 376      FIXME: we don't check that, we just clear them.  */
 377   HOWTO (R_PPC64_ADDR14,        /* type */
 378          0,                     /* rightshift */
 379          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 380          16,                    /* bitsize */
 381          FALSE,                 /* pc_relative */
 382          0,                     /* bitpos */
 383          complain_overflow_signed, /* complain_on_overflow */
 384          ppc64_elf_branch_reloc, /* special_function */
 385          "R_PPC64_ADDR14",      /* name */
 386          FALSE,                 /* partial_inplace */
 387          0,                     /* src_mask */
 388          0x0000fffc,            /* dst_mask */
 389          FALSE),                /* pcrel_offset */
 390
 391   /* An absolute 16 bit branch, for which bit 10 should be set to
 392      indicate that the branch is expected to be taken.  The lower two
 393      bits must be zero.  */
 394   HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
 395          0,                     /* rightshift */
 396          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 397          16,                    /* bitsize */
 398          FALSE,                 /* pc_relative */
 399          0,                     /* bitpos */
 400          complain_overflow_signed, /* complain_on_overflow */
 401          ppc64_elf_brtaken_reloc, /* special_function */
 402          "R_PPC64_ADDR14_BRTAKEN",/* name */
 403          FALSE,                 /* partial_inplace */
 404          0,                     /* src_mask */
 405          0x0000fffc,            /* dst_mask */
 406          FALSE),                /* pcrel_offset */
 407
 408   /* An absolute 16 bit branch, for which bit 10 should be set to
 409      indicate that the branch is not expected to be taken.  The lower
 410      two bits must be zero.  */
 411   HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
 412          0,                     /* rightshift */
 413          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 414          16,                    /* bitsize */
 415          FALSE,                 /* pc_relative */
 416          0,                     /* bitpos */
 417          complain_overflow_signed, /* complain_on_overflow */
 418          ppc64_elf_brtaken_reloc, /* special_function */
 419          "R_PPC64_ADDR14_BRNTAKEN",/* name */
 420          FALSE,                 /* partial_inplace */
 421          0,                     /* src_mask */
 422          0x0000fffc,            /* dst_mask */
 423          FALSE),                /* pcrel_offset */
 424
 425   /* A relative 26 bit branch; the lower two bits must be zero.  */
 426   HOWTO (R_PPC64_REL24,         /* type */
 427          0,                     /* rightshift */
 428          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 429          26,                    /* bitsize */
 430          TRUE,                  /* pc_relative */
 431          0,                     /* bitpos */
 432          complain_overflow_signed, /* complain_on_overflow */
 433          ppc64_elf_branch_reloc, /* special_function */
 434          "R_PPC64_REL24",       /* name */
 435          FALSE,                 /* partial_inplace */
 436          0,                     /* src_mask */
 437          0x03fffffc,            /* dst_mask */
 438          TRUE),                 /* pcrel_offset */
 439
 440   /* A relative 16 bit branch; the lower two bits must be zero.  */
 441   HOWTO (R_PPC64_REL14,         /* type */
 442          0,                     /* rightshift */
 443          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 444          16,                    /* bitsize */
 445          TRUE,                  /* pc_relative */
 446          0,                     /* bitpos */
 447          complain_overflow_signed, /* complain_on_overflow */
 448          ppc64_elf_branch_reloc, /* special_function */
 449          "R_PPC64_REL14",       /* name */
 450          FALSE,                 /* partial_inplace */
 451          0,                     /* src_mask */
 452          0x0000fffc,            /* dst_mask */
 453          TRUE),                 /* pcrel_offset */
 454
 455   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 456      the branch is expected to be taken.  The lower two bits must be
 457      zero.  */
 458   HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
 459          0,                     /* rightshift */
 460          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 461          16,                    /* bitsize */
 462          TRUE,                  /* pc_relative */
 463          0,                     /* bitpos */
 464          complain_overflow_signed, /* complain_on_overflow */
 465          ppc64_elf_brtaken_reloc, /* special_function */
 466          "R_PPC64_REL14_BRTAKEN", /* name */
 467          FALSE,                 /* partial_inplace */
 468          0,                     /* src_mask */
 469          0x0000fffc,            /* dst_mask */
 470          TRUE),                 /* pcrel_offset */
 471
 472   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 473      the branch is not expected to be taken.  The lower two bits must
 474      be zero.  */
 475   HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
 476          0,                     /* rightshift */
 477          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 478          16,                    /* bitsize */
 479          TRUE,                  /* pc_relative */
 480          0,                     /* bitpos */
 481          complain_overflow_signed, /* complain_on_overflow */
 482          ppc64_elf_brtaken_reloc, /* special_function */
 483          "R_PPC64_REL14_BRNTAKEN",/* name */
 484          FALSE,                 /* partial_inplace */
 485          0,                     /* src_mask */
 486          0x0000fffc,            /* dst_mask */
 487          TRUE),                 /* pcrel_offset */
 488
 489   /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
 490      symbol.  */
 491   HOWTO (R_PPC64_GOT16,         /* type */
 492          0,                     /* rightshift */
 493          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 494          16,                    /* bitsize */
 495          FALSE,                 /* pc_relative */
 496          0,                     /* bitpos */
 497          complain_overflow_signed, /* complain_on_overflow */
 498          ppc64_elf_unhandled_reloc, /* special_function */
 499          "R_PPC64_GOT16",       /* name */
 500          FALSE,                 /* partial_inplace */
 501          0,                     /* src_mask */
 502          0xffff,                /* dst_mask */
 503          FALSE),                /* pcrel_offset */
 504
 505   /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
 506      the symbol.  */
 507   HOWTO (R_PPC64_GOT16_LO,      /* type */
 508          0,                     /* rightshift */
 509          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 510          16,                    /* bitsize */
 511          FALSE,                 /* pc_relative */
 512          0,                     /* bitpos */
 513          complain_overflow_dont, /* complain_on_overflow */
 514          ppc64_elf_unhandled_reloc, /* special_function */
 515          "R_PPC64_GOT16_LO",    /* name */
 516          FALSE,                 /* partial_inplace */
 517          0,                     /* src_mask */
 518          0xffff,                /* dst_mask */
 519          FALSE),                /* pcrel_offset */
 520
 521   /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
 522      the symbol.  */
 523   HOWTO (R_PPC64_GOT16_HI,      /* type */
 524          16,                    /* rightshift */
 525          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 526          16,                    /* bitsize */
 527          FALSE,                 /* pc_relative */
 528          0,                     /* bitpos */
 529          complain_overflow_signed,/* complain_on_overflow */
 530          ppc64_elf_unhandled_reloc, /* special_function */
 531          "R_PPC64_GOT16_HI",    /* name */
 532          FALSE,                 /* partial_inplace */
 533          0,                     /* src_mask */
 534          0xffff,                /* dst_mask */
 535          FALSE),                /* pcrel_offset */
 536
 537   /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
 538      the symbol.  */
 539   HOWTO (R_PPC64_GOT16_HA,      /* type */
 540          16,                    /* rightshift */
 541          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 542          16,                    /* bitsize */
 543          FALSE,                 /* pc_relative */
 544          0,                     /* bitpos */
 545          complain_overflow_signed,/* complain_on_overflow */
 546          ppc64_elf_unhandled_reloc, /* special_function */
 547          "R_PPC64_GOT16_HA",    /* name */
 548          FALSE,                 /* partial_inplace */
 549          0,                     /* src_mask */
 550          0xffff,                /* dst_mask */
 551          FALSE),                /* pcrel_offset */
 552
 553   /* This is used only by the dynamic linker.  The symbol should exist
 554      both in the object being run and in some shared library.  The
 555      dynamic linker copies the data addressed by the symbol from the
 556      shared library into the object, because the object being
 557      run has to have the data at some particular address.  */
 558   HOWTO (R_PPC64_COPY,          /* type */
 559          0,                     /* rightshift */
 560          0,                     /* this one is variable size */
 561          0,                     /* bitsize */
 562          FALSE,                 /* pc_relative */
 563          0,                     /* bitpos */
 564          complain_overflow_dont, /* complain_on_overflow */
 565          ppc64_elf_unhandled_reloc, /* special_function */
 566          "R_PPC64_COPY",        /* name */
 567          FALSE,                 /* partial_inplace */
 568          0,                     /* src_mask */
 569          0,                     /* dst_mask */
 570          FALSE),                /* pcrel_offset */
 571
 572   /* Like R_PPC64_ADDR64, but used when setting global offset table
 573      entries.  */
 574   HOWTO (R_PPC64_GLOB_DAT,      /* type */
 575          0,                     /* rightshift */
 576          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 577          64,                    /* bitsize */
 578          FALSE,                 /* pc_relative */
 579          0,                     /* bitpos */
 580          complain_overflow_dont, /* complain_on_overflow */
 581          ppc64_elf_unhandled_reloc,  /* special_function */
 582          "R_PPC64_GLOB_DAT",    /* name */
 583          FALSE,                 /* partial_inplace */
 584          0,                     /* src_mask */
 585          ONES (64),             /* dst_mask */
 586          FALSE),                /* pcrel_offset */
 587
 588   /* Created by the link editor.  Marks a procedure linkage table
 589      entry for a symbol.  */
 590   HOWTO (R_PPC64_JMP_SLOT,      /* type */
 591          0,                     /* rightshift */
 592          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 593          0,                     /* bitsize */
 594          FALSE,                 /* pc_relative */
 595          0,                     /* bitpos */
 596          complain_overflow_dont, /* complain_on_overflow */
 597          ppc64_elf_unhandled_reloc, /* special_function */
 598          "R_PPC64_JMP_SLOT",    /* name */
 599          FALSE,                 /* partial_inplace */
 600          0,                     /* src_mask */
 601          0,                     /* dst_mask */
 602          FALSE),                /* pcrel_offset */
 603
 604   /* Used only by the dynamic linker.  When the object is run, this
 605      doubleword64 is set to the load address of the object, plus the
 606      addend.  */
 607   HOWTO (R_PPC64_RELATIVE,      /* type */
 608          0,                     /* rightshift */
 609          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 610          64,                    /* bitsize */
 611          FALSE,                 /* pc_relative */
 612          0,                     /* bitpos */
 613          complain_overflow_dont, /* complain_on_overflow */
 614          bfd_elf_generic_reloc, /* special_function */
 615          "R_PPC64_RELATIVE",    /* name */
 616          FALSE,                 /* partial_inplace */
 617          0,                     /* src_mask */
 618          ONES (64),             /* dst_mask */
 619          FALSE),                /* pcrel_offset */
 620
 621   /* Like R_PPC64_ADDR32, but may be unaligned.  */
 622   HOWTO (R_PPC64_UADDR32,       /* type */
 623          0,                     /* rightshift */
 624          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 625          32,                    /* bitsize */
 626          FALSE,                 /* pc_relative */
 627          0,                     /* bitpos */
 628          complain_overflow_bitfield, /* complain_on_overflow */
 629          bfd_elf_generic_reloc, /* special_function */
 630          "R_PPC64_UADDR32",     /* name */
 631          FALSE,                 /* partial_inplace */
 632          0,                     /* src_mask */
 633          0xffffffff,            /* dst_mask */
 634          FALSE),                /* pcrel_offset */
 635
 636   /* Like R_PPC64_ADDR16, but may be unaligned.  */
 637   HOWTO (R_PPC64_UADDR16,       /* type */
 638          0,                     /* rightshift */
 639          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 640          16,                    /* bitsize */
 641          FALSE,                 /* pc_relative */
 642          0,                     /* bitpos */
 643          complain_overflow_bitfield, /* complain_on_overflow */
 644          bfd_elf_generic_reloc, /* special_function */
 645          "R_PPC64_UADDR16",     /* name */
 646          FALSE,                 /* partial_inplace */
 647          0,                     /* src_mask */
 648          0xffff,                /* dst_mask */
 649          FALSE),                /* pcrel_offset */
 650
 651   /* 32-bit PC relative.  */
 652   HOWTO (R_PPC64_REL32,         /* type */
 653          0,                     /* rightshift */
 654          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 655          32,                    /* bitsize */
 656          TRUE,                  /* pc_relative */
 657          0,                     /* bitpos */
 658          complain_overflow_signed, /* complain_on_overflow */
 659          bfd_elf_generic_reloc, /* special_function */
 660          "R_PPC64_REL32",       /* name */
 661          FALSE,                 /* partial_inplace */
 662          0,                     /* src_mask */
 663          0xffffffff,            /* dst_mask */
 664          TRUE),                 /* pcrel_offset */
 665
 666   /* 32-bit relocation to the symbol's procedure linkage table.  */
 667   HOWTO (R_PPC64_PLT32,         /* type */
 668          0,                     /* rightshift */
 669          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 670          32,                    /* bitsize */
 671          FALSE,                 /* pc_relative */
 672          0,                     /* bitpos */
 673          complain_overflow_bitfield, /* complain_on_overflow */
 674          ppc64_elf_unhandled_reloc, /* special_function */
 675          "R_PPC64_PLT32",       /* name */
 676          FALSE,                 /* partial_inplace */
 677          0,                     /* src_mask */
 678          0xffffffff,            /* dst_mask */
 679          FALSE),                /* pcrel_offset */
 680
 681   /* 32-bit PC relative relocation to the symbol's procedure linkage table.
 682      FIXME: R_PPC64_PLTREL32 not supported.  */
 683   HOWTO (R_PPC64_PLTREL32,      /* type */
 684          0,                     /* rightshift */
 685          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 686          32,                    /* bitsize */
 687          TRUE,                  /* pc_relative */
 688          0,                     /* bitpos */
 689          complain_overflow_signed, /* complain_on_overflow */
 690          bfd_elf_generic_reloc, /* special_function */
 691          "R_PPC64_PLTREL32",    /* name */
 692          FALSE,                 /* partial_inplace */
 693          0,                     /* src_mask */
 694          0xffffffff,            /* dst_mask */
 695          TRUE),                 /* pcrel_offset */
 696
 697   /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
 698      the symbol.  */
 699   HOWTO (R_PPC64_PLT16_LO,      /* type */
 700          0,                     /* rightshift */
 701          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 702          16,                    /* bitsize */
 703          FALSE,                 /* pc_relative */
 704          0,                     /* bitpos */
 705          complain_overflow_dont, /* complain_on_overflow */
 706          ppc64_elf_unhandled_reloc, /* special_function */
 707          "R_PPC64_PLT16_LO",    /* name */
 708          FALSE,                 /* partial_inplace */
 709          0,                     /* src_mask */
 710          0xffff,                /* dst_mask */
 711          FALSE),                /* pcrel_offset */
 712
 713   /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
 714      the symbol.  */
 715   HOWTO (R_PPC64_PLT16_HI,      /* type */
 716          16,                    /* rightshift */
 717          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 718          16,                    /* bitsize */
 719          FALSE,                 /* pc_relative */
 720          0,                     /* bitpos */
 721          complain_overflow_signed, /* complain_on_overflow */
 722          ppc64_elf_unhandled_reloc, /* special_function */
 723          "R_PPC64_PLT16_HI",    /* name */
 724          FALSE,                 /* partial_inplace */
 725          0,                     /* src_mask */
 726          0xffff,                /* dst_mask */
 727          FALSE),                /* pcrel_offset */
 728
 729   /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
 730      the symbol.  */
 731   HOWTO (R_PPC64_PLT16_HA,      /* type */
 732          16,                    /* rightshift */
 733          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 734          16,                    /* bitsize */
 735          FALSE,                 /* pc_relative */
 736          0,                     /* bitpos */
 737          complain_overflow_signed, /* complain_on_overflow */
 738          ppc64_elf_unhandled_reloc, /* special_function */
 739          "R_PPC64_PLT16_HA",    /* name */
 740          FALSE,                 /* partial_inplace */
 741          0,                     /* src_mask */
 742          0xffff,                /* dst_mask */
 743          FALSE),                /* pcrel_offset */
 744
 745   /* 16-bit section relative relocation.  */
 746   HOWTO (R_PPC64_SECTOFF,       /* type */
 747          0,                     /* rightshift */
 748          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 749          16,                    /* bitsize */
 750          FALSE,                 /* pc_relative */
 751          0,                     /* bitpos */
 752          complain_overflow_signed, /* complain_on_overflow */
 753          ppc64_elf_sectoff_reloc, /* special_function */
 754          "R_PPC64_SECTOFF",     /* name */
 755          FALSE,                 /* partial_inplace */
 756          0,                     /* src_mask */
 757          0xffff,                /* dst_mask */
 758          FALSE),                /* pcrel_offset */
 759
 760   /* Like R_PPC64_SECTOFF, but no overflow warning.  */
 761   HOWTO (R_PPC64_SECTOFF_LO,    /* type */
 762          0,                     /* rightshift */
 763          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 764          16,                    /* bitsize */
 765          FALSE,                 /* pc_relative */
 766          0,                     /* bitpos */
 767          complain_overflow_dont, /* complain_on_overflow */
 768          ppc64_elf_sectoff_reloc, /* special_function */
 769          "R_PPC64_SECTOFF_LO",  /* name */
 770          FALSE,                 /* partial_inplace */
 771          0,                     /* src_mask */
 772          0xffff,                /* dst_mask */
 773          FALSE),                /* pcrel_offset */
 774
 775   /* 16-bit upper half section relative relocation.  */
 776   HOWTO (R_PPC64_SECTOFF_HI,    /* type */
 777          16,                    /* rightshift */
 778          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 779          16,                    /* bitsize */
 780          FALSE,                 /* pc_relative */
 781          0,                     /* bitpos */
 782          complain_overflow_signed, /* complain_on_overflow */
 783          ppc64_elf_sectoff_reloc, /* special_function */
 784          "R_PPC64_SECTOFF_HI",  /* name */
 785          FALSE,                 /* partial_inplace */
 786          0,                     /* src_mask */
 787          0xffff,                /* dst_mask */
 788          FALSE),                /* pcrel_offset */
 789
 790   /* 16-bit upper half adjusted section relative relocation.  */
 791   HOWTO (R_PPC64_SECTOFF_HA,    /* type */
 792          16,                    /* rightshift */
 793          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 794          16,                    /* bitsize */
 795          FALSE,                 /* pc_relative */
 796          0,                     /* bitpos */
 797          complain_overflow_signed, /* complain_on_overflow */
 798          ppc64_elf_sectoff_ha_reloc, /* special_function */
 799          "R_PPC64_SECTOFF_HA",  /* name */
 800          FALSE,                 /* partial_inplace */
 801          0,                     /* src_mask */
 802          0xffff,                /* dst_mask */
 803          FALSE),                /* pcrel_offset */
 804
 805   /* Like R_PPC64_REL24 without touching the two least significant bits.  */
 806   HOWTO (R_PPC64_REL30,         /* type */
 807          2,                     /* rightshift */
 808          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 809          30,                    /* bitsize */
 810          TRUE,                  /* pc_relative */
 811          0,                     /* bitpos */
 812          complain_overflow_dont, /* complain_on_overflow */
 813          bfd_elf_generic_reloc, /* special_function */
 814          "R_PPC64_REL30",       /* name */
 815          FALSE,                 /* partial_inplace */
 816          0,                     /* src_mask */
 817          0xfffffffc,            /* dst_mask */
 818          TRUE),                 /* pcrel_offset */
 819
 820   /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI.  */
 821
 822   /* A standard 64-bit relocation.  */
 823   HOWTO (R_PPC64_ADDR64,        /* type */
 824          0,                     /* rightshift */
 825          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 826          64,                    /* bitsize */
 827          FALSE,                 /* pc_relative */
 828          0,                     /* bitpos */
 829          complain_overflow_dont, /* complain_on_overflow */
 830          bfd_elf_generic_reloc, /* special_function */
 831          "R_PPC64_ADDR64",      /* name */
 832          FALSE,                 /* partial_inplace */
 833          0,                     /* src_mask */
 834          ONES (64),             /* dst_mask */
 835          FALSE),                /* pcrel_offset */
 836
 837   /* The bits 32-47 of an address.  */
 838   HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
 839          32,                    /* rightshift */
 840          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 841          16,                    /* bitsize */
 842          FALSE,                 /* pc_relative */
 843          0,                     /* bitpos */
 844          complain_overflow_dont, /* complain_on_overflow */
 845          bfd_elf_generic_reloc, /* special_function */
 846          "R_PPC64_ADDR16_HIGHER", /* name */
 847          FALSE,                 /* partial_inplace */
 848          0,                     /* src_mask */
 849          0xffff,                /* dst_mask */
 850          FALSE),                /* pcrel_offset */
 851
 852   /* The bits 32-47 of an address, plus 1 if the contents of the low
 853      16 bits, treated as a signed number, is negative.  */
 854   HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
 855          32,                    /* rightshift */
 856          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 857          16,                    /* bitsize */
 858          FALSE,                 /* pc_relative */
 859          0,                     /* bitpos */
 860          complain_overflow_dont, /* complain_on_overflow */
 861          ppc64_elf_ha_reloc,    /* special_function */
 862          "R_PPC64_ADDR16_HIGHERA", /* name */
 863          FALSE,                 /* partial_inplace */
 864          0,                     /* src_mask */
 865          0xffff,                /* dst_mask */
 866          FALSE),                /* pcrel_offset */
 867
 868   /* The bits 48-63 of an address.  */
 869   HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
 870          48,                    /* rightshift */
 871          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 872          16,                    /* bitsize */
 873          FALSE,                 /* pc_relative */
 874          0,                     /* bitpos */
 875          complain_overflow_dont, /* complain_on_overflow */
 876          bfd_elf_generic_reloc, /* special_function */
 877          "R_PPC64_ADDR16_HIGHEST", /* name */
 878          FALSE,                 /* partial_inplace */
 879          0,                     /* src_mask */
 880          0xffff,                /* dst_mask */
 881          FALSE),                /* pcrel_offset */
 882
 883   /* The bits 48-63 of an address, plus 1 if the contents of the low
 884      16 bits, treated as a signed number, is negative.  */
 885   HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
 886          48,                    /* rightshift */
 887          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 888          16,                    /* bitsize */
 889          FALSE,                 /* pc_relative */
 890          0,                     /* bitpos */
 891          complain_overflow_dont, /* complain_on_overflow */
 892          ppc64_elf_ha_reloc,    /* special_function */
 893          "R_PPC64_ADDR16_HIGHESTA", /* name */
 894          FALSE,                 /* partial_inplace */
 895          0,                     /* src_mask */
 896          0xffff,                /* dst_mask */
 897          FALSE),                /* pcrel_offset */
 898
 899   /* Like ADDR64, but may be unaligned.  */
 900   HOWTO (R_PPC64_UADDR64,       /* type */
 901          0,                     /* rightshift */
 902          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 903          64,                    /* bitsize */
 904          FALSE,                 /* pc_relative */
 905          0,                     /* bitpos */
 906          complain_overflow_dont, /* complain_on_overflow */
 907          bfd_elf_generic_reloc, /* special_function */
 908          "R_PPC64_UADDR64",     /* name */
 909          FALSE,                 /* partial_inplace */
 910          0,                     /* src_mask */
 911          ONES (64),             /* dst_mask */
 912          FALSE),                /* pcrel_offset */
 913
 914   /* 64-bit relative relocation.  */
 915   HOWTO (R_PPC64_REL64,         /* type */
 916          0,                     /* rightshift */
 917          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 918          64,                    /* bitsize */
 919          TRUE,                  /* pc_relative */
 920          0,                     /* bitpos */
 921          complain_overflow_dont, /* complain_on_overflow */
 922          bfd_elf_generic_reloc, /* special_function */
 923          "R_PPC64_REL64",       /* name */
 924          FALSE,                 /* partial_inplace */
 925          0,                     /* src_mask */
 926          ONES (64),             /* dst_mask */
 927          TRUE),                 /* pcrel_offset */
 928
 929   /* 64-bit relocation to the symbol's procedure linkage table.  */
 930   HOWTO (R_PPC64_PLT64,         /* type */
 931          0,                     /* rightshift */
 932          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 933          64,                    /* bitsize */
 934          FALSE,                 /* pc_relative */
 935          0,                     /* bitpos */
 936          complain_overflow_dont, /* complain_on_overflow */
 937          ppc64_elf_unhandled_reloc, /* special_function */
 938          "R_PPC64_PLT64",       /* name */
 939          FALSE,                 /* partial_inplace */
 940          0,                     /* src_mask */
 941          ONES (64),             /* dst_mask */
 942          FALSE),                /* pcrel_offset */
 943
 944   /* 64-bit PC relative relocation to the symbol's procedure linkage
 945      table.  */
 946   /* FIXME: R_PPC64_PLTREL64 not supported.  */
 947   HOWTO (R_PPC64_PLTREL64,      /* type */
 948          0,                     /* rightshift */
 949          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 950          64,                    /* bitsize */
 951          TRUE,                  /* pc_relative */
 952          0,                     /* bitpos */
 953          complain_overflow_dont, /* complain_on_overflow */
 954          ppc64_elf_unhandled_reloc, /* special_function */
 955          "R_PPC64_PLTREL64",    /* name */
 956          FALSE,                 /* partial_inplace */
 957          0,                     /* src_mask */
 958          ONES (64),             /* dst_mask */
 959          TRUE),                 /* pcrel_offset */
 960
 961   /* 16 bit TOC-relative relocation.  */
 962
 963   /* R_PPC64_TOC16        47       half16*      S + A - .TOC.  */
 964   HOWTO (R_PPC64_TOC16,         /* type */
 965          0,                     /* rightshift */
 966          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 967          16,                    /* bitsize */
 968          FALSE,                 /* pc_relative */
 969          0,                     /* bitpos */
 970          complain_overflow_signed, /* complain_on_overflow */
 971          ppc64_elf_toc_reloc,   /* special_function */
 972          "R_PPC64_TOC16",       /* name */
 973          FALSE,                 /* partial_inplace */
 974          0,                     /* src_mask */
 975          0xffff,                /* dst_mask */
 976          FALSE),                /* pcrel_offset */
 977
 978   /* 16 bit TOC-relative relocation without overflow.  */
 979
 980   /* R_PPC64_TOC16_LO     48       half16        #lo (S + A - .TOC.)  */
 981   HOWTO (R_PPC64_TOC16_LO,      /* type */
 982          0,                     /* rightshift */
 983          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 984          16,                    /* bitsize */
 985          FALSE,                 /* pc_relative */
 986          0,                     /* bitpos */
 987          complain_overflow_dont, /* complain_on_overflow */
 988          ppc64_elf_toc_reloc,   /* special_function */
 989          "R_PPC64_TOC16_LO",    /* name */
 990          FALSE,                 /* partial_inplace */
 991          0,                     /* src_mask */
 992          0xffff,                /* dst_mask */
 993          FALSE),                /* pcrel_offset */
 994
 995   /* 16 bit TOC-relative relocation, high 16 bits.  */
 996
 997   /* R_PPC64_TOC16_HI     49       half16        #hi (S + A - .TOC.)  */
 998   HOWTO (R_PPC64_TOC16_HI,      /* type */
 999          16,                    /* rightshift */
1000          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1001          16,                    /* bitsize */
1002          FALSE,                 /* pc_relative */
1003          0,                     /* bitpos */
1004          complain_overflow_signed, /* complain_on_overflow */
1005          ppc64_elf_toc_reloc,   /* special_function */
1006          "R_PPC64_TOC16_HI",    /* name */
1007          FALSE,                 /* partial_inplace */
1008          0,                     /* src_mask */
1009          0xffff,                /* dst_mask */
1010          FALSE),                /* pcrel_offset */
1011
1012   /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
1013      contents of the low 16 bits, treated as a signed number, is
1014      negative.  */
1015
1016   /* R_PPC64_TOC16_HA     50       half16        #ha (S + A - .TOC.)  */
1017   HOWTO (R_PPC64_TOC16_HA,      /* type */
1018          16,                    /* rightshift */
1019          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1020          16,                    /* bitsize */
1021          FALSE,                 /* pc_relative */
1022          0,                     /* bitpos */
1023          complain_overflow_signed, /* complain_on_overflow */
1024          ppc64_elf_toc_ha_reloc, /* special_function */
1025          "R_PPC64_TOC16_HA",    /* name */
1026          FALSE,                 /* partial_inplace */
1027          0,                     /* src_mask */
1028          0xffff,                /* dst_mask */
1029          FALSE),                /* pcrel_offset */
1030
1031   /* 64-bit relocation; insert value of TOC base (.TOC.).  */
1032
1033   /* R_PPC64_TOC                  51       doubleword64  .TOC.  */
1034   HOWTO (R_PPC64_TOC,           /* type */
1035          0,                     /* rightshift */
1036          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1037          64,                    /* bitsize */
1038          FALSE,                 /* pc_relative */
1039          0,                     /* bitpos */
1040          complain_overflow_dont, /* complain_on_overflow */
1041          ppc64_elf_toc64_reloc, /* special_function */
1042          "R_PPC64_TOC",         /* name */
1043          FALSE,                 /* partial_inplace */
1044          0,                     /* src_mask */
1045          ONES (64),             /* dst_mask */
1046          FALSE),                /* pcrel_offset */
1047
1048   /* Like R_PPC64_GOT16, but also informs the link editor that the
1049      value to relocate may (!) refer to a PLT entry which the link
1050      editor (a) may replace with the symbol value.  If the link editor
1051      is unable to fully resolve the symbol, it may (b) create a PLT
1052      entry and store the address to the new PLT entry in the GOT.
1053      This permits lazy resolution of function symbols at run time.
1054      The link editor may also skip all of this and just (c) emit a
1055      R_PPC64_GLOB_DAT to tie the symbol to the GOT entry.  */
1056   /* FIXME: R_PPC64_PLTGOT16 not implemented.  */
1057     HOWTO (R_PPC64_PLTGOT16,    /* type */
1058          0,                     /* rightshift */
1059          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1060          16,                    /* bitsize */
1061          FALSE,                 /* pc_relative */
1062          0,                     /* bitpos */
1063          complain_overflow_signed, /* complain_on_overflow */
1064          ppc64_elf_unhandled_reloc, /* special_function */
1065          "R_PPC64_PLTGOT16",    /* name */
1066          FALSE,                 /* partial_inplace */
1067          0,                     /* src_mask */
1068          0xffff,                /* dst_mask */
1069          FALSE),                /* pcrel_offset */
1070
1071   /* Like R_PPC64_PLTGOT16, but without overflow.  */
1072   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1073   HOWTO (R_PPC64_PLTGOT16_LO,   /* type */
1074          0,                     /* rightshift */
1075          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1076          16,                    /* bitsize */
1077          FALSE,                 /* pc_relative */
1078          0,                     /* bitpos */
1079          complain_overflow_dont, /* complain_on_overflow */
1080          ppc64_elf_unhandled_reloc, /* special_function */
1081          "R_PPC64_PLTGOT16_LO", /* name */
1082          FALSE,                 /* partial_inplace */
1083          0,                     /* src_mask */
1084          0xffff,                /* dst_mask */
1085          FALSE),                /* pcrel_offset */
1086
1087   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address.  */
1088   /* FIXME: R_PPC64_PLTGOT16_HI not implemented.  */
1089   HOWTO (R_PPC64_PLTGOT16_HI,   /* type */
1090          16,                    /* rightshift */
1091          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1092          16,                    /* bitsize */
1093          FALSE,                 /* pc_relative */
1094          0,                     /* bitpos */
1095          complain_overflow_signed, /* complain_on_overflow */
1096          ppc64_elf_unhandled_reloc, /* special_function */
1097          "R_PPC64_PLTGOT16_HI", /* name */
1098          FALSE,                 /* partial_inplace */
1099          0,                     /* src_mask */
1100          0xffff,                /* dst_mask */
1101          FALSE),                /* pcrel_offset */
1102
1103   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1104      1 if the contents of the low 16 bits, treated as a signed number,
1105      is negative.  */
1106   /* FIXME: R_PPC64_PLTGOT16_HA not implemented.  */
1107   HOWTO (R_PPC64_PLTGOT16_HA,   /* type */
1108          16,                    /* rightshift */
1109          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1110          16,                    /* bitsize */
1111          FALSE,                 /* pc_relative */
1112          0,                     /* bitpos */
1113          complain_overflow_signed, /* complain_on_overflow */
1114          ppc64_elf_unhandled_reloc, /* special_function */
1115          "R_PPC64_PLTGOT16_HA", /* name */
1116          FALSE,                 /* partial_inplace */
1117          0,                     /* src_mask */
1118          0xffff,                /* dst_mask */
1119          FALSE),                /* pcrel_offset */
1120
1121   /* Like R_PPC64_ADDR16, but for instructions with a DS field.  */
1122   HOWTO (R_PPC64_ADDR16_DS,     /* type */
1123          0,                     /* rightshift */
1124          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1125          16,                    /* bitsize */
1126          FALSE,                 /* pc_relative */
1127          0,                     /* bitpos */
1128          complain_overflow_signed, /* complain_on_overflow */
1129          bfd_elf_generic_reloc, /* special_function */
1130          "R_PPC64_ADDR16_DS",   /* name */
1131          FALSE,                 /* partial_inplace */
1132          0,                     /* src_mask */
1133          0xfffc,                /* dst_mask */
1134          FALSE),                /* pcrel_offset */
1135
1136   /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field.  */
1137   HOWTO (R_PPC64_ADDR16_LO_DS,  /* type */
1138          0,                     /* rightshift */
1139          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1140          16,                    /* bitsize */
1141          FALSE,                 /* pc_relative */
1142          0,                     /* bitpos */
1143          complain_overflow_dont,/* complain_on_overflow */
1144          bfd_elf_generic_reloc, /* special_function */
1145          "R_PPC64_ADDR16_LO_DS",/* name */
1146          FALSE,                 /* partial_inplace */
1147          0,                     /* src_mask */
1148          0xfffc,                /* dst_mask */
1149          FALSE),                /* pcrel_offset */
1150
1151   /* Like R_PPC64_GOT16, but for instructions with a DS field.  */
1152   HOWTO (R_PPC64_GOT16_DS,      /* type */
1153          0,                     /* rightshift */
1154          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1155          16,                    /* bitsize */
1156          FALSE,                 /* pc_relative */
1157          0,                     /* bitpos */
1158          complain_overflow_signed, /* complain_on_overflow */
1159          ppc64_elf_unhandled_reloc, /* special_function */
1160          "R_PPC64_GOT16_DS",    /* name */
1161          FALSE,                 /* partial_inplace */
1162          0,                     /* src_mask */
1163          0xfffc,                /* dst_mask */
1164          FALSE),                /* pcrel_offset */
1165
1166   /* Like R_PPC64_GOT16_LO, but for instructions with a DS field.  */
1167   HOWTO (R_PPC64_GOT16_LO_DS,   /* type */
1168          0,                     /* rightshift */
1169          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1170          16,                    /* bitsize */
1171          FALSE,                 /* pc_relative */
1172          0,                     /* bitpos */
1173          complain_overflow_dont, /* complain_on_overflow */
1174          ppc64_elf_unhandled_reloc, /* special_function */
1175          "R_PPC64_GOT16_LO_DS", /* name */
1176          FALSE,                 /* partial_inplace */
1177          0,                     /* src_mask */
1178          0xfffc,                /* dst_mask */
1179          FALSE),                /* pcrel_offset */
1180
1181   /* Like R_PPC64_PLT16_LO, but for instructions with a DS field.  */
1182   HOWTO (R_PPC64_PLT16_LO_DS,   /* type */
1183          0,                     /* rightshift */
1184          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1185          16,                    /* bitsize */
1186          FALSE,                 /* pc_relative */
1187          0,                     /* bitpos */
1188          complain_overflow_dont, /* complain_on_overflow */
1189          ppc64_elf_unhandled_reloc, /* special_function */
1190          "R_PPC64_PLT16_LO_DS", /* name */
1191          FALSE,                 /* partial_inplace */
1192          0,                     /* src_mask */
1193          0xfffc,                /* dst_mask */
1194          FALSE),                /* pcrel_offset */
1195
1196   /* Like R_PPC64_SECTOFF, but for instructions with a DS field.  */
1197   HOWTO (R_PPC64_SECTOFF_DS,    /* type */
1198          0,                     /* rightshift */
1199          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1200          16,                    /* bitsize */
1201          FALSE,                 /* pc_relative */
1202          0,                     /* bitpos */
1203          complain_overflow_signed, /* complain_on_overflow */
1204          ppc64_elf_sectoff_reloc, /* special_function */
1205          "R_PPC64_SECTOFF_DS",  /* name */
1206          FALSE,                 /* partial_inplace */
1207          0,                     /* src_mask */
1208          0xfffc,                /* dst_mask */
1209          FALSE),                /* pcrel_offset */
1210
1211   /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field.  */
1212   HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1213          0,                     /* rightshift */
1214          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1215          16,                    /* bitsize */
1216          FALSE,                 /* pc_relative */
1217          0,                     /* bitpos */
1218          complain_overflow_dont, /* complain_on_overflow */
1219          ppc64_elf_sectoff_reloc, /* special_function */
1220          "R_PPC64_SECTOFF_LO_DS",/* name */
1221          FALSE,                 /* partial_inplace */
1222          0,                     /* src_mask */
1223          0xfffc,                /* dst_mask */
1224          FALSE),                /* pcrel_offset */
1225
1226   /* Like R_PPC64_TOC16, but for instructions with a DS field.  */
1227   HOWTO (R_PPC64_TOC16_DS,      /* type */
1228          0,                     /* rightshift */
1229          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1230          16,                    /* bitsize */
1231          FALSE,                 /* pc_relative */
1232          0,                     /* bitpos */
1233          complain_overflow_signed, /* complain_on_overflow */
1234          ppc64_elf_toc_reloc,   /* special_function */
1235          "R_PPC64_TOC16_DS",    /* name */
1236          FALSE,                 /* partial_inplace */
1237          0,                     /* src_mask */
1238          0xfffc,                /* dst_mask */
1239          FALSE),                /* pcrel_offset */
1240
1241   /* Like R_PPC64_TOC16_LO, but for instructions with a DS field.  */
1242   HOWTO (R_PPC64_TOC16_LO_DS,   /* type */
1243          0,                     /* rightshift */
1244          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1245          16,                    /* bitsize */
1246          FALSE,                 /* pc_relative */
1247          0,                     /* bitpos */
1248          complain_overflow_dont, /* complain_on_overflow */
1249          ppc64_elf_toc_reloc,   /* special_function */
1250          "R_PPC64_TOC16_LO_DS", /* name */
1251          FALSE,                 /* partial_inplace */
1252          0,                     /* src_mask */
1253          0xfffc,                /* dst_mask */
1254          FALSE),                /* pcrel_offset */
1255
1256   /* Like R_PPC64_PLTGOT16, but for instructions with a DS field.  */
1257   /* FIXME: R_PPC64_PLTGOT16_DS not implemented.  */
1258   HOWTO (R_PPC64_PLTGOT16_DS,   /* type */
1259          0,                     /* rightshift */
1260          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1261          16,                    /* bitsize */
1262          FALSE,                 /* pc_relative */
1263          0,                     /* bitpos */
1264          complain_overflow_signed, /* complain_on_overflow */
1265          ppc64_elf_unhandled_reloc, /* special_function */
1266          "R_PPC64_PLTGOT16_DS", /* name */
1267          FALSE,                 /* partial_inplace */
1268          0,                     /* src_mask */
1269          0xfffc,                /* dst_mask */
1270          FALSE),                /* pcrel_offset */
1271
1272   /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field.  */
1273   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1274   HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1275          0,                     /* rightshift */
1276          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1277          16,                    /* bitsize */
1278          FALSE,                 /* pc_relative */
1279          0,                     /* bitpos */
1280          complain_overflow_dont, /* complain_on_overflow */
1281          ppc64_elf_unhandled_reloc, /* special_function */
1282          "R_PPC64_PLTGOT16_LO_DS",/* name */
1283          FALSE,                 /* partial_inplace */
1284          0,                     /* src_mask */
1285          0xfffc,                /* dst_mask */
1286          FALSE),                /* pcrel_offset */
1287
1288   /* Marker relocs for TLS.  */
1289   HOWTO (R_PPC64_TLS,
1290          0,                     /* rightshift */
1291          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1292          32,                    /* bitsize */
1293          FALSE,                 /* pc_relative */
1294          0,                     /* bitpos */
1295          complain_overflow_dont, /* complain_on_overflow */
1296          bfd_elf_generic_reloc, /* special_function */
1297          "R_PPC64_TLS",         /* name */
1298          FALSE,                 /* partial_inplace */
1299          0,                     /* src_mask */
1300          0,                     /* dst_mask */
1301          FALSE),                /* pcrel_offset */
1302
1303   HOWTO (R_PPC64_TLSGD,
1304          0,                     /* rightshift */
1305          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1306          32,                    /* bitsize */
1307          FALSE,                 /* pc_relative */
1308          0,                     /* bitpos */
1309          complain_overflow_dont, /* complain_on_overflow */
1310          bfd_elf_generic_reloc, /* special_function */
1311          "R_PPC64_TLSGD",       /* name */
1312          FALSE,                 /* partial_inplace */
1313          0,                     /* src_mask */
1314          0,                     /* dst_mask */
1315          FALSE),                /* pcrel_offset */
1316
1317   HOWTO (R_PPC64_TLSLD,
1318          0,                     /* rightshift */
1319          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1320          32,                    /* bitsize */
1321          FALSE,                 /* pc_relative */
1322          0,                     /* bitpos */
1323          complain_overflow_dont, /* complain_on_overflow */
1324          bfd_elf_generic_reloc, /* special_function */
1325          "R_PPC64_TLSLD",       /* name */
1326          FALSE,                 /* partial_inplace */
1327          0,                     /* src_mask */
1328          0,                     /* dst_mask */
1329          FALSE),                /* pcrel_offset */
1330
1331   HOWTO (R_PPC64_TOCSAVE,
1332          0,                     /* rightshift */
1333          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1334          32,                    /* bitsize */
1335          FALSE,                 /* pc_relative */
1336          0,                     /* bitpos */
1337          complain_overflow_dont, /* complain_on_overflow */
1338          bfd_elf_generic_reloc, /* special_function */
1339          "R_PPC64_TOCSAVE",     /* name */
1340          FALSE,                 /* partial_inplace */
1341          0,                     /* src_mask */
1342          0,                     /* dst_mask */
1343          FALSE),                /* pcrel_offset */
1344
1345   /* Computes the load module index of the load module that contains the
1346      definition of its TLS sym.  */
1347   HOWTO (R_PPC64_DTPMOD64,
1348          0,                     /* rightshift */
1349          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1350          64,                    /* bitsize */
1351          FALSE,                 /* pc_relative */
1352          0,                     /* bitpos */
1353          complain_overflow_dont, /* complain_on_overflow */
1354          ppc64_elf_unhandled_reloc, /* special_function */
1355          "R_PPC64_DTPMOD64",    /* name */
1356          FALSE,                 /* partial_inplace */
1357          0,                     /* src_mask */
1358          ONES (64),             /* dst_mask */
1359          FALSE),                /* pcrel_offset */
1360
1361   /* Computes a dtv-relative displacement, the difference between the value
1362      of sym+add and the base address of the thread-local storage block that
1363      contains the definition of sym, minus 0x8000.  */
1364   HOWTO (R_PPC64_DTPREL64,
1365          0,                     /* rightshift */
1366          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1367          64,                    /* bitsize */
1368          FALSE,                 /* pc_relative */
1369          0,                     /* bitpos */
1370          complain_overflow_dont, /* complain_on_overflow */
1371          ppc64_elf_unhandled_reloc, /* special_function */
1372          "R_PPC64_DTPREL64",    /* name */
1373          FALSE,                 /* partial_inplace */
1374          0,                     /* src_mask */
1375          ONES (64),             /* dst_mask */
1376          FALSE),                /* pcrel_offset */
1377
1378   /* A 16 bit dtprel reloc.  */
1379   HOWTO (R_PPC64_DTPREL16,
1380          0,                     /* rightshift */
1381          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1382          16,                    /* bitsize */
1383          FALSE,                 /* pc_relative */
1384          0,                     /* bitpos */
1385          complain_overflow_signed, /* complain_on_overflow */
1386          ppc64_elf_unhandled_reloc, /* special_function */
1387          "R_PPC64_DTPREL16",    /* name */
1388          FALSE,                 /* partial_inplace */
1389          0,                     /* src_mask */
1390          0xffff,                /* dst_mask */
1391          FALSE),                /* pcrel_offset */
1392
1393   /* Like DTPREL16, but no overflow.  */
1394   HOWTO (R_PPC64_DTPREL16_LO,
1395          0,                     /* rightshift */
1396          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1397          16,                    /* bitsize */
1398          FALSE,                 /* pc_relative */
1399          0,                     /* bitpos */
1400          complain_overflow_dont, /* complain_on_overflow */
1401          ppc64_elf_unhandled_reloc, /* special_function */
1402          "R_PPC64_DTPREL16_LO", /* name */
1403          FALSE,                 /* partial_inplace */
1404          0,                     /* src_mask */
1405          0xffff,                /* dst_mask */
1406          FALSE),                /* pcrel_offset */
1407
1408   /* Like DTPREL16_LO, but next higher group of 16 bits.  */
1409   HOWTO (R_PPC64_DTPREL16_HI,
1410          16,                    /* rightshift */
1411          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1412          16,                    /* bitsize */
1413          FALSE,                 /* pc_relative */
1414          0,                     /* bitpos */
1415          complain_overflow_signed, /* complain_on_overflow */
1416          ppc64_elf_unhandled_reloc, /* special_function */
1417          "R_PPC64_DTPREL16_HI", /* name */
1418          FALSE,                 /* partial_inplace */
1419          0,                     /* src_mask */
1420          0xffff,                /* dst_mask */
1421          FALSE),                /* pcrel_offset */
1422
1423   /* Like DTPREL16_HI, but adjust for low 16 bits.  */
1424   HOWTO (R_PPC64_DTPREL16_HA,
1425          16,                    /* rightshift */
1426          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1427          16,                    /* bitsize */
1428          FALSE,                 /* pc_relative */
1429          0,                     /* bitpos */
1430          complain_overflow_signed, /* complain_on_overflow */
1431          ppc64_elf_unhandled_reloc, /* special_function */
1432          "R_PPC64_DTPREL16_HA", /* name */
1433          FALSE,                 /* partial_inplace */
1434          0,                     /* src_mask */
1435          0xffff,                /* dst_mask */
1436          FALSE),                /* pcrel_offset */
1437
1438   /* Like DTPREL16_HI, but next higher group of 16 bits.  */
1439   HOWTO (R_PPC64_DTPREL16_HIGHER,
1440          32,                    /* rightshift */
1441          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1442          16,                    /* bitsize */
1443          FALSE,                 /* pc_relative */
1444          0,                     /* bitpos */
1445          complain_overflow_dont, /* complain_on_overflow */
1446          ppc64_elf_unhandled_reloc, /* special_function */
1447          "R_PPC64_DTPREL16_HIGHER", /* name */
1448          FALSE,                 /* partial_inplace */
1449          0,                     /* src_mask */
1450          0xffff,                /* dst_mask */
1451          FALSE),                /* pcrel_offset */
1452
1453   /* Like DTPREL16_HIGHER, but adjust for low 16 bits.  */
1454   HOWTO (R_PPC64_DTPREL16_HIGHERA,
1455          32,                    /* rightshift */
1456          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1457          16,                    /* bitsize */
1458          FALSE,                 /* pc_relative */
1459          0,                     /* bitpos */
1460          complain_overflow_dont, /* complain_on_overflow */
1461          ppc64_elf_unhandled_reloc, /* special_function */
1462          "R_PPC64_DTPREL16_HIGHERA", /* name */
1463          FALSE,                 /* partial_inplace */
1464          0,                     /* src_mask */
1465          0xffff,                /* dst_mask */
1466          FALSE),                /* pcrel_offset */
1467
1468   /* Like DTPREL16_HIGHER, but next higher group of 16 bits.  */
1469   HOWTO (R_PPC64_DTPREL16_HIGHEST,
1470          48,                    /* rightshift */
1471          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1472          16,                    /* bitsize */
1473          FALSE,                 /* pc_relative */
1474          0,                     /* bitpos */
1475          complain_overflow_dont, /* complain_on_overflow */
1476          ppc64_elf_unhandled_reloc, /* special_function */
1477          "R_PPC64_DTPREL16_HIGHEST", /* name */
1478          FALSE,                 /* partial_inplace */
1479          0,                     /* src_mask */
1480          0xffff,                /* dst_mask */
1481          FALSE),                /* pcrel_offset */
1482
1483   /* Like DTPREL16_HIGHEST, but adjust for low 16 bits.  */
1484   HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1485          48,                    /* rightshift */
1486          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1487          16,                    /* bitsize */
1488          FALSE,                 /* pc_relative */
1489          0,                     /* bitpos */
1490          complain_overflow_dont, /* complain_on_overflow */
1491          ppc64_elf_unhandled_reloc, /* special_function */
1492          "R_PPC64_DTPREL16_HIGHESTA", /* name */
1493          FALSE,                 /* partial_inplace */
1494          0,                     /* src_mask */
1495          0xffff,                /* dst_mask */
1496          FALSE),                /* pcrel_offset */
1497
1498   /* Like DTPREL16, but for insns with a DS field.  */
1499   HOWTO (R_PPC64_DTPREL16_DS,
1500          0,                     /* rightshift */
1501          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1502          16,                    /* bitsize */
1503          FALSE,                 /* pc_relative */
1504          0,                     /* bitpos */
1505          complain_overflow_signed, /* complain_on_overflow */
1506          ppc64_elf_unhandled_reloc, /* special_function */
1507          "R_PPC64_DTPREL16_DS", /* name */
1508          FALSE,                 /* partial_inplace */
1509          0,                     /* src_mask */
1510          0xfffc,                /* dst_mask */
1511          FALSE),                /* pcrel_offset */
1512
1513   /* Like DTPREL16_DS, but no overflow.  */
1514   HOWTO (R_PPC64_DTPREL16_LO_DS,
1515          0,                     /* rightshift */
1516          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1517          16,                    /* bitsize */
1518          FALSE,                 /* pc_relative */
1519          0,                     /* bitpos */
1520          complain_overflow_dont, /* complain_on_overflow */
1521          ppc64_elf_unhandled_reloc, /* special_function */
1522          "R_PPC64_DTPREL16_LO_DS", /* name */
1523          FALSE,                 /* partial_inplace */
1524          0,                     /* src_mask */
1525          0xfffc,                /* dst_mask */
1526          FALSE),                /* pcrel_offset */
1527
1528   /* Computes a tp-relative displacement, the difference between the value of
1529      sym+add and the value of the thread pointer (r13).  */
1530   HOWTO (R_PPC64_TPREL64,
1531          0,                     /* rightshift */
1532          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1533          64,                    /* bitsize */
1534          FALSE,                 /* pc_relative */
1535          0,                     /* bitpos */
1536          complain_overflow_dont, /* complain_on_overflow */
1537          ppc64_elf_unhandled_reloc, /* special_function */
1538          "R_PPC64_TPREL64",     /* name */
1539          FALSE,                 /* partial_inplace */
1540          0,                     /* src_mask */
1541          ONES (64),             /* dst_mask */
1542          FALSE),                /* pcrel_offset */
1543
1544   /* A 16 bit tprel reloc.  */
1545   HOWTO (R_PPC64_TPREL16,
1546          0,                     /* rightshift */
1547          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1548          16,                    /* bitsize */
1549          FALSE,                 /* pc_relative */
1550          0,                     /* bitpos */
1551          complain_overflow_signed, /* complain_on_overflow */
1552          ppc64_elf_unhandled_reloc, /* special_function */
1553          "R_PPC64_TPREL16",     /* name */
1554          FALSE,                 /* partial_inplace */
1555          0,                     /* src_mask */
1556          0xffff,                /* dst_mask */
1557          FALSE),                /* pcrel_offset */
1558
1559   /* Like TPREL16, but no overflow.  */
1560   HOWTO (R_PPC64_TPREL16_LO,
1561          0,                     /* rightshift */
1562          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1563          16,                    /* bitsize */
1564          FALSE,                 /* pc_relative */
1565          0,                     /* bitpos */
1566          complain_overflow_dont, /* complain_on_overflow */
1567          ppc64_elf_unhandled_reloc, /* special_function */
1568          "R_PPC64_TPREL16_LO",  /* name */
1569          FALSE,                 /* partial_inplace */
1570          0,                     /* src_mask */
1571          0xffff,                /* dst_mask */
1572          FALSE),                /* pcrel_offset */
1573
1574   /* Like TPREL16_LO, but next higher group of 16 bits.  */
1575   HOWTO (R_PPC64_TPREL16_HI,
1576          16,                    /* rightshift */
1577          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1578          16,                    /* bitsize */
1579          FALSE,                 /* pc_relative */
1580          0,                     /* bitpos */
1581          complain_overflow_signed, /* complain_on_overflow */
1582          ppc64_elf_unhandled_reloc, /* special_function */
1583          "R_PPC64_TPREL16_HI",  /* name */
1584          FALSE,                 /* partial_inplace */
1585          0,                     /* src_mask */
1586          0xffff,                /* dst_mask */
1587          FALSE),                /* pcrel_offset */
1588
1589   /* Like TPREL16_HI, but adjust for low 16 bits.  */
1590   HOWTO (R_PPC64_TPREL16_HA,
1591          16,                    /* rightshift */
1592          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1593          16,                    /* bitsize */
1594          FALSE,                 /* pc_relative */
1595          0,                     /* bitpos */
1596          complain_overflow_signed, /* complain_on_overflow */
1597          ppc64_elf_unhandled_reloc, /* special_function */
1598          "R_PPC64_TPREL16_HA",  /* name */
1599          FALSE,                 /* partial_inplace */
1600          0,                     /* src_mask */
1601          0xffff,                /* dst_mask */
1602          FALSE),                /* pcrel_offset */
1603
1604   /* Like TPREL16_HI, but next higher group of 16 bits.  */
1605   HOWTO (R_PPC64_TPREL16_HIGHER,
1606          32,                    /* rightshift */
1607          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1608          16,                    /* bitsize */
1609          FALSE,                 /* pc_relative */
1610          0,                     /* bitpos */
1611          complain_overflow_dont, /* complain_on_overflow */
1612          ppc64_elf_unhandled_reloc, /* special_function */
1613          "R_PPC64_TPREL16_HIGHER",      /* name */
1614          FALSE,                 /* partial_inplace */
1615          0,                     /* src_mask */
1616          0xffff,                /* dst_mask */
1617          FALSE),                /* pcrel_offset */
1618
1619   /* Like TPREL16_HIGHER, but adjust for low 16 bits.  */
1620   HOWTO (R_PPC64_TPREL16_HIGHERA,
1621          32,                    /* rightshift */
1622          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1623          16,                    /* bitsize */
1624          FALSE,                 /* pc_relative */
1625          0,                     /* bitpos */
1626          complain_overflow_dont, /* complain_on_overflow */
1627          ppc64_elf_unhandled_reloc, /* special_function */
1628          "R_PPC64_TPREL16_HIGHERA", /* name */
1629          FALSE,                 /* partial_inplace */
1630          0,                     /* src_mask */
1631          0xffff,                /* dst_mask */
1632          FALSE),                /* pcrel_offset */
1633
1634   /* Like TPREL16_HIGHER, but next higher group of 16 bits.  */
1635   HOWTO (R_PPC64_TPREL16_HIGHEST,
1636          48,                    /* rightshift */
1637          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1638          16,                    /* bitsize */
1639          FALSE,                 /* pc_relative */
1640          0,                     /* bitpos */
1641          complain_overflow_dont, /* complain_on_overflow */
1642          ppc64_elf_unhandled_reloc, /* special_function */
1643          "R_PPC64_TPREL16_HIGHEST", /* name */
1644          FALSE,                 /* partial_inplace */
1645          0,                     /* src_mask */
1646          0xffff,                /* dst_mask */
1647          FALSE),                /* pcrel_offset */
1648
1649   /* Like TPREL16_HIGHEST, but adjust for low 16 bits.  */
1650   HOWTO (R_PPC64_TPREL16_HIGHESTA,
1651          48,                    /* rightshift */
1652          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1653          16,                    /* bitsize */
1654          FALSE,                 /* pc_relative */
1655          0,                     /* bitpos */
1656          complain_overflow_dont, /* complain_on_overflow */
1657          ppc64_elf_unhandled_reloc, /* special_function */
1658          "R_PPC64_TPREL16_HIGHESTA", /* name */
1659          FALSE,                 /* partial_inplace */
1660          0,                     /* src_mask */
1661          0xffff,                /* dst_mask */
1662          FALSE),                /* pcrel_offset */
1663
1664   /* Like TPREL16, but for insns with a DS field.  */
1665   HOWTO (R_PPC64_TPREL16_DS,
1666          0,                     /* rightshift */
1667          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1668          16,                    /* bitsize */
1669          FALSE,                 /* pc_relative */
1670          0,                     /* bitpos */
1671          complain_overflow_signed, /* complain_on_overflow */
1672          ppc64_elf_unhandled_reloc, /* special_function */
1673          "R_PPC64_TPREL16_DS",  /* name */
1674          FALSE,                 /* partial_inplace */
1675          0,                     /* src_mask */
1676          0xfffc,                /* dst_mask */
1677          FALSE),                /* pcrel_offset */
1678
1679   /* Like TPREL16_DS, but no overflow.  */
1680   HOWTO (R_PPC64_TPREL16_LO_DS,
1681          0,                     /* rightshift */
1682          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1683          16,                    /* bitsize */
1684          FALSE,                 /* pc_relative */
1685          0,                     /* bitpos */
1686          complain_overflow_dont, /* complain_on_overflow */
1687          ppc64_elf_unhandled_reloc, /* special_function */
1688          "R_PPC64_TPREL16_LO_DS", /* name */
1689          FALSE,                 /* partial_inplace */
1690          0,                     /* src_mask */
1691          0xfffc,                /* dst_mask */
1692          FALSE),                /* pcrel_offset */
1693
1694   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1695      with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1696      to the first entry relative to the TOC base (r2).  */
1697   HOWTO (R_PPC64_GOT_TLSGD16,
1698          0,                     /* rightshift */
1699          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1700          16,                    /* bitsize */
1701          FALSE,                 /* pc_relative */
1702          0,                     /* bitpos */
1703          complain_overflow_signed, /* complain_on_overflow */
1704          ppc64_elf_unhandled_reloc, /* special_function */
1705          "R_PPC64_GOT_TLSGD16", /* name */
1706          FALSE,                 /* partial_inplace */
1707          0,                     /* src_mask */
1708          0xffff,                /* dst_mask */
1709          FALSE),                /* pcrel_offset */
1710
1711   /* Like GOT_TLSGD16, but no overflow.  */
1712   HOWTO (R_PPC64_GOT_TLSGD16_LO,
1713          0,                     /* rightshift */
1714          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1715          16,                    /* bitsize */
1716          FALSE,                 /* pc_relative */
1717          0,                     /* bitpos */
1718          complain_overflow_dont, /* complain_on_overflow */
1719          ppc64_elf_unhandled_reloc, /* special_function */
1720          "R_PPC64_GOT_TLSGD16_LO", /* name */
1721          FALSE,                 /* partial_inplace */
1722          0,                     /* src_mask */
1723          0xffff,                /* dst_mask */
1724          FALSE),                /* pcrel_offset */
1725
1726   /* Like GOT_TLSGD16_LO, but next higher group of 16 bits.  */
1727   HOWTO (R_PPC64_GOT_TLSGD16_HI,
1728          16,                    /* rightshift */
1729          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1730          16,                    /* bitsize */
1731          FALSE,                 /* pc_relative */
1732          0,                     /* bitpos */
1733          complain_overflow_signed, /* complain_on_overflow */
1734          ppc64_elf_unhandled_reloc, /* special_function */
1735          "R_PPC64_GOT_TLSGD16_HI", /* name */
1736          FALSE,                 /* partial_inplace */
1737          0,                     /* src_mask */
1738          0xffff,                /* dst_mask */
1739          FALSE),                /* pcrel_offset */
1740
1741   /* Like GOT_TLSGD16_HI, but adjust for low 16 bits.  */
1742   HOWTO (R_PPC64_GOT_TLSGD16_HA,
1743          16,                    /* rightshift */
1744          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1745          16,                    /* bitsize */
1746          FALSE,                 /* pc_relative */
1747          0,                     /* bitpos */
1748          complain_overflow_signed, /* complain_on_overflow */
1749          ppc64_elf_unhandled_reloc, /* special_function */
1750          "R_PPC64_GOT_TLSGD16_HA", /* name */
1751          FALSE,                 /* partial_inplace */
1752          0,                     /* src_mask */
1753          0xffff,                /* dst_mask */
1754          FALSE),                /* pcrel_offset */
1755
1756   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1757      with values (sym+add)@dtpmod and zero, and computes the offset to the
1758      first entry relative to the TOC base (r2).  */
1759   HOWTO (R_PPC64_GOT_TLSLD16,
1760          0,                     /* rightshift */
1761          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1762          16,                    /* bitsize */
1763          FALSE,                 /* pc_relative */
1764          0,                     /* bitpos */
1765          complain_overflow_signed, /* complain_on_overflow */
1766          ppc64_elf_unhandled_reloc, /* special_function */
1767          "R_PPC64_GOT_TLSLD16", /* name */
1768          FALSE,                 /* partial_inplace */
1769          0,                     /* src_mask */
1770          0xffff,                /* dst_mask */
1771          FALSE),                /* pcrel_offset */
1772
1773   /* Like GOT_TLSLD16, but no overflow.  */
1774   HOWTO (R_PPC64_GOT_TLSLD16_LO,
1775          0,                     /* rightshift */
1776          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1777          16,                    /* bitsize */
1778          FALSE,                 /* pc_relative */
1779          0,                     /* bitpos */
1780          complain_overflow_dont, /* complain_on_overflow */
1781          ppc64_elf_unhandled_reloc, /* special_function */
1782          "R_PPC64_GOT_TLSLD16_LO", /* name */
1783          FALSE,                 /* partial_inplace */
1784          0,                     /* src_mask */
1785          0xffff,                /* dst_mask */
1786          FALSE),                /* pcrel_offset */
1787
1788   /* Like GOT_TLSLD16_LO, but next higher group of 16 bits.  */
1789   HOWTO (R_PPC64_GOT_TLSLD16_HI,
1790          16,                    /* rightshift */
1791          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1792          16,                    /* bitsize */
1793          FALSE,                 /* pc_relative */
1794          0,                     /* bitpos */
1795          complain_overflow_signed, /* complain_on_overflow */
1796          ppc64_elf_unhandled_reloc, /* special_function */
1797          "R_PPC64_GOT_TLSLD16_HI", /* name */
1798          FALSE,                 /* partial_inplace */
1799          0,                     /* src_mask */
1800          0xffff,                /* dst_mask */
1801          FALSE),                /* pcrel_offset */
1802
1803   /* Like GOT_TLSLD16_HI, but adjust for low 16 bits.  */
1804   HOWTO (R_PPC64_GOT_TLSLD16_HA,
1805          16,                    /* rightshift */
1806          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1807          16,                    /* bitsize */
1808          FALSE,                 /* pc_relative */
1809          0,                     /* bitpos */
1810          complain_overflow_signed, /* complain_on_overflow */
1811          ppc64_elf_unhandled_reloc, /* special_function */
1812          "R_PPC64_GOT_TLSLD16_HA", /* name */
1813          FALSE,                 /* partial_inplace */
1814          0,                     /* src_mask */
1815          0xffff,                /* dst_mask */
1816          FALSE),                /* pcrel_offset */
1817
1818   /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1819      the offset to the entry relative to the TOC base (r2).  */
1820   HOWTO (R_PPC64_GOT_DTPREL16_DS,
1821          0,                     /* rightshift */
1822          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1823          16,                    /* bitsize */
1824          FALSE,                 /* pc_relative */
1825          0,                     /* bitpos */
1826          complain_overflow_signed, /* complain_on_overflow */
1827          ppc64_elf_unhandled_reloc, /* special_function */
1828          "R_PPC64_GOT_DTPREL16_DS", /* name */
1829          FALSE,                 /* partial_inplace */
1830          0,                     /* src_mask */
1831          0xfffc,                /* dst_mask */
1832          FALSE),                /* pcrel_offset */
1833
1834   /* Like GOT_DTPREL16_DS, but no overflow.  */
1835   HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1836          0,                     /* rightshift */
1837          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1838          16,                    /* bitsize */
1839          FALSE,                 /* pc_relative */
1840          0,                     /* bitpos */
1841          complain_overflow_dont, /* complain_on_overflow */
1842          ppc64_elf_unhandled_reloc, /* special_function */
1843          "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1844          FALSE,                 /* partial_inplace */
1845          0,                     /* src_mask */
1846          0xfffc,                /* dst_mask */
1847          FALSE),                /* pcrel_offset */
1848
1849   /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits.  */
1850   HOWTO (R_PPC64_GOT_DTPREL16_HI,
1851          16,                    /* rightshift */
1852          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1853          16,                    /* bitsize */
1854          FALSE,                 /* pc_relative */
1855          0,                     /* bitpos */
1856          complain_overflow_signed, /* complain_on_overflow */
1857          ppc64_elf_unhandled_reloc, /* special_function */
1858          "R_PPC64_GOT_DTPREL16_HI", /* name */
1859          FALSE,                 /* partial_inplace */
1860          0,                     /* src_mask */
1861          0xffff,                /* dst_mask */
1862          FALSE),                /* pcrel_offset */
1863
1864   /* Like GOT_DTPREL16_HI, but adjust for low 16 bits.  */
1865   HOWTO (R_PPC64_GOT_DTPREL16_HA,
1866          16,                    /* rightshift */
1867          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1868          16,                    /* bitsize */
1869          FALSE,                 /* pc_relative */
1870          0,                     /* bitpos */
1871          complain_overflow_signed, /* complain_on_overflow */
1872          ppc64_elf_unhandled_reloc, /* special_function */
1873          "R_PPC64_GOT_DTPREL16_HA", /* name */
1874          FALSE,                 /* partial_inplace */
1875          0,                     /* src_mask */
1876          0xffff,                /* dst_mask */
1877          FALSE),                /* pcrel_offset */
1878
1879   /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1880      offset to the entry relative to the TOC base (r2).  */
1881   HOWTO (R_PPC64_GOT_TPREL16_DS,
1882          0,                     /* rightshift */
1883          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1884          16,                    /* bitsize */
1885          FALSE,                 /* pc_relative */
1886          0,                     /* bitpos */
1887          complain_overflow_signed, /* complain_on_overflow */
1888          ppc64_elf_unhandled_reloc, /* special_function */
1889          "R_PPC64_GOT_TPREL16_DS", /* name */
1890          FALSE,                 /* partial_inplace */
1891          0,                     /* src_mask */
1892          0xfffc,                /* dst_mask */
1893          FALSE),                /* pcrel_offset */
1894
1895   /* Like GOT_TPREL16_DS, but no overflow.  */
1896   HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1897          0,                     /* rightshift */
1898          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1899          16,                    /* bitsize */
1900          FALSE,                 /* pc_relative */
1901          0,                     /* bitpos */
1902          complain_overflow_dont, /* complain_on_overflow */
1903          ppc64_elf_unhandled_reloc, /* special_function */
1904          "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1905          FALSE,                 /* partial_inplace */
1906          0,                     /* src_mask */
1907          0xfffc,                /* dst_mask */
1908          FALSE),                /* pcrel_offset */
1909
1910   /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits.  */
1911   HOWTO (R_PPC64_GOT_TPREL16_HI,
1912          16,                    /* rightshift */
1913          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1914          16,                    /* bitsize */
1915          FALSE,                 /* pc_relative */
1916          0,                     /* bitpos */
1917          complain_overflow_signed, /* complain_on_overflow */
1918          ppc64_elf_unhandled_reloc, /* special_function */
1919          "R_PPC64_GOT_TPREL16_HI", /* name */
1920          FALSE,                 /* partial_inplace */
1921          0,                     /* src_mask */
1922          0xffff,                /* dst_mask */
1923          FALSE),                /* pcrel_offset */
1924
1925   /* Like GOT_TPREL16_HI, but adjust for low 16 bits.  */
1926   HOWTO (R_PPC64_GOT_TPREL16_HA,
1927          16,                    /* rightshift */
1928          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1929          16,                    /* bitsize */
1930          FALSE,                 /* pc_relative */
1931          0,                     /* bitpos */
1932          complain_overflow_signed, /* complain_on_overflow */
1933          ppc64_elf_unhandled_reloc, /* special_function */
1934          "R_PPC64_GOT_TPREL16_HA", /* name */
1935          FALSE,                 /* partial_inplace */
1936          0,                     /* src_mask */
1937          0xffff,                /* dst_mask */
1938          FALSE),                /* pcrel_offset */
1939
1940   HOWTO (R_PPC64_JMP_IREL,      /* type */
1941          0,                     /* rightshift */
1942          0,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1943          0,                     /* bitsize */
1944          FALSE,                 /* pc_relative */
1945          0,                     /* bitpos */
1946          complain_overflow_dont, /* complain_on_overflow */
1947          ppc64_elf_unhandled_reloc, /* special_function */
1948          "R_PPC64_JMP_IREL",    /* name */
1949          FALSE,                 /* partial_inplace */
1950          0,                     /* src_mask */
1951          0,                     /* dst_mask */
1952          FALSE),                /* pcrel_offset */
1953
1954   HOWTO (R_PPC64_IRELATIVE,     /* type */
1955          0,                     /* rightshift */
1956          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1957          64,                    /* bitsize */
1958          FALSE,                 /* pc_relative */
1959          0,                     /* bitpos */
1960          complain_overflow_dont, /* complain_on_overflow */
1961          bfd_elf_generic_reloc, /* special_function */
1962          "R_PPC64_IRELATIVE",   /* name */
1963          FALSE,                 /* partial_inplace */
1964          0,                     /* src_mask */
1965          ONES (64),             /* dst_mask */
1966          FALSE),                /* pcrel_offset */
1967
1968   /* A 16 bit relative relocation.  */
1969   HOWTO (R_PPC64_REL16,         /* type */
1970          0,                     /* rightshift */
1971          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1972          16,                    /* bitsize */
1973          TRUE,                  /* pc_relative */
1974          0,                     /* bitpos */
1975          complain_overflow_signed, /* complain_on_overflow */
1976          bfd_elf_generic_reloc, /* special_function */
1977          "R_PPC64_REL16",       /* name */
1978          FALSE,                 /* partial_inplace */
1979          0,                     /* src_mask */
1980          0xffff,                /* dst_mask */
1981          TRUE),                 /* pcrel_offset */
1982
1983   /* A 16 bit relative relocation without overflow.  */
1984   HOWTO (R_PPC64_REL16_LO,      /* type */
1985          0,                     /* rightshift */
1986          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1987          16,                    /* bitsize */
1988          TRUE,                  /* pc_relative */
1989          0,                     /* bitpos */
1990          complain_overflow_dont,/* complain_on_overflow */
1991          bfd_elf_generic_reloc, /* special_function */
1992          "R_PPC64_REL16_LO",    /* name */
1993          FALSE,                 /* partial_inplace */
1994          0,                     /* src_mask */
1995          0xffff,                /* dst_mask */
1996          TRUE),                 /* pcrel_offset */
1997
1998   /* The high order 16 bits of a relative address.  */
1999   HOWTO (R_PPC64_REL16_HI,      /* type */
2000          16,                    /* rightshift */
2001          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2002          16,                    /* bitsize */
2003          TRUE,                  /* pc_relative */
2004          0,                     /* bitpos */
2005          complain_overflow_signed, /* complain_on_overflow */
2006          bfd_elf_generic_reloc, /* special_function */
2007          "R_PPC64_REL16_HI",    /* name */
2008          FALSE,                 /* partial_inplace */
2009          0,                     /* src_mask */
2010          0xffff,                /* dst_mask */
2011          TRUE),                 /* pcrel_offset */
2012
2013   /* The high order 16 bits of a relative address, plus 1 if the contents of
2014      the low 16 bits, treated as a signed number, is negative.  */
2015   HOWTO (R_PPC64_REL16_HA,      /* type */
2016          16,                    /* rightshift */
2017          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2018          16,                    /* bitsize */
2019          TRUE,                  /* pc_relative */
2020          0,                     /* bitpos */
2021          complain_overflow_signed, /* complain_on_overflow */
2022          ppc64_elf_ha_reloc,    /* special_function */
2023          "R_PPC64_REL16_HA",    /* name */
2024          FALSE,                 /* partial_inplace */
2025          0,                     /* src_mask */
2026          0xffff,                /* dst_mask */
2027          TRUE),                 /* pcrel_offset */
2028
2029   /* Like R_PPC64_REL16_HA but for split field in addpcis.  */
2030   HOWTO (R_PPC64_REL16DX_HA,    /* type */
2031          16,                    /* rightshift */
2032          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2033          16,                    /* bitsize */
2034          TRUE,                  /* pc_relative */
2035          0,                     /* bitpos */
2036          complain_overflow_signed, /* complain_on_overflow */
2037          ppc64_elf_ha_reloc,    /* special_function */
2038          "R_PPC64_REL16DX_HA",  /* name */
2039          FALSE,                 /* partial_inplace */
2040          0,                     /* src_mask */
2041          0x1fffc1,              /* dst_mask */
2042          TRUE),                 /* pcrel_offset */
2043
2044   /* Like R_PPC64_ADDR16_HI, but no overflow.  */
2045   HOWTO (R_PPC64_ADDR16_HIGH,   /* type */
2046          16,                    /* rightshift */
2047          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2048          16,                    /* bitsize */
2049          FALSE,                 /* pc_relative */
2050          0,                     /* bitpos */
2051          complain_overflow_dont, /* complain_on_overflow */
2052          bfd_elf_generic_reloc, /* special_function */
2053          "R_PPC64_ADDR16_HIGH", /* name */
2054          FALSE,                 /* partial_inplace */
2055          0,                     /* src_mask */
2056          0xffff,                /* dst_mask */
2057          FALSE),                /* pcrel_offset */
2058
2059   /* Like R_PPC64_ADDR16_HA, but no overflow.  */
2060   HOWTO (R_PPC64_ADDR16_HIGHA,  /* type */
2061          16,                    /* rightshift */
2062          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2063          16,                    /* bitsize */
2064          FALSE,                 /* pc_relative */
2065          0,                     /* bitpos */
2066          complain_overflow_dont, /* complain_on_overflow */
2067          ppc64_elf_ha_reloc,    /* special_function */
2068          "R_PPC64_ADDR16_HIGHA",        /* name */
2069          FALSE,                 /* partial_inplace */
2070          0,                     /* src_mask */
2071          0xffff,                /* dst_mask */
2072          FALSE),                /* pcrel_offset */
2073
2074   /* Like R_PPC64_DTPREL16_HI, but no overflow.  */
2075   HOWTO (R_PPC64_DTPREL16_HIGH,
2076          16,                    /* rightshift */
2077          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2078          16,                    /* bitsize */
2079          FALSE,                 /* pc_relative */
2080          0,                     /* bitpos */
2081          complain_overflow_dont, /* complain_on_overflow */
2082          ppc64_elf_unhandled_reloc, /* special_function */
2083          "R_PPC64_DTPREL16_HIGH", /* name */
2084          FALSE,                 /* partial_inplace */
2085          0,                     /* src_mask */
2086          0xffff,                /* dst_mask */
2087          FALSE),                /* pcrel_offset */
2088
2089   /* Like R_PPC64_DTPREL16_HA, but no overflow.  */
2090   HOWTO (R_PPC64_DTPREL16_HIGHA,
2091          16,                    /* rightshift */
2092          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2093          16,                    /* bitsize */
2094          FALSE,                 /* pc_relative */
2095          0,                     /* bitpos */
2096          complain_overflow_dont, /* complain_on_overflow */
2097          ppc64_elf_unhandled_reloc, /* special_function */
2098          "R_PPC64_DTPREL16_HIGHA", /* name */
2099          FALSE,                 /* partial_inplace */
2100          0,                     /* src_mask */
2101          0xffff,                /* dst_mask */
2102          FALSE),                /* pcrel_offset */
2103
2104   /* Like R_PPC64_TPREL16_HI, but no overflow.  */
2105   HOWTO (R_PPC64_TPREL16_HIGH,
2106          16,                    /* rightshift */
2107          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2108          16,                    /* bitsize */
2109          FALSE,                 /* pc_relative */
2110          0,                     /* bitpos */
2111          complain_overflow_dont, /* complain_on_overflow */
2112          ppc64_elf_unhandled_reloc, /* special_function */
2113          "R_PPC64_TPREL16_HIGH",        /* name */
2114          FALSE,                 /* partial_inplace */
2115          0,                     /* src_mask */
2116          0xffff,                /* dst_mask */
2117          FALSE),                /* pcrel_offset */
2118
2119   /* Like R_PPC64_TPREL16_HA, but no overflow.  */
2120   HOWTO (R_PPC64_TPREL16_HIGHA,
2121          16,                    /* rightshift */
2122          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2123          16,                    /* bitsize */
2124          FALSE,                 /* pc_relative */
2125          0,                     /* bitpos */
2126          complain_overflow_dont, /* complain_on_overflow */
2127          ppc64_elf_unhandled_reloc, /* special_function */
2128          "R_PPC64_TPREL16_HIGHA",       /* name */
2129          FALSE,                 /* partial_inplace */
2130          0,                     /* src_mask */
2131          0xffff,                /* dst_mask */
2132          FALSE),                /* pcrel_offset */
2133
2134   /* Marker reloc on ELFv2 large-model function entry.  */
2135   HOWTO (R_PPC64_ENTRY,
2136          0,                     /* rightshift */
2137          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2138          32,                    /* bitsize */
2139          FALSE,                 /* pc_relative */
2140          0,                     /* bitpos */
2141          complain_overflow_dont, /* complain_on_overflow */
2142          bfd_elf_generic_reloc, /* special_function */
2143          "R_PPC64_ENTRY",       /* name */
2144          FALSE,                 /* partial_inplace */
2145          0,                     /* src_mask */
2146          0,                     /* dst_mask */
2147          FALSE),                /* pcrel_offset */
2148
2149   /* Like ADDR64, but use local entry point of function.  */
2150   HOWTO (R_PPC64_ADDR64_LOCAL,  /* type */
2151          0,                     /* rightshift */
2152          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2153          64,                    /* bitsize */
2154          FALSE,                 /* pc_relative */
2155          0,                     /* bitpos */
2156          complain_overflow_dont, /* complain_on_overflow */
2157          bfd_elf_generic_reloc, /* special_function */
2158          "R_PPC64_ADDR64_LOCAL", /* name */
2159          FALSE,                 /* partial_inplace */
2160          0,                     /* src_mask */
2161          ONES (64),             /* dst_mask */
2162          FALSE),                /* pcrel_offset */
2163
2164   /* GNU extension to record C++ vtable hierarchy.  */
2165   HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2166          0,                     /* rightshift */
2167          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2168          0,                     /* bitsize */
2169          FALSE,                 /* pc_relative */
2170          0,                     /* bitpos */
2171          complain_overflow_dont, /* complain_on_overflow */
2172          NULL,                  /* special_function */
2173          "R_PPC64_GNU_VTINHERIT", /* name */
2174          FALSE,                 /* partial_inplace */
2175          0,                     /* src_mask */
2176          0,                     /* dst_mask */
2177          FALSE),                /* pcrel_offset */
2178
2179   /* GNU extension to record C++ vtable member usage.  */
2180   HOWTO (R_PPC64_GNU_VTENTRY,   /* type */
2181          0,                     /* rightshift */
2182          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2183          0,                     /* bitsize */
2184          FALSE,                 /* pc_relative */
2185          0,                     /* bitpos */
2186          complain_overflow_dont, /* complain_on_overflow */
2187          NULL,                  /* special_function */
2188          "R_PPC64_GNU_VTENTRY", /* name */
2189          FALSE,                 /* partial_inplace */
2190          0,                     /* src_mask */
2191          0,                     /* dst_mask */
2192          FALSE),                /* pcrel_offset */
2193 };
2194
2195 \f
2196 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2197    be done.  */
2198
2199 static void
2200 ppc_howto_init (void)
2201 {
2202   unsigned int i, type;
2203
2204   for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2205     {
2206       type = ppc64_elf_howto_raw[i].type;
2207       BFD_ASSERT (type < ARRAY_SIZE (ppc64_elf_howto_table));
2208       ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2209     }
2210 }
2211
2212 static reloc_howto_type *
2213 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2214                              bfd_reloc_code_real_type code)
2215 {
2216   enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2217
2218   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2219     /* Initialize howto table if needed.  */
2220     ppc_howto_init ();
2221
2222   switch (code)
2223     {
2224     default:
2225       return NULL;
2226
2227     case BFD_RELOC_NONE:                        r = R_PPC64_NONE;
2228       break;
2229     case BFD_RELOC_32:                          r = R_PPC64_ADDR32;
2230       break;
2231     case BFD_RELOC_PPC_BA26:                    r = R_PPC64_ADDR24;
2232       break;
2233     case BFD_RELOC_16:                          r = R_PPC64_ADDR16;
2234       break;
2235     case BFD_RELOC_LO16:                        r = R_PPC64_ADDR16_LO;
2236       break;
2237     case BFD_RELOC_HI16:                        r = R_PPC64_ADDR16_HI;
2238       break;
2239     case BFD_RELOC_PPC64_ADDR16_HIGH:           r = R_PPC64_ADDR16_HIGH;
2240       break;
2241     case BFD_RELOC_HI16_S:                      r = R_PPC64_ADDR16_HA;
2242       break;
2243     case BFD_RELOC_PPC64_ADDR16_HIGHA:          r = R_PPC64_ADDR16_HIGHA;
2244       break;
2245     case BFD_RELOC_PPC_BA16:                    r = R_PPC64_ADDR14;
2246       break;
2247     case BFD_RELOC_PPC_BA16_BRTAKEN:            r = R_PPC64_ADDR14_BRTAKEN;
2248       break;
2249     case BFD_RELOC_PPC_BA16_BRNTAKEN:           r = R_PPC64_ADDR14_BRNTAKEN;
2250       break;
2251     case BFD_RELOC_PPC_B26:                     r = R_PPC64_REL24;
2252       break;
2253     case BFD_RELOC_PPC_B16:                     r = R_PPC64_REL14;
2254       break;
2255     case BFD_RELOC_PPC_B16_BRTAKEN:             r = R_PPC64_REL14_BRTAKEN;
2256       break;
2257     case BFD_RELOC_PPC_B16_BRNTAKEN:            r = R_PPC64_REL14_BRNTAKEN;
2258       break;
2259     case BFD_RELOC_16_GOTOFF:                   r = R_PPC64_GOT16;
2260       break;
2261     case BFD_RELOC_LO16_GOTOFF:                 r = R_PPC64_GOT16_LO;
2262       break;
2263     case BFD_RELOC_HI16_GOTOFF:                 r = R_PPC64_GOT16_HI;
2264       break;
2265     case BFD_RELOC_HI16_S_GOTOFF:               r = R_PPC64_GOT16_HA;
2266       break;
2267     case BFD_RELOC_PPC_COPY:                    r = R_PPC64_COPY;
2268       break;
2269     case BFD_RELOC_PPC_GLOB_DAT:                r = R_PPC64_GLOB_DAT;
2270       break;
2271     case BFD_RELOC_32_PCREL:                    r = R_PPC64_REL32;
2272       break;
2273     case BFD_RELOC_32_PLTOFF:                   r = R_PPC64_PLT32;
2274       break;
2275     case BFD_RELOC_32_PLT_PCREL:                r = R_PPC64_PLTREL32;
2276       break;
2277     case BFD_RELOC_LO16_PLTOFF:                 r = R_PPC64_PLT16_LO;
2278       break;
2279     case BFD_RELOC_HI16_PLTOFF:                 r = R_PPC64_PLT16_HI;
2280       break;
2281     case BFD_RELOC_HI16_S_PLTOFF:               r = R_PPC64_PLT16_HA;
2282       break;
2283     case BFD_RELOC_16_BASEREL:                  r = R_PPC64_SECTOFF;
2284       break;
2285     case BFD_RELOC_LO16_BASEREL:                r = R_PPC64_SECTOFF_LO;
2286       break;
2287     case BFD_RELOC_HI16_BASEREL:                r = R_PPC64_SECTOFF_HI;
2288       break;
2289     case BFD_RELOC_HI16_S_BASEREL:              r = R_PPC64_SECTOFF_HA;
2290       break;
2291     case BFD_RELOC_CTOR:                        r = R_PPC64_ADDR64;
2292       break;
2293     case BFD_RELOC_64:                          r = R_PPC64_ADDR64;
2294       break;
2295     case BFD_RELOC_PPC64_HIGHER:                r = R_PPC64_ADDR16_HIGHER;
2296       break;
2297     case BFD_RELOC_PPC64_HIGHER_S:              r = R_PPC64_ADDR16_HIGHERA;
2298       break;
2299     case BFD_RELOC_PPC64_HIGHEST:               r = R_PPC64_ADDR16_HIGHEST;
2300       break;
2301     case BFD_RELOC_PPC64_HIGHEST_S:             r = R_PPC64_ADDR16_HIGHESTA;
2302       break;
2303     case BFD_RELOC_64_PCREL:                    r = R_PPC64_REL64;
2304       break;
2305     case BFD_RELOC_64_PLTOFF:                   r = R_PPC64_PLT64;
2306       break;
2307     case BFD_RELOC_64_PLT_PCREL:                r = R_PPC64_PLTREL64;
2308       break;
2309     case BFD_RELOC_PPC_TOC16:                   r = R_PPC64_TOC16;
2310       break;
2311     case BFD_RELOC_PPC64_TOC16_LO:              r = R_PPC64_TOC16_LO;
2312       break;
2313     case BFD_RELOC_PPC64_TOC16_HI:              r = R_PPC64_TOC16_HI;
2314       break;
2315     case BFD_RELOC_PPC64_TOC16_HA:              r = R_PPC64_TOC16_HA;
2316       break;
2317     case BFD_RELOC_PPC64_TOC:                   r = R_PPC64_TOC;
2318       break;
2319     case BFD_RELOC_PPC64_PLTGOT16:              r = R_PPC64_PLTGOT16;
2320       break;
2321     case BFD_RELOC_PPC64_PLTGOT16_LO:           r = R_PPC64_PLTGOT16_LO;
2322       break;
2323     case BFD_RELOC_PPC64_PLTGOT16_HI:           r = R_PPC64_PLTGOT16_HI;
2324       break;
2325     case BFD_RELOC_PPC64_PLTGOT16_HA:           r = R_PPC64_PLTGOT16_HA;
2326       break;
2327     case BFD_RELOC_PPC64_ADDR16_DS:             r = R_PPC64_ADDR16_DS;
2328       break;
2329     case BFD_RELOC_PPC64_ADDR16_LO_DS:          r = R_PPC64_ADDR16_LO_DS;
2330       break;
2331     case BFD_RELOC_PPC64_GOT16_DS:              r = R_PPC64_GOT16_DS;
2332       break;
2333     case BFD_RELOC_PPC64_GOT16_LO_DS:           r = R_PPC64_GOT16_LO_DS;
2334       break;
2335     case BFD_RELOC_PPC64_PLT16_LO_DS:           r = R_PPC64_PLT16_LO_DS;
2336       break;
2337     case BFD_RELOC_PPC64_SECTOFF_DS:            r = R_PPC64_SECTOFF_DS;
2338       break;
2339     case BFD_RELOC_PPC64_SECTOFF_LO_DS:         r = R_PPC64_SECTOFF_LO_DS;
2340       break;
2341     case BFD_RELOC_PPC64_TOC16_DS:              r = R_PPC64_TOC16_DS;
2342       break;
2343     case BFD_RELOC_PPC64_TOC16_LO_DS:           r = R_PPC64_TOC16_LO_DS;
2344       break;
2345     case BFD_RELOC_PPC64_PLTGOT16_DS:           r = R_PPC64_PLTGOT16_DS;
2346       break;
2347     case BFD_RELOC_PPC64_PLTGOT16_LO_DS:        r = R_PPC64_PLTGOT16_LO_DS;
2348       break;
2349     case BFD_RELOC_PPC_TLS:                     r = R_PPC64_TLS;
2350       break;
2351     case BFD_RELOC_PPC_TLSGD:                   r = R_PPC64_TLSGD;
2352       break;
2353     case BFD_RELOC_PPC_TLSLD:                   r = R_PPC64_TLSLD;
2354       break;
2355     case BFD_RELOC_PPC_DTPMOD:                  r = R_PPC64_DTPMOD64;
2356       break;
2357     case BFD_RELOC_PPC_TPREL16:                 r = R_PPC64_TPREL16;
2358       break;
2359     case BFD_RELOC_PPC_TPREL16_LO:              r = R_PPC64_TPREL16_LO;
2360       break;
2361     case BFD_RELOC_PPC_TPREL16_HI:              r = R_PPC64_TPREL16_HI;
2362       break;
2363     case BFD_RELOC_PPC64_TPREL16_HIGH:          r = R_PPC64_TPREL16_HIGH;
2364       break;
2365     case BFD_RELOC_PPC_TPREL16_HA:              r = R_PPC64_TPREL16_HA;
2366       break;
2367     case BFD_RELOC_PPC64_TPREL16_HIGHA:         r = R_PPC64_TPREL16_HIGHA;
2368       break;
2369     case BFD_RELOC_PPC_TPREL:                   r = R_PPC64_TPREL64;
2370       break;
2371     case BFD_RELOC_PPC_DTPREL16:                r = R_PPC64_DTPREL16;
2372       break;
2373     case BFD_RELOC_PPC_DTPREL16_LO:             r = R_PPC64_DTPREL16_LO;
2374       break;
2375     case BFD_RELOC_PPC_DTPREL16_HI:             r = R_PPC64_DTPREL16_HI;
2376       break;
2377     case BFD_RELOC_PPC64_DTPREL16_HIGH:         r = R_PPC64_DTPREL16_HIGH;
2378       break;
2379     case BFD_RELOC_PPC_DTPREL16_HA:             r = R_PPC64_DTPREL16_HA;
2380       break;
2381     case BFD_RELOC_PPC64_DTPREL16_HIGHA:        r = R_PPC64_DTPREL16_HIGHA;
2382       break;
2383     case BFD_RELOC_PPC_DTPREL:                  r = R_PPC64_DTPREL64;
2384       break;
2385     case BFD_RELOC_PPC_GOT_TLSGD16:             r = R_PPC64_GOT_TLSGD16;
2386       break;
2387     case BFD_RELOC_PPC_GOT_TLSGD16_LO:          r = R_PPC64_GOT_TLSGD16_LO;
2388       break;
2389     case BFD_RELOC_PPC_GOT_TLSGD16_HI:          r = R_PPC64_GOT_TLSGD16_HI;
2390       break;
2391     case BFD_RELOC_PPC_GOT_TLSGD16_HA:          r = R_PPC64_GOT_TLSGD16_HA;
2392       break;
2393     case BFD_RELOC_PPC_GOT_TLSLD16:             r = R_PPC64_GOT_TLSLD16;
2394       break;
2395     case BFD_RELOC_PPC_GOT_TLSLD16_LO:          r = R_PPC64_GOT_TLSLD16_LO;
2396       break;
2397     case BFD_RELOC_PPC_GOT_TLSLD16_HI:          r = R_PPC64_GOT_TLSLD16_HI;
2398       break;
2399     case BFD_RELOC_PPC_GOT_TLSLD16_HA:          r = R_PPC64_GOT_TLSLD16_HA;
2400       break;
2401     case BFD_RELOC_PPC_GOT_TPREL16:             r = R_PPC64_GOT_TPREL16_DS;
2402       break;
2403     case BFD_RELOC_PPC_GOT_TPREL16_LO:          r = R_PPC64_GOT_TPREL16_LO_DS;
2404       break;
2405     case BFD_RELOC_PPC_GOT_TPREL16_HI:          r = R_PPC64_GOT_TPREL16_HI;
2406       break;
2407     case BFD_RELOC_PPC_GOT_TPREL16_HA:          r = R_PPC64_GOT_TPREL16_HA;
2408       break;
2409     case BFD_RELOC_PPC_GOT_DTPREL16:            r = R_PPC64_GOT_DTPREL16_DS;
2410       break;
2411     case BFD_RELOC_PPC_GOT_DTPREL16_LO:         r = R_PPC64_GOT_DTPREL16_LO_DS;
2412       break;
2413     case BFD_RELOC_PPC_GOT_DTPREL16_HI:         r = R_PPC64_GOT_DTPREL16_HI;
2414       break;
2415     case BFD_RELOC_PPC_GOT_DTPREL16_HA:         r = R_PPC64_GOT_DTPREL16_HA;
2416       break;
2417     case BFD_RELOC_PPC64_TPREL16_DS:            r = R_PPC64_TPREL16_DS;
2418       break;
2419     case BFD_RELOC_PPC64_TPREL16_LO_DS:         r = R_PPC64_TPREL16_LO_DS;
2420       break;
2421     case BFD_RELOC_PPC64_TPREL16_HIGHER:        r = R_PPC64_TPREL16_HIGHER;
2422       break;
2423     case BFD_RELOC_PPC64_TPREL16_HIGHERA:       r = R_PPC64_TPREL16_HIGHERA;
2424       break;
2425     case BFD_RELOC_PPC64_TPREL16_HIGHEST:       r = R_PPC64_TPREL16_HIGHEST;
2426       break;
2427     case BFD_RELOC_PPC64_TPREL16_HIGHESTA:      r = R_PPC64_TPREL16_HIGHESTA;
2428       break;
2429     case BFD_RELOC_PPC64_DTPREL16_DS:           r = R_PPC64_DTPREL16_DS;
2430       break;
2431     case BFD_RELOC_PPC64_DTPREL16_LO_DS:        r = R_PPC64_DTPREL16_LO_DS;
2432       break;
2433     case BFD_RELOC_PPC64_DTPREL16_HIGHER:       r = R_PPC64_DTPREL16_HIGHER;
2434       break;
2435     case BFD_RELOC_PPC64_DTPREL16_HIGHERA:      r = R_PPC64_DTPREL16_HIGHERA;
2436       break;
2437     case BFD_RELOC_PPC64_DTPREL16_HIGHEST:      r = R_PPC64_DTPREL16_HIGHEST;
2438       break;
2439     case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:     r = R_PPC64_DTPREL16_HIGHESTA;
2440       break;
2441     case BFD_RELOC_16_PCREL:                    r = R_PPC64_REL16;
2442       break;
2443     case BFD_RELOC_LO16_PCREL:                  r = R_PPC64_REL16_LO;
2444       break;
2445     case BFD_RELOC_HI16_PCREL:                  r = R_PPC64_REL16_HI;
2446       break;
2447     case BFD_RELOC_HI16_S_PCREL:                r = R_PPC64_REL16_HA;
2448       break;
2449     case BFD_RELOC_PPC_REL16DX_HA:              r = R_PPC64_REL16DX_HA;
2450       break;
2451     case BFD_RELOC_PPC64_ENTRY:                 r = R_PPC64_ENTRY;
2452       break;
2453     case BFD_RELOC_PPC64_ADDR64_LOCAL:          r = R_PPC64_ADDR64_LOCAL;
2454       break;
2455     case BFD_RELOC_VTABLE_INHERIT:              r = R_PPC64_GNU_VTINHERIT;
2456       break;
2457     case BFD_RELOC_VTABLE_ENTRY:                r = R_PPC64_GNU_VTENTRY;
2458       break;
2459     }
2460
2461   return ppc64_elf_howto_table[r];
2462 };
2463
2464 static reloc_howto_type *
2465 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2466                              const char *r_name)
2467 {
2468   unsigned int i;
2469
2470   for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2471     if (ppc64_elf_howto_raw[i].name != NULL
2472         && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2473       return &ppc64_elf_howto_raw[i];
2474
2475   return NULL;
2476 }
2477
2478 /* Set the howto pointer for a PowerPC ELF reloc.  */
2479
2480 static void
2481 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2482                          Elf_Internal_Rela *dst)
2483 {
2484   unsigned int type;
2485
2486   /* Initialize howto table if needed.  */
2487   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2488     ppc_howto_init ();
2489
2490   type = ELF64_R_TYPE (dst->r_info);
2491   if (type >= ARRAY_SIZE (ppc64_elf_howto_table))
2492     {
2493       (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
2494                              abfd, (int) type);
2495       type = R_PPC64_NONE;
2496     }
2497   cache_ptr->howto = ppc64_elf_howto_table[type];
2498 }
2499
2500 /* Handle the R_PPC64_ADDR16_HA and similar relocs.  */
2501
2502 static bfd_reloc_status_type
2503 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2504                     void *data, asection *input_section,
2505                     bfd *output_bfd, char **error_message)
2506 {
2507   enum elf_ppc64_reloc_type r_type;
2508   long insn;
2509   bfd_size_type octets;
2510   bfd_vma value;
2511
2512   /* If this is a relocatable link (output_bfd test tells us), just
2513      call the generic function.  Any adjustment will be done at final
2514      link time.  */
2515   if (output_bfd != NULL)
2516     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2517                                   input_section, output_bfd, error_message);
2518
2519   /* Adjust the addend for sign extension of the low 16 bits.
2520      We won't actually be using the low 16 bits, so trashing them
2521      doesn't matter.  */
2522   reloc_entry->addend += 0x8000;
2523   r_type = reloc_entry->howto->type;
2524   if (r_type != R_PPC64_REL16DX_HA)
2525     return bfd_reloc_continue;
2526
2527   value = 0;
2528   if (!bfd_is_com_section (symbol->section))
2529     value = symbol->value;
2530   value += (reloc_entry->addend
2531             + symbol->section->output_offset
2532             + symbol->section->output_section->vma);
2533   value -= (reloc_entry->address
2534             + input_section->output_offset
2535             + input_section->output_section->vma);
2536   value = (bfd_signed_vma) value >> 16;
2537
2538   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2539   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2540   insn &= ~0x1fffc1;
2541   insn |= (value & 0xffc1) | ((value & 0x3e) << 15);
2542   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2543   if (value + 0x8000 > 0xffff)
2544     return bfd_reloc_overflow;
2545   return bfd_reloc_ok;
2546 }
2547
2548 static bfd_reloc_status_type
2549 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2550                         void *data, asection *input_section,
2551                         bfd *output_bfd, char **error_message)
2552 {
2553   if (output_bfd != NULL)
2554     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2555                                   input_section, output_bfd, error_message);
2556
2557   if (strcmp (symbol->section->name, ".opd") == 0
2558       && (symbol->section->owner->flags & DYNAMIC) == 0)
2559     {
2560       bfd_vma dest = opd_entry_value (symbol->section,
2561                                       symbol->value + reloc_entry->addend,
2562                                       NULL, NULL, FALSE);
2563       if (dest != (bfd_vma) -1)
2564         reloc_entry->addend = dest - (symbol->value
2565                                       + symbol->section->output_section->vma
2566                                       + symbol->section->output_offset);
2567     }
2568   else
2569     {
2570       elf_symbol_type *elfsym = (elf_symbol_type *) symbol;
2571
2572       if (symbol->section->owner != abfd
2573           && abiversion (symbol->section->owner) >= 2)
2574         {
2575           unsigned int i;
2576
2577           for (i = 0; i < symbol->section->owner->symcount; ++i)
2578             {
2579               asymbol *symdef = symbol->section->owner->outsymbols[i];
2580
2581               if (strcmp (symdef->name, symbol->name) == 0)
2582                 {
2583                   elfsym = (elf_symbol_type *) symdef;
2584                   break;
2585                 }
2586             }
2587         }
2588       reloc_entry->addend
2589         += PPC64_LOCAL_ENTRY_OFFSET (elfsym->internal_elf_sym.st_other);
2590     }
2591   return bfd_reloc_continue;
2592 }
2593
2594 static bfd_reloc_status_type
2595 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2596                          void *data, asection *input_section,
2597                          bfd *output_bfd, char **error_message)
2598 {
2599   long insn;
2600   enum elf_ppc64_reloc_type r_type;
2601   bfd_size_type octets;
2602   /* Assume 'at' branch hints.  */
2603   bfd_boolean is_isa_v2 = TRUE;
2604
2605   /* If this is a relocatable link (output_bfd test tells us), just
2606      call the generic function.  Any adjustment will be done at final
2607      link time.  */
2608   if (output_bfd != NULL)
2609     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2610                                   input_section, output_bfd, error_message);
2611
2612   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2613   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2614   insn &= ~(0x01 << 21);
2615   r_type = reloc_entry->howto->type;
2616   if (r_type == R_PPC64_ADDR14_BRTAKEN
2617       || r_type == R_PPC64_REL14_BRTAKEN)
2618     insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
2619
2620   if (is_isa_v2)
2621     {
2622       /* Set 'a' bit.  This is 0b00010 in BO field for branch
2623          on CR(BI) insns (BO == 001at or 011at), and 0b01000
2624          for branch on CTR insns (BO == 1a00t or 1a01t).  */
2625       if ((insn & (0x14 << 21)) == (0x04 << 21))
2626         insn |= 0x02 << 21;
2627       else if ((insn & (0x14 << 21)) == (0x10 << 21))
2628         insn |= 0x08 << 21;
2629       else
2630         goto out;
2631     }
2632   else
2633     {
2634       bfd_vma target = 0;
2635       bfd_vma from;
2636
2637       if (!bfd_is_com_section (symbol->section))
2638         target = symbol->value;
2639       target += symbol->section->output_section->vma;
2640       target += symbol->section->output_offset;
2641       target += reloc_entry->addend;
2642
2643       from = (reloc_entry->address
2644               + input_section->output_offset
2645               + input_section->output_section->vma);
2646
2647       /* Invert 'y' bit if not the default.  */
2648       if ((bfd_signed_vma) (target - from) < 0)
2649         insn ^= 0x01 << 21;
2650     }
2651   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2652  out:
2653   return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2654                                  input_section, output_bfd, error_message);
2655 }
2656
2657 static bfd_reloc_status_type
2658 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2659                          void *data, asection *input_section,
2660                          bfd *output_bfd, char **error_message)
2661 {
2662   /* If this is a relocatable link (output_bfd test tells us), just
2663      call the generic function.  Any adjustment will be done at final
2664      link time.  */
2665   if (output_bfd != NULL)
2666     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2667                                   input_section, output_bfd, error_message);
2668
2669   /* Subtract the symbol section base address.  */
2670   reloc_entry->addend -= symbol->section->output_section->vma;
2671   return bfd_reloc_continue;
2672 }
2673
2674 static bfd_reloc_status_type
2675 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2676                             void *data, asection *input_section,
2677                             bfd *output_bfd, char **error_message)
2678 {
2679   /* If this is a relocatable link (output_bfd test tells us), just
2680      call the generic function.  Any adjustment will be done at final
2681      link time.  */
2682   if (output_bfd != NULL)
2683     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2684                                   input_section, output_bfd, error_message);
2685
2686   /* Subtract the symbol section base address.  */
2687   reloc_entry->addend -= symbol->section->output_section->vma;
2688
2689   /* Adjust the addend for sign extension of the low 16 bits.  */
2690   reloc_entry->addend += 0x8000;
2691   return bfd_reloc_continue;
2692 }
2693
2694 static bfd_reloc_status_type
2695 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2696                      void *data, asection *input_section,
2697                      bfd *output_bfd, char **error_message)
2698 {
2699   bfd_vma TOCstart;
2700
2701   /* If this is a relocatable link (output_bfd test tells us), just
2702      call the generic function.  Any adjustment will be done at final
2703      link time.  */
2704   if (output_bfd != NULL)
2705     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2706                                   input_section, output_bfd, error_message);
2707
2708   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2709   if (TOCstart == 0)
2710     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2711
2712   /* Subtract the TOC base address.  */
2713   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2714   return bfd_reloc_continue;
2715 }
2716
2717 static bfd_reloc_status_type
2718 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2719                         void *data, asection *input_section,
2720                         bfd *output_bfd, char **error_message)
2721 {
2722   bfd_vma TOCstart;
2723
2724   /* If this is a relocatable link (output_bfd test tells us), just
2725      call the generic function.  Any adjustment will be done at final
2726      link time.  */
2727   if (output_bfd != NULL)
2728     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2729                                   input_section, output_bfd, error_message);
2730
2731   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2732   if (TOCstart == 0)
2733     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2734
2735   /* Subtract the TOC base address.  */
2736   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2737
2738   /* Adjust the addend for sign extension of the low 16 bits.  */
2739   reloc_entry->addend += 0x8000;
2740   return bfd_reloc_continue;
2741 }
2742
2743 static bfd_reloc_status_type
2744 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2745                        void *data, asection *input_section,
2746                        bfd *output_bfd, char **error_message)
2747 {
2748   bfd_vma TOCstart;
2749   bfd_size_type octets;
2750
2751   /* If this is a relocatable link (output_bfd test tells us), just
2752      call the generic function.  Any adjustment will be done at final
2753      link time.  */
2754   if (output_bfd != NULL)
2755     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2756                                   input_section, output_bfd, error_message);
2757
2758   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2759   if (TOCstart == 0)
2760     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2761
2762   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2763   bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2764   return bfd_reloc_ok;
2765 }
2766
2767 static bfd_reloc_status_type
2768 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2769                            void *data, asection *input_section,
2770                            bfd *output_bfd, char **error_message)
2771 {
2772   /* If this is a relocatable link (output_bfd test tells us), just
2773      call the generic function.  Any adjustment will be done at final
2774      link time.  */
2775   if (output_bfd != NULL)
2776     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2777                                   input_section, output_bfd, error_message);
2778
2779   if (error_message != NULL)
2780     {
2781       static char buf[60];
2782       sprintf (buf, "generic linker can't handle %s",
2783                reloc_entry->howto->name);
2784       *error_message = buf;
2785     }
2786   return bfd_reloc_dangerous;
2787 }
2788
2789 /* Track GOT entries needed for a given symbol.  We might need more
2790    than one got entry per symbol.  */
2791 struct got_entry
2792 {
2793   struct got_entry *next;
2794
2795   /* The symbol addend that we'll be placing in the GOT.  */
2796   bfd_vma addend;
2797
2798   /* Unlike other ELF targets, we use separate GOT entries for the same
2799      symbol referenced from different input files.  This is to support
2800      automatic multiple TOC/GOT sections, where the TOC base can vary
2801      from one input file to another.  After partitioning into TOC groups
2802      we merge entries within the group.
2803
2804      Point to the BFD owning this GOT entry.  */
2805   bfd *owner;
2806
2807   /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2808      TLS_TPREL or TLS_DTPREL for tls entries.  */
2809   unsigned char tls_type;
2810
2811   /* Non-zero if got.ent points to real entry.  */
2812   unsigned char is_indirect;
2813
2814   /* Reference count until size_dynamic_sections, GOT offset thereafter.  */
2815   union
2816     {
2817       bfd_signed_vma refcount;
2818       bfd_vma offset;
2819       struct got_entry *ent;
2820     } got;
2821 };
2822
2823 /* The same for PLT.  */
2824 struct plt_entry
2825 {
2826   struct plt_entry *next;
2827
2828   bfd_vma addend;
2829
2830   union
2831     {
2832       bfd_signed_vma refcount;
2833       bfd_vma offset;
2834     } plt;
2835 };
2836
2837 struct ppc64_elf_obj_tdata
2838 {
2839   struct elf_obj_tdata elf;
2840
2841   /* Shortcuts to dynamic linker sections.  */
2842   asection *got;
2843   asection *relgot;
2844
2845   /* Used during garbage collection.  We attach global symbols defined
2846      on removed .opd entries to this section so that the sym is removed.  */
2847   asection *deleted_section;
2848
2849   /* TLS local dynamic got entry handling.  Support for multiple GOT
2850      sections means we potentially need one of these for each input bfd.  */
2851   struct got_entry tlsld_got;
2852
2853   union {
2854     /* A copy of relocs before they are modified for --emit-relocs.  */
2855     Elf_Internal_Rela *relocs;
2856
2857     /* Section contents.  */
2858     bfd_byte *contents;
2859   } opd;
2860
2861   /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2862      the reloc to be in the range -32768 to 32767.  */
2863   unsigned int has_small_toc_reloc : 1;
2864
2865   /* Set if toc/got ha relocs detected not using r2, or lo reloc
2866      instruction not one we handle.  */
2867   unsigned int unexpected_toc_insn : 1;
2868 };
2869
2870 #define ppc64_elf_tdata(bfd) \
2871   ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2872
2873 #define ppc64_tlsld_got(bfd) \
2874   (&ppc64_elf_tdata (bfd)->tlsld_got)
2875
2876 #define is_ppc64_elf(bfd) \
2877   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2878    && elf_object_id (bfd) == PPC64_ELF_DATA)
2879
2880 /* Override the generic function because we store some extras.  */
2881
2882 static bfd_boolean
2883 ppc64_elf_mkobject (bfd *abfd)
2884 {
2885   return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2886                                   PPC64_ELF_DATA);
2887 }
2888
2889 /* Fix bad default arch selected for a 64 bit input bfd when the
2890    default is 32 bit.  */
2891
2892 static bfd_boolean
2893 ppc64_elf_object_p (bfd *abfd)
2894 {
2895   if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32)
2896     {
2897       Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2898
2899       if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2900         {
2901           /* Relies on arch after 32 bit default being 64 bit default.  */
2902           abfd->arch_info = abfd->arch_info->next;
2903           BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2904         }
2905     }
2906   return TRUE;
2907 }
2908
2909 /* Support for core dump NOTE sections.  */
2910
2911 static bfd_boolean
2912 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2913 {
2914   size_t offset, size;
2915
2916   if (note->descsz != 504)
2917     return FALSE;
2918
2919   /* pr_cursig */
2920   elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2921
2922   /* pr_pid */
2923   elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2924
2925   /* pr_reg */
2926   offset = 112;
2927   size = 384;
2928
2929   /* Make a ".reg/999" section.  */
2930   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2931                                           size, note->descpos + offset);
2932 }
2933
2934 static bfd_boolean
2935 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2936 {
2937   if (note->descsz != 136)
2938     return FALSE;
2939
2940   elf_tdata (abfd)->core->pid
2941     = bfd_get_32 (abfd, note->descdata + 24);
2942   elf_tdata (abfd)->core->program
2943     = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2944   elf_tdata (abfd)->core->command
2945     = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2946
2947   return TRUE;
2948 }
2949
2950 static char *
2951 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2952                            ...)
2953 {
2954   switch (note_type)
2955     {
2956     default:
2957       return NULL;
2958
2959     case NT_PRPSINFO:
2960       {
2961         char data[136];
2962         va_list ap;
2963
2964         va_start (ap, note_type);
2965         memset (data, 0, sizeof (data));
2966         strncpy (data + 40, va_arg (ap, const char *), 16);
2967         strncpy (data + 56, va_arg (ap, const char *), 80);
2968         va_end (ap);
2969         return elfcore_write_note (abfd, buf, bufsiz,
2970                                    "CORE", note_type, data, sizeof (data));
2971       }
2972
2973     case NT_PRSTATUS:
2974       {
2975         char data[504];
2976         va_list ap;
2977         long pid;
2978         int cursig;
2979         const void *greg;
2980
2981         va_start (ap, note_type);
2982         memset (data, 0, 112);
2983         pid = va_arg (ap, long);
2984         bfd_put_32 (abfd, pid, data + 32);
2985         cursig = va_arg (ap, int);
2986         bfd_put_16 (abfd, cursig, data + 12);
2987         greg = va_arg (ap, const void *);
2988         memcpy (data + 112, greg, 384);
2989         memset (data + 496, 0, 8);
2990         va_end (ap);
2991         return elfcore_write_note (abfd, buf, bufsiz,
2992                                    "CORE", note_type, data, sizeof (data));
2993       }
2994     }
2995 }
2996
2997 /* Add extra PPC sections.  */
2998
2999 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
3000 {
3001   { STRING_COMMA_LEN (".plt"),    0, SHT_NOBITS,   0 },
3002   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
3003   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3004   { STRING_COMMA_LEN (".toc"),    0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3005   { STRING_COMMA_LEN (".toc1"),   0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3006   { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
3007   { NULL,                     0,  0, 0,            0 }
3008 };
3009
3010 enum _ppc64_sec_type {
3011   sec_normal = 0,
3012   sec_opd = 1,
3013   sec_toc = 2
3014 };
3015
3016 struct _ppc64_elf_section_data
3017 {
3018   struct bfd_elf_section_data elf;
3019
3020   union
3021   {
3022     /* An array with one entry for each opd function descriptor,
3023        and some spares since opd entries may be either 16 or 24 bytes.  */
3024 #define OPD_NDX(OFF) ((OFF) >> 4)
3025     struct _opd_sec_data
3026     {
3027       /* Points to the function code section for local opd entries.  */
3028       asection **func_sec;
3029
3030       /* After editing .opd, adjust references to opd local syms.  */
3031       long *adjust;
3032     } opd;
3033
3034     /* An array for toc sections, indexed by offset/8.  */
3035     struct _toc_sec_data
3036     {
3037       /* Specifies the relocation symbol index used at a given toc offset.  */
3038       unsigned *symndx;
3039
3040       /* And the relocation addend.  */
3041       bfd_vma *add;
3042     } toc;
3043   } u;
3044
3045   enum _ppc64_sec_type sec_type:2;
3046
3047   /* Flag set when small branches are detected.  Used to
3048      select suitable defaults for the stub group size.  */
3049   unsigned int has_14bit_branch:1;
3050 };
3051
3052 #define ppc64_elf_section_data(sec) \
3053   ((struct _ppc64_elf_section_data *) elf_section_data (sec))
3054
3055 static bfd_boolean
3056 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
3057 {
3058   if (!sec->used_by_bfd)
3059     {
3060       struct _ppc64_elf_section_data *sdata;
3061       bfd_size_type amt = sizeof (*sdata);
3062
3063       sdata = bfd_zalloc (abfd, amt);
3064       if (sdata == NULL)
3065         return FALSE;
3066       sec->used_by_bfd = sdata;
3067     }
3068
3069   return _bfd_elf_new_section_hook (abfd, sec);
3070 }
3071
3072 static struct _opd_sec_data *
3073 get_opd_info (asection * sec)
3074 {
3075   if (sec != NULL
3076       && ppc64_elf_section_data (sec) != NULL
3077       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
3078     return &ppc64_elf_section_data (sec)->u.opd;
3079   return NULL;
3080 }
3081 \f
3082 /* Parameters for the qsort hook.  */
3083 static bfd_boolean synthetic_relocatable;
3084
3085 /* qsort comparison function for ppc64_elf_get_synthetic_symtab.  */
3086
3087 static int
3088 compare_symbols (const void *ap, const void *bp)
3089 {
3090   const asymbol *a = * (const asymbol **) ap;
3091   const asymbol *b = * (const asymbol **) bp;
3092
3093   /* Section symbols first.  */
3094   if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
3095     return -1;
3096   if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
3097     return 1;
3098
3099   /* then .opd symbols.  */
3100   if (strcmp (a->section->name, ".opd") == 0
3101       && strcmp (b->section->name, ".opd") != 0)
3102     return -1;
3103   if (strcmp (a->section->name, ".opd") != 0
3104       && strcmp (b->section->name, ".opd") == 0)
3105     return 1;
3106
3107   /* then other code symbols.  */
3108   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3109       == (SEC_CODE | SEC_ALLOC)
3110       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3111          != (SEC_CODE | SEC_ALLOC))
3112     return -1;
3113
3114   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3115       != (SEC_CODE | SEC_ALLOC)
3116       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3117          == (SEC_CODE | SEC_ALLOC))
3118     return 1;
3119
3120   if (synthetic_relocatable)
3121     {
3122       if (a->section->id < b->section->id)
3123         return -1;
3124
3125       if (a->section->id > b->section->id)
3126         return 1;
3127     }
3128
3129   if (a->value + a->section->vma < b->value + b->section->vma)
3130     return -1;
3131
3132   if (a->value + a->section->vma > b->value + b->section->vma)
3133     return 1;
3134
3135   /* For syms with the same value, prefer strong dynamic global function
3136      syms over other syms.  */
3137   if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3138     return -1;
3139
3140   if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3141     return 1;
3142
3143   if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3144     return -1;
3145
3146   if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3147     return 1;
3148
3149   if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3150     return -1;
3151
3152   if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3153     return 1;
3154
3155   if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3156     return -1;
3157
3158   if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3159     return 1;
3160
3161   return 0;
3162 }
3163
3164 /* Search SYMS for a symbol of the given VALUE.  */
3165
3166 static asymbol *
3167 sym_exists_at (asymbol **syms, long lo, long hi, unsigned int id, bfd_vma value)
3168 {
3169   long mid;
3170
3171   if (id == (unsigned) -1)
3172     {
3173       while (lo < hi)
3174         {
3175           mid = (lo + hi) >> 1;
3176           if (syms[mid]->value + syms[mid]->section->vma < value)
3177             lo = mid + 1;
3178           else if (syms[mid]->value + syms[mid]->section->vma > value)
3179             hi = mid;
3180           else
3181             return syms[mid];
3182         }
3183     }
3184   else
3185     {
3186       while (lo < hi)
3187         {
3188           mid = (lo + hi) >> 1;
3189           if (syms[mid]->section->id < id)
3190             lo = mid + 1;
3191           else if (syms[mid]->section->id > id)
3192             hi = mid;
3193           else if (syms[mid]->value < value)
3194             lo = mid + 1;
3195           else if (syms[mid]->value > value)
3196             hi = mid;
3197           else
3198             return syms[mid];
3199         }
3200     }
3201   return NULL;
3202 }
3203
3204 static bfd_boolean
3205 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3206 {
3207   bfd_vma vma = *(bfd_vma *) ptr;
3208   return ((section->flags & SEC_ALLOC) != 0
3209           && section->vma <= vma
3210           && vma < section->vma + section->size);
3211 }
3212
3213 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3214    entry syms.  Also generate @plt symbols for the glink branch table.
3215    Returns count of synthetic symbols in RET or -1 on error.  */
3216
3217 static long
3218 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3219                                 long static_count, asymbol **static_syms,
3220                                 long dyn_count, asymbol **dyn_syms,
3221                                 asymbol **ret)
3222 {
3223   asymbol *s;
3224   long i;
3225   long count;
3226   char *names;
3227   long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3228   asection *opd = NULL;
3229   bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3230   asymbol **syms;
3231   int abi = abiversion (abfd);
3232
3233   *ret = NULL;
3234
3235   if (abi < 2)
3236     {
3237       opd = bfd_get_section_by_name (abfd, ".opd");
3238       if (opd == NULL && abi == 1)
3239         return 0;
3240     }
3241
3242   symcount = static_count;
3243   if (!relocatable)
3244     symcount += dyn_count;
3245   if (symcount == 0)
3246     return 0;
3247
3248   syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3249   if (syms == NULL)
3250     return -1;
3251
3252   if (!relocatable && static_count != 0 && dyn_count != 0)
3253     {
3254       /* Use both symbol tables.  */
3255       memcpy (syms, static_syms, static_count * sizeof (*syms));
3256       memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3257     }
3258   else if (!relocatable && static_count == 0)
3259     memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3260   else
3261     memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3262
3263   synthetic_relocatable = relocatable;
3264   qsort (syms, symcount, sizeof (*syms), compare_symbols);
3265
3266   if (!relocatable && symcount > 1)
3267     {
3268       long j;
3269       /* Trim duplicate syms, since we may have merged the normal and
3270          dynamic symbols.  Actually, we only care about syms that have
3271          different values, so trim any with the same value.  */
3272       for (i = 1, j = 1; i < symcount; ++i)
3273         if (syms[i - 1]->value + syms[i - 1]->section->vma
3274             != syms[i]->value + syms[i]->section->vma)
3275           syms[j++] = syms[i];
3276       symcount = j;
3277     }
3278
3279   i = 0;
3280   if (strcmp (syms[i]->section->name, ".opd") == 0)
3281     ++i;
3282   codesecsym = i;
3283
3284   for (; i < symcount; ++i)
3285     if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3286          != (SEC_CODE | SEC_ALLOC))
3287         || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3288       break;
3289   codesecsymend = i;
3290
3291   for (; i < symcount; ++i)
3292     if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3293       break;
3294   secsymend = i;
3295
3296   for (; i < symcount; ++i)
3297     if (strcmp (syms[i]->section->name, ".opd") != 0)
3298       break;
3299   opdsymend = i;
3300
3301   for (; i < symcount; ++i)
3302     if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3303         != (SEC_CODE | SEC_ALLOC))
3304       break;
3305   symcount = i;
3306
3307   count = 0;
3308
3309   if (relocatable)
3310     {
3311       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3312       arelent *r;
3313       size_t size;
3314       long relcount;
3315
3316       if (opdsymend == secsymend)
3317         goto done;
3318
3319       slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3320       relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3321       if (relcount == 0)
3322         goto done;
3323
3324       if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3325         {
3326           count = -1;
3327           goto done;
3328         }
3329
3330       size = 0;
3331       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3332         {
3333           asymbol *sym;
3334
3335           while (r < opd->relocation + relcount
3336                  && r->address < syms[i]->value + opd->vma)
3337             ++r;
3338
3339           if (r == opd->relocation + relcount)
3340             break;
3341
3342           if (r->address != syms[i]->value + opd->vma)
3343             continue;
3344
3345           if (r->howto->type != R_PPC64_ADDR64)
3346             continue;
3347
3348           sym = *r->sym_ptr_ptr;
3349           if (!sym_exists_at (syms, opdsymend, symcount,
3350                               sym->section->id, sym->value + r->addend))
3351             {
3352               ++count;
3353               size += sizeof (asymbol);
3354               size += strlen (syms[i]->name) + 2;
3355             }
3356         }
3357
3358       if (size == 0)
3359         goto done;
3360       s = *ret = bfd_malloc (size);
3361       if (s == NULL)
3362         {
3363           count = -1;
3364           goto done;
3365         }
3366
3367       names = (char *) (s + count);
3368
3369       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3370         {
3371           asymbol *sym;
3372
3373           while (r < opd->relocation + relcount
3374                  && r->address < syms[i]->value + opd->vma)
3375             ++r;
3376
3377           if (r == opd->relocation + relcount)
3378             break;
3379
3380           if (r->address != syms[i]->value + opd->vma)
3381             continue;
3382
3383           if (r->howto->type != R_PPC64_ADDR64)
3384             continue;
3385
3386           sym = *r->sym_ptr_ptr;
3387           if (!sym_exists_at (syms, opdsymend, symcount,
3388                               sym->section->id, sym->value + r->addend))
3389             {
3390               size_t len;
3391
3392               *s = *syms[i];
3393               s->flags |= BSF_SYNTHETIC;
3394               s->section = sym->section;
3395               s->value = sym->value + r->addend;
3396               s->name = names;
3397               *names++ = '.';
3398               len = strlen (syms[i]->name);
3399               memcpy (names, syms[i]->name, len + 1);
3400               names += len + 1;
3401               /* Have udata.p point back to the original symbol this
3402                  synthetic symbol was derived from.  */
3403               s->udata.p = syms[i];
3404               s++;
3405             }
3406         }
3407     }
3408   else
3409     {
3410       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3411       bfd_byte *contents = NULL;
3412       size_t size;
3413       long plt_count = 0;
3414       bfd_vma glink_vma = 0, resolv_vma = 0;
3415       asection *dynamic, *glink = NULL, *relplt = NULL;
3416       arelent *p;
3417
3418       if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3419         {
3420         free_contents_and_exit_err:
3421           count = -1;
3422         free_contents_and_exit:
3423           if (contents)
3424             free (contents);
3425           goto done;
3426         }
3427
3428       size = 0;
3429       for (i = secsymend; i < opdsymend; ++i)
3430         {
3431           bfd_vma ent;
3432
3433           /* Ignore bogus symbols.  */
3434           if (syms[i]->value > opd->size - 8)
3435             continue;
3436
3437           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3438           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3439             {
3440               ++count;
3441               size += sizeof (asymbol);
3442               size += strlen (syms[i]->name) + 2;
3443             }
3444         }
3445
3446       /* Get start of .glink stubs from DT_PPC64_GLINK.  */
3447       if (dyn_count != 0
3448           && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3449         {
3450           bfd_byte *dynbuf, *extdyn, *extdynend;
3451           size_t extdynsize;
3452           void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3453
3454           if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3455             goto free_contents_and_exit_err;
3456
3457           extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3458           swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3459
3460           extdyn = dynbuf;
3461           extdynend = extdyn + dynamic->size;
3462           for (; extdyn < extdynend; extdyn += extdynsize)
3463             {
3464               Elf_Internal_Dyn dyn;
3465               (*swap_dyn_in) (abfd, extdyn, &dyn);
3466
3467               if (dyn.d_tag == DT_NULL)
3468                 break;
3469
3470               if (dyn.d_tag == DT_PPC64_GLINK)
3471                 {
3472                   /* The first glink stub starts at offset 32; see
3473                      comment in ppc64_elf_finish_dynamic_sections. */
3474                   glink_vma = dyn.d_un.d_val + GLINK_CALL_STUB_SIZE - 8 * 4;
3475                   /* The .glink section usually does not survive the final
3476                      link; search for the section (usually .text) where the
3477                      glink stubs now reside.  */
3478                   glink = bfd_sections_find_if (abfd, section_covers_vma,
3479                                                 &glink_vma);
3480                   break;
3481                 }
3482             }
3483
3484           free (dynbuf);
3485         }
3486
3487       if (glink != NULL)
3488         {
3489           /* Determine __glink trampoline by reading the relative branch
3490              from the first glink stub.  */
3491           bfd_byte buf[4];
3492           unsigned int off = 0;
3493
3494           while (bfd_get_section_contents (abfd, glink, buf,
3495                                            glink_vma + off - glink->vma, 4))
3496             {
3497               unsigned int insn = bfd_get_32 (abfd, buf);
3498               insn ^= B_DOT;
3499               if ((insn & ~0x3fffffc) == 0)
3500                 {
3501                   resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3502                   break;
3503                 }
3504               off += 4;
3505               if (off > 4)
3506                 break;
3507             }
3508
3509           if (resolv_vma)
3510             size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3511
3512           relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3513           if (relplt != NULL)
3514             {
3515               slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3516               if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3517                 goto free_contents_and_exit_err;
3518
3519               plt_count = relplt->size / sizeof (Elf64_External_Rela);
3520               size += plt_count * sizeof (asymbol);
3521
3522               p = relplt->relocation;
3523               for (i = 0; i < plt_count; i++, p++)
3524                 {
3525                   size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3526                   if (p->addend != 0)
3527                     size += sizeof ("+0x") - 1 + 16;
3528                 }
3529             }
3530         }
3531
3532       if (size == 0)
3533         goto free_contents_and_exit;
3534       s = *ret = bfd_malloc (size);
3535       if (s == NULL)
3536         goto free_contents_and_exit_err;
3537
3538       names = (char *) (s + count + plt_count + (resolv_vma != 0));
3539
3540       for (i = secsymend; i < opdsymend; ++i)
3541         {
3542           bfd_vma ent;
3543
3544           if (syms[i]->value > opd->size - 8)
3545             continue;
3546
3547           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3548           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3549             {
3550               long lo, hi;
3551               size_t len;
3552               asection *sec = abfd->sections;
3553
3554               *s = *syms[i];
3555               lo = codesecsym;
3556               hi = codesecsymend;
3557               while (lo < hi)
3558                 {
3559                   long mid = (lo + hi) >> 1;
3560                   if (syms[mid]->section->vma < ent)
3561                     lo = mid + 1;
3562                   else if (syms[mid]->section->vma > ent)
3563                     hi = mid;
3564                   else
3565                     {
3566                       sec = syms[mid]->section;
3567                       break;
3568                     }
3569                 }
3570
3571               if (lo >= hi && lo > codesecsym)
3572                 sec = syms[lo - 1]->section;
3573
3574               for (; sec != NULL; sec = sec->next)
3575                 {
3576                   if (sec->vma > ent)
3577                     break;
3578                   /* SEC_LOAD may not be set if SEC is from a separate debug
3579                      info file.  */
3580                   if ((sec->flags & SEC_ALLOC) == 0)
3581                     break;
3582                   if ((sec->flags & SEC_CODE) != 0)
3583                     s->section = sec;
3584                 }
3585               s->flags |= BSF_SYNTHETIC;
3586               s->value = ent - s->section->vma;
3587               s->name = names;
3588               *names++ = '.';
3589               len = strlen (syms[i]->name);
3590               memcpy (names, syms[i]->name, len + 1);
3591               names += len + 1;
3592               /* Have udata.p point back to the original symbol this
3593                  synthetic symbol was derived from.  */
3594               s->udata.p = syms[i];
3595               s++;
3596             }
3597         }
3598       free (contents);
3599
3600       if (glink != NULL && relplt != NULL)
3601         {
3602           if (resolv_vma)
3603             {
3604               /* Add a symbol for the main glink trampoline.  */
3605               memset (s, 0, sizeof *s);
3606               s->the_bfd = abfd;
3607               s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3608               s->section = glink;
3609               s->value = resolv_vma - glink->vma;
3610               s->name = names;
3611               memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3612               names += sizeof ("__glink_PLTresolve");
3613               s++;
3614               count++;
3615             }
3616
3617           /* FIXME: It would be very much nicer to put sym@plt on the
3618              stub rather than on the glink branch table entry.  The
3619              objdump disassembler would then use a sensible symbol
3620              name on plt calls.  The difficulty in doing so is
3621              a) finding the stubs, and,
3622              b) matching stubs against plt entries, and,
3623              c) there can be multiple stubs for a given plt entry.
3624
3625              Solving (a) could be done by code scanning, but older
3626              ppc64 binaries used different stubs to current code.
3627              (b) is the tricky one since you need to known the toc
3628              pointer for at least one function that uses a pic stub to
3629              be able to calculate the plt address referenced.
3630              (c) means gdb would need to set multiple breakpoints (or
3631              find the glink branch itself) when setting breakpoints
3632              for pending shared library loads.  */
3633           p = relplt->relocation;
3634           for (i = 0; i < plt_count; i++, p++)
3635             {
3636               size_t len;
3637
3638               *s = **p->sym_ptr_ptr;
3639               /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
3640                  we are defining a symbol, ensure one of them is set.  */
3641               if ((s->flags & BSF_LOCAL) == 0)
3642                 s->flags |= BSF_GLOBAL;
3643               s->flags |= BSF_SYNTHETIC;
3644               s->section = glink;
3645               s->value = glink_vma - glink->vma;
3646               s->name = names;
3647               s->udata.p = NULL;
3648               len = strlen ((*p->sym_ptr_ptr)->name);
3649               memcpy (names, (*p->sym_ptr_ptr)->name, len);
3650               names += len;
3651               if (p->addend != 0)
3652                 {
3653                   memcpy (names, "+0x", sizeof ("+0x") - 1);
3654                   names += sizeof ("+0x") - 1;
3655                   bfd_sprintf_vma (abfd, names, p->addend);
3656                   names += strlen (names);
3657                 }
3658               memcpy (names, "@plt", sizeof ("@plt"));
3659               names += sizeof ("@plt");
3660               s++;
3661               if (abi < 2)
3662                 {
3663                   glink_vma += 8;
3664                   if (i >= 0x8000)
3665                     glink_vma += 4;
3666                 }
3667               else
3668                 glink_vma += 4;
3669             }
3670           count += plt_count;
3671         }
3672     }
3673
3674  done:
3675   free (syms);
3676   return count;
3677 }
3678 \f
3679 /* The following functions are specific to the ELF linker, while
3680    functions above are used generally.  Those named ppc64_elf_* are
3681    called by the main ELF linker code.  They appear in this file more
3682    or less in the order in which they are called.  eg.
3683    ppc64_elf_check_relocs is called early in the link process,
3684    ppc64_elf_finish_dynamic_sections is one of the last functions
3685    called.
3686
3687    PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3688    functions have both a function code symbol and a function descriptor
3689    symbol.  A call to foo in a relocatable object file looks like:
3690
3691    .            .text
3692    .    x:
3693    .            bl      .foo
3694    .            nop
3695
3696    The function definition in another object file might be:
3697
3698    .            .section .opd
3699    .    foo:    .quad   .foo
3700    .            .quad   .TOC.@tocbase
3701    .            .quad   0
3702    .
3703    .            .text
3704    .    .foo:   blr
3705
3706    When the linker resolves the call during a static link, the branch
3707    unsurprisingly just goes to .foo and the .opd information is unused.
3708    If the function definition is in a shared library, things are a little
3709    different:  The call goes via a plt call stub, the opd information gets
3710    copied to the plt, and the linker patches the nop.
3711
3712    .    x:
3713    .            bl      .foo_stub
3714    .            ld      2,40(1)
3715    .
3716    .
3717    .    .foo_stub:
3718    .            std     2,40(1)                 # in practice, the call stub
3719    .            addis   11,2,Lfoo@toc@ha        # is slightly optimized, but
3720    .            addi    11,11,Lfoo@toc@l        # this is the general idea
3721    .            ld      12,0(11)
3722    .            ld      2,8(11)
3723    .            mtctr   12
3724    .            ld      11,16(11)
3725    .            bctr
3726    .
3727    .            .section .plt
3728    .    Lfoo:   reloc (R_PPC64_JMP_SLOT, foo)
3729
3730    The "reloc ()" notation is supposed to indicate that the linker emits
3731    an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
3732    copying.
3733
3734    What are the difficulties here?  Well, firstly, the relocations
3735    examined by the linker in check_relocs are against the function code
3736    sym .foo, while the dynamic relocation in the plt is emitted against
3737    the function descriptor symbol, foo.  Somewhere along the line, we need
3738    to carefully copy dynamic link information from one symbol to the other.
3739    Secondly, the generic part of the elf linker will make .foo a dynamic
3740    symbol as is normal for most other backends.  We need foo dynamic
3741    instead, at least for an application final link.  However, when
3742    creating a shared library containing foo, we need to have both symbols
3743    dynamic so that references to .foo are satisfied during the early
3744    stages of linking.  Otherwise the linker might decide to pull in a
3745    definition from some other object, eg. a static library.
3746
3747    Update: As of August 2004, we support a new convention.  Function
3748    calls may use the function descriptor symbol, ie. "bl foo".  This
3749    behaves exactly as "bl .foo".  */
3750
3751 /* Of those relocs that might be copied as dynamic relocs, this function
3752    selects those that must be copied when linking a shared library,
3753    even when the symbol is local.  */
3754
3755 static int
3756 must_be_dyn_reloc (struct bfd_link_info *info,
3757                    enum elf_ppc64_reloc_type r_type)
3758 {
3759   switch (r_type)
3760     {
3761     default:
3762       return 1;
3763
3764     case R_PPC64_REL32:
3765     case R_PPC64_REL64:
3766     case R_PPC64_REL30:
3767       return 0;
3768
3769     case R_PPC64_TPREL16:
3770     case R_PPC64_TPREL16_LO:
3771     case R_PPC64_TPREL16_HI:
3772     case R_PPC64_TPREL16_HA:
3773     case R_PPC64_TPREL16_DS:
3774     case R_PPC64_TPREL16_LO_DS:
3775     case R_PPC64_TPREL16_HIGH:
3776     case R_PPC64_TPREL16_HIGHA:
3777     case R_PPC64_TPREL16_HIGHER:
3778     case R_PPC64_TPREL16_HIGHERA:
3779     case R_PPC64_TPREL16_HIGHEST:
3780     case R_PPC64_TPREL16_HIGHESTA:
3781     case R_PPC64_TPREL64:
3782       return !bfd_link_executable (info);
3783     }
3784 }
3785
3786 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3787    copying dynamic variables from a shared lib into an app's dynbss
3788    section, and instead use a dynamic relocation to point into the
3789    shared lib.  With code that gcc generates, it's vital that this be
3790    enabled;  In the PowerPC64 ABI, the address of a function is actually
3791    the address of a function descriptor, which resides in the .opd
3792    section.  gcc uses the descriptor directly rather than going via the
3793    GOT as some other ABI's do, which means that initialized function
3794    pointers must reference the descriptor.  Thus, a function pointer
3795    initialized to the address of a function in a shared library will
3796    either require a copy reloc, or a dynamic reloc.  Using a copy reloc
3797    redefines the function descriptor symbol to point to the copy.  This
3798    presents a problem as a plt entry for that function is also
3799    initialized from the function descriptor symbol and the copy reloc
3800    may not be initialized first.  */
3801 #define ELIMINATE_COPY_RELOCS 1
3802
3803 /* Section name for stubs is the associated section name plus this
3804    string.  */
3805 #define STUB_SUFFIX ".stub"
3806
3807 /* Linker stubs.
3808    ppc_stub_long_branch:
3809    Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3810    destination, but a 24 bit branch in a stub section will reach.
3811    .    b       dest
3812
3813    ppc_stub_plt_branch:
3814    Similar to the above, but a 24 bit branch in the stub section won't
3815    reach its destination.
3816    .    addis   %r11,%r2,xxx@toc@ha
3817    .    ld      %r12,xxx@toc@l(%r11)
3818    .    mtctr   %r12
3819    .    bctr
3820
3821    ppc_stub_plt_call:
3822    Used to call a function in a shared library.  If it so happens that
3823    the plt entry referenced crosses a 64k boundary, then an extra
3824    "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3825    .    std     %r2,40(%r1)
3826    .    addis   %r11,%r2,xxx@toc@ha
3827    .    ld      %r12,xxx+0@toc@l(%r11)
3828    .    mtctr   %r12
3829    .    ld      %r2,xxx+8@toc@l(%r11)
3830    .    ld      %r11,xxx+16@toc@l(%r11)
3831    .    bctr
3832
3833    ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3834    code to adjust the value and save r2 to support multiple toc sections.
3835    A ppc_stub_long_branch with an r2 offset looks like:
3836    .    std     %r2,40(%r1)
3837    .    addis   %r2,%r2,off@ha
3838    .    addi    %r2,%r2,off@l
3839    .    b       dest
3840
3841    A ppc_stub_plt_branch with an r2 offset looks like:
3842    .    std     %r2,40(%r1)
3843    .    addis   %r11,%r2,xxx@toc@ha
3844    .    ld      %r12,xxx@toc@l(%r11)
3845    .    addis   %r2,%r2,off@ha
3846    .    addi    %r2,%r2,off@l
3847    .    mtctr   %r12
3848    .    bctr
3849
3850    In cases where the "addis" instruction would add zero, the "addis" is
3851    omitted and following instructions modified slightly in some cases.
3852 */
3853
3854 enum ppc_stub_type {
3855   ppc_stub_none,
3856   ppc_stub_long_branch,
3857   ppc_stub_long_branch_r2off,
3858   ppc_stub_plt_branch,
3859   ppc_stub_plt_branch_r2off,
3860   ppc_stub_plt_call,
3861   ppc_stub_plt_call_r2save,
3862   ppc_stub_global_entry,
3863   ppc_stub_save_res
3864 };
3865
3866 /* Information on stub grouping.  */
3867 struct map_stub
3868 {
3869   /* The stub section.  */
3870   asection *stub_sec;
3871   /* This is the section to which stubs in the group will be attached.  */
3872   asection *link_sec;
3873   /* Next group.  */
3874   struct map_stub *next;
3875   /* Whether to emit a copy of register save/restore functions in this
3876      group.  */
3877   int needs_save_res;
3878 };
3879
3880 struct ppc_stub_hash_entry {
3881
3882   /* Base hash table entry structure.  */
3883   struct bfd_hash_entry root;
3884
3885   enum ppc_stub_type stub_type;
3886
3887   /* Group information.  */
3888   struct map_stub *group;
3889
3890   /* Offset within stub_sec of the beginning of this stub.  */
3891   bfd_vma stub_offset;
3892
3893   /* Given the symbol's value and its section we can determine its final
3894      value when building the stubs (so the stub knows where to jump.  */
3895   bfd_vma target_value;
3896   asection *target_section;
3897
3898   /* The symbol table entry, if any, that this was derived from.  */
3899   struct ppc_link_hash_entry *h;
3900   struct plt_entry *plt_ent;
3901
3902   /* Symbol st_other.  */
3903   unsigned char other;
3904 };
3905
3906 struct ppc_branch_hash_entry {
3907
3908   /* Base hash table entry structure.  */
3909   struct bfd_hash_entry root;
3910
3911   /* Offset within branch lookup table.  */
3912   unsigned int offset;
3913
3914   /* Generation marker.  */
3915   unsigned int iter;
3916 };
3917
3918 /* Used to track dynamic relocations for local symbols.  */
3919 struct ppc_dyn_relocs
3920 {
3921   struct ppc_dyn_relocs *next;
3922
3923   /* The input section of the reloc.  */
3924   asection *sec;
3925
3926   /* Total number of relocs copied for the input section.  */
3927   unsigned int count : 31;
3928
3929   /* Whether this entry is for STT_GNU_IFUNC symbols.  */
3930   unsigned int ifunc : 1;
3931 };
3932
3933 struct ppc_link_hash_entry
3934 {
3935   struct elf_link_hash_entry elf;
3936
3937   union {
3938     /* A pointer to the most recently used stub hash entry against this
3939        symbol.  */
3940     struct ppc_stub_hash_entry *stub_cache;
3941
3942     /* A pointer to the next symbol starting with a '.'  */
3943     struct ppc_link_hash_entry *next_dot_sym;
3944   } u;
3945
3946   /* Track dynamic relocs copied for this symbol.  */
3947   struct elf_dyn_relocs *dyn_relocs;
3948
3949   /* Link between function code and descriptor symbols.  */
3950   struct ppc_link_hash_entry *oh;
3951
3952   /* Flag function code and descriptor symbols.  */
3953   unsigned int is_func:1;
3954   unsigned int is_func_descriptor:1;
3955   unsigned int fake:1;
3956
3957   /* Whether global opd/toc sym has been adjusted or not.
3958      After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3959      should be set for all globals defined in any opd/toc section.  */
3960   unsigned int adjust_done:1;
3961
3962   /* Set if we twiddled this symbol to weak at some stage.  */
3963   unsigned int was_undefined:1;
3964
3965   /* Set if this is an out-of-line register save/restore function,
3966      with non-standard calling convention.  */
3967   unsigned int save_res:1;
3968
3969   /* Contexts in which symbol is used in the GOT (or TOC).
3970      TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3971      corresponding relocs are encountered during check_relocs.
3972      tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3973      indicate the corresponding GOT entry type is not needed.
3974      tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3975      a TPREL one.  We use a separate flag rather than setting TPREL
3976      just for convenience in distinguishing the two cases.  */
3977 #define TLS_GD           1      /* GD reloc. */
3978 #define TLS_LD           2      /* LD reloc. */
3979 #define TLS_TPREL        4      /* TPREL reloc, => IE. */
3980 #define TLS_DTPREL       8      /* DTPREL reloc, => LD. */
3981 #define TLS_TLS         16      /* Any TLS reloc.  */
3982 #define TLS_EXPLICIT    32      /* Marks TOC section TLS relocs. */
3983 #define TLS_TPRELGD     64      /* TPREL reloc resulting from GD->IE. */
3984 #define PLT_IFUNC      128      /* STT_GNU_IFUNC.  */
3985   unsigned char tls_mask;
3986 };
3987
3988 /* ppc64 ELF linker hash table.  */
3989
3990 struct ppc_link_hash_table
3991 {
3992   struct elf_link_hash_table elf;
3993
3994   /* The stub hash table.  */
3995   struct bfd_hash_table stub_hash_table;
3996
3997   /* Another hash table for plt_branch stubs.  */
3998   struct bfd_hash_table branch_hash_table;
3999
4000   /* Hash table for function prologue tocsave.  */
4001   htab_t tocsave_htab;
4002
4003   /* Various options and other info passed from the linker.  */
4004   struct ppc64_elf_params *params;
4005
4006   /* The size of sec_info below.  */
4007   unsigned int sec_info_arr_size;
4008
4009   /* Per-section array of extra section info.  Done this way rather
4010      than as part of ppc64_elf_section_data so we have the info for
4011      non-ppc64 sections.  */
4012   struct
4013   {
4014     /* Along with elf_gp, specifies the TOC pointer used by this section.  */
4015     bfd_vma toc_off;
4016
4017     union
4018     {
4019       /* The section group that this section belongs to.  */
4020       struct map_stub *group;
4021       /* A temp section list pointer.  */
4022       asection *list;
4023     } u;
4024   } *sec_info;
4025
4026   /* Linked list of groups.  */
4027   struct map_stub *group;
4028
4029   /* Temp used when calculating TOC pointers.  */
4030   bfd_vma toc_curr;
4031   bfd *toc_bfd;
4032   asection *toc_first_sec;
4033
4034   /* Used when adding symbols.  */
4035   struct ppc_link_hash_entry *dot_syms;
4036
4037   /* Shortcuts to get to dynamic linker sections.  */
4038   asection *dynbss;
4039   asection *relbss;
4040   asection *glink;
4041   asection *sfpr;
4042   asection *brlt;
4043   asection *relbrlt;
4044   asection *glink_eh_frame;
4045
4046   /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
4047   struct ppc_link_hash_entry *tls_get_addr;
4048   struct ppc_link_hash_entry *tls_get_addr_fd;
4049
4050   /* The size of reliplt used by got entry relocs.  */
4051   bfd_size_type got_reli_size;
4052
4053   /* Statistics.  */
4054   unsigned long stub_count[ppc_stub_global_entry];
4055
4056   /* Number of stubs against global syms.  */
4057   unsigned long stub_globals;
4058
4059   /* Set if we're linking code with function descriptors.  */
4060   unsigned int opd_abi:1;
4061
4062   /* Support for multiple toc sections.  */
4063   unsigned int do_multi_toc:1;
4064   unsigned int multi_toc_needed:1;
4065   unsigned int second_toc_pass:1;
4066   unsigned int do_toc_opt:1;
4067
4068   /* Set on error.  */
4069   unsigned int stub_error:1;
4070
4071   /* Temp used by ppc64_elf_before_check_relocs.  */
4072   unsigned int twiddled_syms:1;
4073
4074   /* Incremented every time we size stubs.  */
4075   unsigned int stub_iteration;
4076
4077   /* Small local sym cache.  */
4078   struct sym_cache sym_cache;
4079 };
4080
4081 /* Rename some of the generic section flags to better document how they
4082    are used here.  */
4083
4084 /* Nonzero if this section has TLS related relocations.  */
4085 #define has_tls_reloc sec_flg0
4086
4087 /* Nonzero if this section has a call to __tls_get_addr.  */
4088 #define has_tls_get_addr_call sec_flg1
4089
4090 /* Nonzero if this section has any toc or got relocs.  */
4091 #define has_toc_reloc sec_flg2
4092
4093 /* Nonzero if this section has a call to another section that uses
4094    the toc or got.  */
4095 #define makes_toc_func_call sec_flg3
4096
4097 /* Recursion protection when determining above flag.  */
4098 #define call_check_in_progress sec_flg4
4099 #define call_check_done sec_flg5
4100
4101 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
4102
4103 #define ppc_hash_table(p) \
4104   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
4105   == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
4106
4107 #define ppc_stub_hash_lookup(table, string, create, copy) \
4108   ((struct ppc_stub_hash_entry *) \
4109    bfd_hash_lookup ((table), (string), (create), (copy)))
4110
4111 #define ppc_branch_hash_lookup(table, string, create, copy) \
4112   ((struct ppc_branch_hash_entry *) \
4113    bfd_hash_lookup ((table), (string), (create), (copy)))
4114
4115 /* Create an entry in the stub hash table.  */
4116
4117 static struct bfd_hash_entry *
4118 stub_hash_newfunc (struct bfd_hash_entry *entry,
4119                    struct bfd_hash_table *table,
4120                    const char *string)
4121 {
4122   /* Allocate the structure if it has not already been allocated by a
4123      subclass.  */
4124   if (entry == NULL)
4125     {
4126       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4127       if (entry == NULL)
4128         return entry;
4129     }
4130
4131   /* Call the allocation method of the superclass.  */
4132   entry = bfd_hash_newfunc (entry, table, string);
4133   if (entry != NULL)
4134     {
4135       struct ppc_stub_hash_entry *eh;
4136
4137       /* Initialize the local fields.  */
4138       eh = (struct ppc_stub_hash_entry *) entry;
4139       eh->stub_type = ppc_stub_none;
4140       eh->group = NULL;
4141       eh->stub_offset = 0;
4142       eh->target_value = 0;
4143       eh->target_section = NULL;
4144       eh->h = NULL;
4145       eh->plt_ent = NULL;
4146       eh->other = 0;
4147     }
4148
4149   return entry;
4150 }
4151
4152 /* Create an entry in the branch hash table.  */
4153
4154 static struct bfd_hash_entry *
4155 branch_hash_newfunc (struct bfd_hash_entry *entry,
4156                      struct bfd_hash_table *table,
4157                      const char *string)
4158 {
4159   /* Allocate the structure if it has not already been allocated by a
4160      subclass.  */
4161   if (entry == NULL)
4162     {
4163       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4164       if (entry == NULL)
4165         return entry;
4166     }
4167
4168   /* Call the allocation method of the superclass.  */
4169   entry = bfd_hash_newfunc (entry, table, string);
4170   if (entry != NULL)
4171     {
4172       struct ppc_branch_hash_entry *eh;
4173
4174       /* Initialize the local fields.  */
4175       eh = (struct ppc_branch_hash_entry *) entry;
4176       eh->offset = 0;
4177       eh->iter = 0;
4178     }
4179
4180   return entry;
4181 }
4182
4183 /* Create an entry in a ppc64 ELF linker hash table.  */
4184
4185 static struct bfd_hash_entry *
4186 link_hash_newfunc (struct bfd_hash_entry *entry,
4187                    struct bfd_hash_table *table,
4188                    const char *string)
4189 {
4190   /* Allocate the structure if it has not already been allocated by a
4191      subclass.  */
4192   if (entry == NULL)
4193     {
4194       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4195       if (entry == NULL)
4196         return entry;
4197     }
4198
4199   /* Call the allocation method of the superclass.  */
4200   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4201   if (entry != NULL)
4202     {
4203       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4204
4205       memset (&eh->u.stub_cache, 0,
4206               (sizeof (struct ppc_link_hash_entry)
4207                - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4208
4209       /* When making function calls, old ABI code references function entry
4210          points (dot symbols), while new ABI code references the function
4211          descriptor symbol.  We need to make any combination of reference and
4212          definition work together, without breaking archive linking.
4213
4214          For a defined function "foo" and an undefined call to "bar":
4215          An old object defines "foo" and ".foo", references ".bar" (possibly
4216          "bar" too).
4217          A new object defines "foo" and references "bar".
4218
4219          A new object thus has no problem with its undefined symbols being
4220          satisfied by definitions in an old object.  On the other hand, the
4221          old object won't have ".bar" satisfied by a new object.
4222
4223          Keep a list of newly added dot-symbols.  */
4224
4225       if (string[0] == '.')
4226         {
4227           struct ppc_link_hash_table *htab;
4228
4229           htab = (struct ppc_link_hash_table *) table;
4230           eh->u.next_dot_sym = htab->dot_syms;
4231           htab->dot_syms = eh;
4232         }
4233     }
4234
4235   return entry;
4236 }
4237
4238 struct tocsave_entry {
4239   asection *sec;
4240   bfd_vma offset;
4241 };
4242
4243 static hashval_t
4244 tocsave_htab_hash (const void *p)
4245 {
4246   const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4247   return ((bfd_vma)(intptr_t) e->sec ^ e->offset) >> 3;
4248 }
4249
4250 static int
4251 tocsave_htab_eq (const void *p1, const void *p2)
4252 {
4253   const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4254   const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4255   return e1->sec == e2->sec && e1->offset == e2->offset;
4256 }
4257
4258 /* Destroy a ppc64 ELF linker hash table.  */
4259
4260 static void
4261 ppc64_elf_link_hash_table_free (bfd *obfd)
4262 {
4263   struct ppc_link_hash_table *htab;
4264
4265   htab = (struct ppc_link_hash_table *) obfd->link.hash;
4266   if (htab->tocsave_htab)
4267     htab_delete (htab->tocsave_htab);
4268   bfd_hash_table_free (&htab->branch_hash_table);
4269   bfd_hash_table_free (&htab->stub_hash_table);
4270   _bfd_elf_link_hash_table_free (obfd);
4271 }
4272
4273 /* Create a ppc64 ELF linker hash table.  */
4274
4275 static struct bfd_link_hash_table *
4276 ppc64_elf_link_hash_table_create (bfd *abfd)
4277 {
4278   struct ppc_link_hash_table *htab;
4279   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4280
4281   htab = bfd_zmalloc (amt);
4282   if (htab == NULL)
4283     return NULL;
4284
4285   if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4286                                       sizeof (struct ppc_link_hash_entry),
4287                                       PPC64_ELF_DATA))
4288     {
4289       free (htab);
4290       return NULL;
4291     }
4292
4293   /* Init the stub hash table too.  */
4294   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4295                             sizeof (struct ppc_stub_hash_entry)))
4296     {
4297       _bfd_elf_link_hash_table_free (abfd);
4298       return NULL;
4299     }
4300
4301   /* And the branch hash table.  */
4302   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4303                             sizeof (struct ppc_branch_hash_entry)))
4304     {
4305       bfd_hash_table_free (&htab->stub_hash_table);
4306       _bfd_elf_link_hash_table_free (abfd);
4307       return NULL;
4308     }
4309
4310   htab->tocsave_htab = htab_try_create (1024,
4311                                         tocsave_htab_hash,
4312                                         tocsave_htab_eq,
4313                                         NULL);
4314   if (htab->tocsave_htab == NULL)
4315     {
4316       ppc64_elf_link_hash_table_free (abfd);
4317       return NULL;
4318     }
4319   htab->elf.root.hash_table_free = ppc64_elf_link_hash_table_free;
4320
4321   /* Initializing two fields of the union is just cosmetic.  We really
4322      only care about glist, but when compiled on a 32-bit host the
4323      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
4324      debugger inspection of these fields look nicer.  */
4325   htab->elf.init_got_refcount.refcount = 0;
4326   htab->elf.init_got_refcount.glist = NULL;
4327   htab->elf.init_plt_refcount.refcount = 0;
4328   htab->elf.init_plt_refcount.glist = NULL;
4329   htab->elf.init_got_offset.offset = 0;
4330   htab->elf.init_got_offset.glist = NULL;
4331   htab->elf.init_plt_offset.offset = 0;
4332   htab->elf.init_plt_offset.glist = NULL;
4333
4334   return &htab->elf.root;
4335 }
4336
4337 /* Create sections for linker generated code.  */
4338
4339 static bfd_boolean
4340 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4341 {
4342   struct ppc_link_hash_table *htab;
4343   flagword flags;
4344
4345   htab = ppc_hash_table (info);
4346
4347   /* Create .sfpr for code to save and restore fp regs.  */
4348   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4349            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4350   htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4351                                                    flags);
4352   if (htab->sfpr == NULL
4353       || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4354     return FALSE;
4355
4356   /* Create .glink for lazy dynamic linking support.  */
4357   htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4358                                                     flags);
4359   if (htab->glink == NULL
4360       || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4361     return FALSE;
4362
4363   if (!info->no_ld_generated_unwind_info)
4364     {
4365       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4366                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4367       htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4368                                                                  ".eh_frame",
4369                                                                  flags);
4370       if (htab->glink_eh_frame == NULL
4371           || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4372         return FALSE;
4373     }
4374
4375   flags = SEC_ALLOC | SEC_LINKER_CREATED;
4376   htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4377   if (htab->elf.iplt == NULL
4378       || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4379     return FALSE;
4380
4381   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4382            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4383   htab->elf.irelplt
4384     = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4385   if (htab->elf.irelplt == NULL
4386       || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4387     return FALSE;
4388
4389   /* Create branch lookup table for plt_branch stubs.  */
4390   flags = (SEC_ALLOC | SEC_LOAD
4391            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4392   htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4393                                                    flags);
4394   if (htab->brlt == NULL
4395       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4396     return FALSE;
4397
4398   if (!bfd_link_pic (info))
4399     return TRUE;
4400
4401   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4402            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4403   htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4404                                                       ".rela.branch_lt",
4405                                                       flags);
4406   if (htab->relbrlt == NULL
4407       || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4408     return FALSE;
4409
4410   return TRUE;
4411 }
4412
4413 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
4414
4415 bfd_boolean
4416 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4417                          struct ppc64_elf_params *params)
4418 {
4419   struct ppc_link_hash_table *htab;
4420
4421   elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4422
4423 /* Always hook our dynamic sections into the first bfd, which is the
4424    linker created stub bfd.  This ensures that the GOT header is at
4425    the start of the output TOC section.  */
4426   htab = ppc_hash_table (info);
4427   if (htab == NULL)
4428     return FALSE;
4429   htab->elf.dynobj = params->stub_bfd;
4430   htab->params = params;
4431
4432   if (bfd_link_relocatable (info))
4433     return TRUE;
4434
4435   return create_linkage_sections (htab->elf.dynobj, info);
4436 }
4437
4438 /* Build a name for an entry in the stub hash table.  */
4439
4440 static char *
4441 ppc_stub_name (const asection *input_section,
4442                const asection *sym_sec,
4443                const struct ppc_link_hash_entry *h,
4444                const Elf_Internal_Rela *rel)
4445 {
4446   char *stub_name;
4447   ssize_t len;
4448
4449   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4450      offsets from a sym as a branch target?  In fact, we could
4451      probably assume the addend is always zero.  */
4452   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4453
4454   if (h)
4455     {
4456       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4457       stub_name = bfd_malloc (len);
4458       if (stub_name == NULL)
4459         return stub_name;
4460
4461       len = sprintf (stub_name, "%08x.%s+%x",
4462                      input_section->id & 0xffffffff,
4463                      h->elf.root.root.string,
4464                      (int) rel->r_addend & 0xffffffff);
4465     }
4466   else
4467     {
4468       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4469       stub_name = bfd_malloc (len);
4470       if (stub_name == NULL)
4471         return stub_name;
4472
4473       len = sprintf (stub_name, "%08x.%x:%x+%x",
4474                      input_section->id & 0xffffffff,
4475                      sym_sec->id & 0xffffffff,
4476                      (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4477                      (int) rel->r_addend & 0xffffffff);
4478     }
4479   if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4480     stub_name[len - 2] = 0;
4481   return stub_name;
4482 }
4483
4484 /* Look up an entry in the stub hash.  Stub entries are cached because
4485    creating the stub name takes a bit of time.  */
4486
4487 static struct ppc_stub_hash_entry *
4488 ppc_get_stub_entry (const asection *input_section,
4489                     const asection *sym_sec,
4490                     struct ppc_link_hash_entry *h,
4491                     const Elf_Internal_Rela *rel,
4492                     struct ppc_link_hash_table *htab)
4493 {
4494   struct ppc_stub_hash_entry *stub_entry;
4495   struct map_stub *group;
4496
4497   /* If this input section is part of a group of sections sharing one
4498      stub section, then use the id of the first section in the group.
4499      Stub names need to include a section id, as there may well be
4500      more than one stub used to reach say, printf, and we need to
4501      distinguish between them.  */
4502   group = htab->sec_info[input_section->id].u.group;
4503
4504   if (h != NULL && h->u.stub_cache != NULL
4505       && h->u.stub_cache->h == h
4506       && h->u.stub_cache->group == group)
4507     {
4508       stub_entry = h->u.stub_cache;
4509     }
4510   else
4511     {
4512       char *stub_name;
4513
4514       stub_name = ppc_stub_name (group->link_sec, sym_sec, h, rel);
4515       if (stub_name == NULL)
4516         return NULL;
4517
4518       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4519                                          stub_name, FALSE, FALSE);
4520       if (h != NULL)
4521         h->u.stub_cache = stub_entry;
4522
4523       free (stub_name);
4524     }
4525
4526   return stub_entry;
4527 }
4528
4529 /* Add a new stub entry to the stub hash.  Not all fields of the new
4530    stub entry are initialised.  */
4531
4532 static struct ppc_stub_hash_entry *
4533 ppc_add_stub (const char *stub_name,
4534               asection *section,
4535               struct bfd_link_info *info)
4536 {
4537   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4538   struct map_stub *group;
4539   asection *link_sec;
4540   asection *stub_sec;
4541   struct ppc_stub_hash_entry *stub_entry;
4542
4543   group = htab->sec_info[section->id].u.group;
4544   link_sec = group->link_sec;
4545   stub_sec = group->stub_sec;
4546   if (stub_sec == NULL)
4547     {
4548       size_t namelen;
4549       bfd_size_type len;
4550       char *s_name;
4551
4552       namelen = strlen (link_sec->name);
4553       len = namelen + sizeof (STUB_SUFFIX);
4554       s_name = bfd_alloc (htab->params->stub_bfd, len);
4555       if (s_name == NULL)
4556         return NULL;
4557
4558       memcpy (s_name, link_sec->name, namelen);
4559       memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4560       stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4561       if (stub_sec == NULL)
4562         return NULL;
4563       group->stub_sec = stub_sec;
4564     }
4565
4566   /* Enter this entry into the linker stub hash table.  */
4567   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4568                                      TRUE, FALSE);
4569   if (stub_entry == NULL)
4570     {
4571       info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4572                               section->owner, stub_name);
4573       return NULL;
4574     }
4575
4576   stub_entry->group = group;
4577   stub_entry->stub_offset = 0;
4578   return stub_entry;
4579 }
4580
4581 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4582    not already done.  */
4583
4584 static bfd_boolean
4585 create_got_section (bfd *abfd, struct bfd_link_info *info)
4586 {
4587   asection *got, *relgot;
4588   flagword flags;
4589   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4590
4591   if (!is_ppc64_elf (abfd))
4592     return FALSE;
4593   if (htab == NULL)
4594     return FALSE;
4595
4596   if (!htab->elf.sgot
4597       && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4598     return FALSE;
4599
4600   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4601            | SEC_LINKER_CREATED);
4602
4603   got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4604   if (!got
4605       || !bfd_set_section_alignment (abfd, got, 3))
4606     return FALSE;
4607
4608   relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4609                                                flags | SEC_READONLY);
4610   if (!relgot
4611       || ! bfd_set_section_alignment (abfd, relgot, 3))
4612     return FALSE;
4613
4614   ppc64_elf_tdata (abfd)->got = got;
4615   ppc64_elf_tdata (abfd)->relgot = relgot;
4616   return TRUE;
4617 }
4618
4619 /* Create the dynamic sections, and set up shortcuts.  */
4620
4621 static bfd_boolean
4622 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4623 {
4624   struct ppc_link_hash_table *htab;
4625
4626   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4627     return FALSE;
4628
4629   htab = ppc_hash_table (info);
4630   if (htab == NULL)
4631     return FALSE;
4632
4633   htab->dynbss = bfd_get_linker_section (dynobj, ".dynbss");
4634   if (!bfd_link_pic (info))
4635     htab->relbss = bfd_get_linker_section (dynobj, ".rela.bss");
4636
4637   if (!htab->elf.sgot || !htab->elf.splt || !htab->elf.srelplt || !htab->dynbss
4638       || (!bfd_link_pic (info) && !htab->relbss))
4639     abort ();
4640
4641   return TRUE;
4642 }
4643
4644 /* Follow indirect and warning symbol links.  */
4645
4646 static inline struct bfd_link_hash_entry *
4647 follow_link (struct bfd_link_hash_entry *h)
4648 {
4649   while (h->type == bfd_link_hash_indirect
4650          || h->type == bfd_link_hash_warning)
4651     h = h->u.i.link;
4652   return h;
4653 }
4654
4655 static inline struct elf_link_hash_entry *
4656 elf_follow_link (struct elf_link_hash_entry *h)
4657 {
4658   return (struct elf_link_hash_entry *) follow_link (&h->root);
4659 }
4660
4661 static inline struct ppc_link_hash_entry *
4662 ppc_follow_link (struct ppc_link_hash_entry *h)
4663 {
4664   return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4665 }
4666
4667 /* Merge PLT info on FROM with that on TO.  */
4668
4669 static void
4670 move_plt_plist (struct ppc_link_hash_entry *from,
4671                 struct ppc_link_hash_entry *to)
4672 {
4673   if (from->elf.plt.plist != NULL)
4674     {
4675       if (to->elf.plt.plist != NULL)
4676         {
4677           struct plt_entry **entp;
4678           struct plt_entry *ent;
4679
4680           for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4681             {
4682               struct plt_entry *dent;
4683
4684               for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4685                 if (dent->addend == ent->addend)
4686                   {
4687                     dent->plt.refcount += ent->plt.refcount;
4688                     *entp = ent->next;
4689                     break;
4690                   }
4691               if (dent == NULL)
4692                 entp = &ent->next;
4693             }
4694           *entp = to->elf.plt.plist;
4695         }
4696
4697       to->elf.plt.plist = from->elf.plt.plist;
4698       from->elf.plt.plist = NULL;
4699     }
4700 }
4701
4702 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
4703
4704 static void
4705 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4706                                 struct elf_link_hash_entry *dir,
4707                                 struct elf_link_hash_entry *ind)
4708 {
4709   struct ppc_link_hash_entry *edir, *eind;
4710
4711   edir = (struct ppc_link_hash_entry *) dir;
4712   eind = (struct ppc_link_hash_entry *) ind;
4713
4714   edir->is_func |= eind->is_func;
4715   edir->is_func_descriptor |= eind->is_func_descriptor;
4716   edir->tls_mask |= eind->tls_mask;
4717   if (eind->oh != NULL)
4718     edir->oh = ppc_follow_link (eind->oh);
4719
4720   /* If called to transfer flags for a weakdef during processing
4721      of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4722      We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
4723   if (!(ELIMINATE_COPY_RELOCS
4724         && eind->elf.root.type != bfd_link_hash_indirect
4725         && edir->elf.dynamic_adjusted))
4726     edir->elf.non_got_ref |= eind->elf.non_got_ref;
4727
4728   edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4729   edir->elf.ref_regular |= eind->elf.ref_regular;
4730   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4731   edir->elf.needs_plt |= eind->elf.needs_plt;
4732   edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4733
4734   /* Copy over any dynamic relocs we may have on the indirect sym.  */
4735   if (eind->dyn_relocs != NULL)
4736     {
4737       if (edir->dyn_relocs != NULL)
4738         {
4739           struct elf_dyn_relocs **pp;
4740           struct elf_dyn_relocs *p;
4741
4742           /* Add reloc counts against the indirect sym to the direct sym
4743              list.  Merge any entries against the same section.  */
4744           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4745             {
4746               struct elf_dyn_relocs *q;
4747
4748               for (q = edir->dyn_relocs; q != NULL; q = q->next)
4749                 if (q->sec == p->sec)
4750                   {
4751                     q->pc_count += p->pc_count;
4752                     q->count += p->count;
4753                     *pp = p->next;
4754                     break;
4755                   }
4756               if (q == NULL)
4757                 pp = &p->next;
4758             }
4759           *pp = edir->dyn_relocs;
4760         }
4761
4762       edir->dyn_relocs = eind->dyn_relocs;
4763       eind->dyn_relocs = NULL;
4764     }
4765
4766   /* If we were called to copy over info for a weak sym, that's all.
4767      You might think dyn_relocs need not be copied over;  After all,
4768      both syms will be dynamic or both non-dynamic so we're just
4769      moving reloc accounting around.  However, ELIMINATE_COPY_RELOCS
4770      code in ppc64_elf_adjust_dynamic_symbol needs to check for
4771      dyn_relocs in read-only sections, and it does so on what is the
4772      DIR sym here.  */
4773   if (eind->elf.root.type != bfd_link_hash_indirect)
4774     return;
4775
4776   /* Copy over got entries that we may have already seen to the
4777      symbol which just became indirect.  */
4778   if (eind->elf.got.glist != NULL)
4779     {
4780       if (edir->elf.got.glist != NULL)
4781         {
4782           struct got_entry **entp;
4783           struct got_entry *ent;
4784
4785           for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4786             {
4787               struct got_entry *dent;
4788
4789               for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4790                 if (dent->addend == ent->addend
4791                     && dent->owner == ent->owner
4792                     && dent->tls_type == ent->tls_type)
4793                   {
4794                     dent->got.refcount += ent->got.refcount;
4795                     *entp = ent->next;
4796                     break;
4797                   }
4798               if (dent == NULL)
4799                 entp = &ent->next;
4800             }
4801           *entp = edir->elf.got.glist;
4802         }
4803
4804       edir->elf.got.glist = eind->elf.got.glist;
4805       eind->elf.got.glist = NULL;
4806     }
4807
4808   /* And plt entries.  */
4809   move_plt_plist (eind, edir);
4810
4811   if (eind->elf.dynindx != -1)
4812     {
4813       if (edir->elf.dynindx != -1)
4814         _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4815                                 edir->elf.dynstr_index);
4816       edir->elf.dynindx = eind->elf.dynindx;
4817       edir->elf.dynstr_index = eind->elf.dynstr_index;
4818       eind->elf.dynindx = -1;
4819       eind->elf.dynstr_index = 0;
4820     }
4821 }
4822
4823 /* Find the function descriptor hash entry from the given function code
4824    hash entry FH.  Link the entries via their OH fields.  */
4825
4826 static struct ppc_link_hash_entry *
4827 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4828 {
4829   struct ppc_link_hash_entry *fdh = fh->oh;
4830
4831   if (fdh == NULL)
4832     {
4833       const char *fd_name = fh->elf.root.root.string + 1;
4834
4835       fdh = (struct ppc_link_hash_entry *)
4836         elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4837       if (fdh == NULL)
4838         return fdh;
4839
4840       fdh->is_func_descriptor = 1;
4841       fdh->oh = fh;
4842       fh->is_func = 1;
4843       fh->oh = fdh;
4844     }
4845
4846   return ppc_follow_link (fdh);
4847 }
4848
4849 /* Make a fake function descriptor sym for the code sym FH.  */
4850
4851 static struct ppc_link_hash_entry *
4852 make_fdh (struct bfd_link_info *info,
4853           struct ppc_link_hash_entry *fh)
4854 {
4855   bfd *abfd;
4856   asymbol *newsym;
4857   struct bfd_link_hash_entry *bh;
4858   struct ppc_link_hash_entry *fdh;
4859
4860   abfd = fh->elf.root.u.undef.abfd;
4861   newsym = bfd_make_empty_symbol (abfd);
4862   newsym->name = fh->elf.root.root.string + 1;
4863   newsym->section = bfd_und_section_ptr;
4864   newsym->value = 0;
4865   newsym->flags = BSF_WEAK;
4866
4867   bh = NULL;
4868   if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4869                                          newsym->flags, newsym->section,
4870                                          newsym->value, NULL, FALSE, FALSE,
4871                                          &bh))
4872     return NULL;
4873
4874   fdh = (struct ppc_link_hash_entry *) bh;
4875   fdh->elf.non_elf = 0;
4876   fdh->fake = 1;
4877   fdh->is_func_descriptor = 1;
4878   fdh->oh = fh;
4879   fh->is_func = 1;
4880   fh->oh = fdh;
4881   return fdh;
4882 }
4883
4884 /* Fix function descriptor symbols defined in .opd sections to be
4885    function type.  */
4886
4887 static bfd_boolean
4888 ppc64_elf_add_symbol_hook (bfd *ibfd,
4889                            struct bfd_link_info *info,
4890                            Elf_Internal_Sym *isym,
4891                            const char **name,
4892                            flagword *flags ATTRIBUTE_UNUSED,
4893                            asection **sec,
4894                            bfd_vma *value)
4895 {
4896   if ((ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4897        || ELF_ST_BIND (isym->st_info) == STB_GNU_UNIQUE)
4898       && (ibfd->flags & DYNAMIC) == 0
4899       && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
4900     elf_tdata (info->output_bfd)->has_gnu_symbols = elf_gnu_symbol_any;
4901
4902   if (*sec != NULL
4903       && strcmp ((*sec)->name, ".opd") == 0)
4904     {
4905       asection *code_sec;
4906
4907       if (!(ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4908             || ELF_ST_TYPE (isym->st_info) == STT_FUNC))
4909         isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4910
4911       /* If the symbol is a function defined in .opd, and the function
4912          code is in a discarded group, let it appear to be undefined.  */
4913       if (!bfd_link_relocatable (info)
4914           && (*sec)->reloc_count != 0
4915           && opd_entry_value (*sec, *value, &code_sec, NULL,
4916                               FALSE) != (bfd_vma) -1
4917           && discarded_section (code_sec))
4918         {
4919           *sec = bfd_und_section_ptr;
4920           isym->st_shndx = SHN_UNDEF;
4921         }
4922     }
4923   else if (*sec != NULL
4924            && strcmp ((*sec)->name, ".toc") == 0
4925            && ELF_ST_TYPE (isym->st_info) == STT_OBJECT)
4926     {
4927       struct ppc_link_hash_table *htab = ppc_hash_table (info);
4928       if (htab != NULL)
4929         htab->params->object_in_toc = 1;
4930     }
4931
4932   if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4933     {
4934       if (abiversion (ibfd) == 0)
4935         set_abiversion (ibfd, 2);
4936       else if (abiversion (ibfd) == 1)
4937         {
4938           info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other"
4939                                     " for ABI version 1\n"), name);
4940           bfd_set_error (bfd_error_bad_value);
4941           return FALSE;
4942         }
4943     }
4944
4945   return TRUE;
4946 }
4947
4948 /* Merge non-visibility st_other attributes: local entry point.  */
4949
4950 static void
4951 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
4952                                   const Elf_Internal_Sym *isym,
4953                                   bfd_boolean definition,
4954                                   bfd_boolean dynamic)
4955 {
4956   if (definition && !dynamic)
4957     h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
4958                 | ELF_ST_VISIBILITY (h->other));
4959 }
4960
4961 /* This function makes an old ABI object reference to ".bar" cause the
4962    inclusion of a new ABI object archive that defines "bar".
4963    NAME is a symbol defined in an archive.  Return a symbol in the hash
4964    table that might be satisfied by the archive symbols.  */
4965
4966 static struct elf_link_hash_entry *
4967 ppc64_elf_archive_symbol_lookup (bfd *abfd,
4968                                  struct bfd_link_info *info,
4969                                  const char *name)
4970 {
4971   struct elf_link_hash_entry *h;
4972   char *dot_name;
4973   size_t len;
4974
4975   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4976   if (h != NULL
4977       /* Don't return this sym if it is a fake function descriptor
4978          created by add_symbol_adjust.  */
4979       && !(h->root.type == bfd_link_hash_undefweak
4980            && ((struct ppc_link_hash_entry *) h)->fake))
4981     return h;
4982
4983   if (name[0] == '.')
4984     return h;
4985
4986   len = strlen (name);
4987   dot_name = bfd_alloc (abfd, len + 2);
4988   if (dot_name == NULL)
4989     return (struct elf_link_hash_entry *) 0 - 1;
4990   dot_name[0] = '.';
4991   memcpy (dot_name + 1, name, len + 1);
4992   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4993   bfd_release (abfd, dot_name);
4994   return h;
4995 }
4996
4997 /* This function satisfies all old ABI object references to ".bar" if a
4998    new ABI object defines "bar".  Well, at least, undefined dot symbols
4999    are made weak.  This stops later archive searches from including an
5000    object if we already have a function descriptor definition.  It also
5001    prevents the linker complaining about undefined symbols.
5002    We also check and correct mismatched symbol visibility here.  The
5003    most restrictive visibility of the function descriptor and the
5004    function entry symbol is used.  */
5005
5006 static bfd_boolean
5007 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
5008 {
5009   struct ppc_link_hash_table *htab;
5010   struct ppc_link_hash_entry *fdh;
5011
5012   if (eh->elf.root.type == bfd_link_hash_indirect)
5013     return TRUE;
5014
5015   if (eh->elf.root.type == bfd_link_hash_warning)
5016     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
5017
5018   if (eh->elf.root.root.string[0] != '.')
5019     abort ();
5020
5021   htab = ppc_hash_table (info);
5022   if (htab == NULL)
5023     return FALSE;
5024
5025   fdh = lookup_fdh (eh, htab);
5026   if (fdh == NULL)
5027     {
5028       if (!bfd_link_relocatable (info)
5029           && (eh->elf.root.type == bfd_link_hash_undefined
5030               || eh->elf.root.type == bfd_link_hash_undefweak)
5031           && eh->elf.ref_regular)
5032         {
5033           /* Make an undefweak function descriptor sym, which is enough to
5034              pull in an --as-needed shared lib, but won't cause link
5035              errors.  Archives are handled elsewhere.  */
5036           fdh = make_fdh (info, eh);
5037           if (fdh == NULL)
5038             return FALSE;
5039           fdh->elf.ref_regular = 1;
5040         }
5041     }
5042   else
5043     {
5044       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
5045       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
5046       if (entry_vis < descr_vis)
5047         fdh->elf.other += entry_vis - descr_vis;
5048       else if (entry_vis > descr_vis)
5049         eh->elf.other += descr_vis - entry_vis;
5050
5051       if ((fdh->elf.root.type == bfd_link_hash_defined
5052            || fdh->elf.root.type == bfd_link_hash_defweak)
5053           && eh->elf.root.type == bfd_link_hash_undefined)
5054         {
5055           eh->elf.root.type = bfd_link_hash_undefweak;
5056           eh->was_undefined = 1;
5057           htab->twiddled_syms = 1;
5058         }
5059     }
5060
5061   return TRUE;
5062 }
5063
5064 /* Set up opd section info and abiversion for IBFD, and process list
5065    of dot-symbols we made in link_hash_newfunc.  */
5066
5067 static bfd_boolean
5068 ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
5069 {
5070   struct ppc_link_hash_table *htab;
5071   struct ppc_link_hash_entry **p, *eh;
5072   asection *opd = bfd_get_section_by_name (ibfd, ".opd");
5073
5074   if (opd != NULL && opd->size != 0)
5075     {
5076       if (abiversion (ibfd) == 0)
5077         set_abiversion (ibfd, 1);
5078       else if (abiversion (ibfd) == 2)
5079         {
5080           info->callbacks->einfo (_("%P: %B .opd not allowed in ABI"
5081                                     " version %d\n"),
5082                                   ibfd, abiversion (ibfd));
5083           bfd_set_error (bfd_error_bad_value);
5084           return FALSE;
5085         }
5086
5087       if ((ibfd->flags & DYNAMIC) == 0
5088           && (opd->flags & SEC_RELOC) != 0
5089           && opd->reloc_count != 0
5090           && !bfd_is_abs_section (opd->output_section))
5091         {
5092           /* Garbage collection needs some extra help with .opd sections.
5093              We don't want to necessarily keep everything referenced by
5094              relocs in .opd, as that would keep all functions.  Instead,
5095              if we reference an .opd symbol (a function descriptor), we
5096              want to keep the function code symbol's section.  This is
5097              easy for global symbols, but for local syms we need to keep
5098              information about the associated function section.  */
5099           bfd_size_type amt;
5100           asection **opd_sym_map;
5101
5102           amt = OPD_NDX (opd->size) * sizeof (*opd_sym_map);
5103           opd_sym_map = bfd_zalloc (ibfd, amt);
5104           if (opd_sym_map == NULL)
5105             return FALSE;
5106           ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
5107           BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
5108           ppc64_elf_section_data (opd)->sec_type = sec_opd;
5109         }
5110     }
5111
5112   if (!is_ppc64_elf (info->output_bfd))
5113     return TRUE;
5114   htab = ppc_hash_table (info);
5115   if (htab == NULL)
5116     return FALSE;
5117
5118   /* For input files without an explicit abiversion in e_flags
5119      we should have flagged any with symbol st_other bits set
5120      as ELFv1 and above flagged those with .opd as ELFv2.
5121      Set the output abiversion if not yet set, and for any input
5122      still ambiguous, take its abiversion from the output.
5123      Differences in ABI are reported later.  */
5124   if (abiversion (info->output_bfd) == 0)
5125     set_abiversion (info->output_bfd, abiversion (ibfd));
5126   else if (abiversion (ibfd) == 0)
5127     set_abiversion (ibfd, abiversion (info->output_bfd));
5128
5129   p = &htab->dot_syms;
5130   while ((eh = *p) != NULL)
5131     {
5132       *p = NULL;
5133       if (&eh->elf == htab->elf.hgot)
5134         ;
5135       else if (htab->elf.hgot == NULL
5136                && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
5137         htab->elf.hgot = &eh->elf;
5138       else if (!add_symbol_adjust (eh, info))
5139         return FALSE;
5140       p = &eh->u.next_dot_sym;
5141     }
5142
5143   /* Clear the list for non-ppc64 input files.  */
5144   p = &htab->dot_syms;
5145   while ((eh = *p) != NULL)
5146     {
5147       *p = NULL;
5148       p = &eh->u.next_dot_sym;
5149     }
5150
5151   /* We need to fix the undefs list for any syms we have twiddled to
5152      undef_weak.  */
5153   if (htab->twiddled_syms)
5154     {
5155       bfd_link_repair_undef_list (&htab->elf.root);
5156       htab->twiddled_syms = 0;
5157     }
5158   return TRUE;
5159 }
5160
5161 /* Undo hash table changes when an --as-needed input file is determined
5162    not to be needed.  */
5163
5164 static bfd_boolean
5165 ppc64_elf_notice_as_needed (bfd *ibfd,
5166                             struct bfd_link_info *info,
5167                             enum notice_asneeded_action act)
5168 {
5169   if (act == notice_not_needed)
5170     {
5171       struct ppc_link_hash_table *htab = ppc_hash_table (info);
5172
5173       if (htab == NULL)
5174         return FALSE;
5175
5176       htab->dot_syms = NULL;
5177     }
5178   return _bfd_elf_notice_as_needed (ibfd, info, act);
5179 }
5180
5181 /* If --just-symbols against a final linked binary, then assume we need
5182    toc adjusting stubs when calling functions defined there.  */
5183
5184 static void
5185 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5186 {
5187   if ((sec->flags & SEC_CODE) != 0
5188       && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5189       && is_ppc64_elf (sec->owner))
5190     {
5191       if (abiversion (sec->owner) >= 2
5192           || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5193         sec->has_toc_reloc = 1;
5194     }
5195   _bfd_elf_link_just_syms (sec, info);
5196 }
5197
5198 static struct plt_entry **
5199 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5200                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5201 {
5202   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5203   struct plt_entry **local_plt;
5204   unsigned char *local_got_tls_masks;
5205
5206   if (local_got_ents == NULL)
5207     {
5208       bfd_size_type size = symtab_hdr->sh_info;
5209
5210       size *= (sizeof (*local_got_ents)
5211                + sizeof (*local_plt)
5212                + sizeof (*local_got_tls_masks));
5213       local_got_ents = bfd_zalloc (abfd, size);
5214       if (local_got_ents == NULL)
5215         return NULL;
5216       elf_local_got_ents (abfd) = local_got_ents;
5217     }
5218
5219   if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
5220     {
5221       struct got_entry *ent;
5222
5223       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5224         if (ent->addend == r_addend
5225             && ent->owner == abfd
5226             && ent->tls_type == tls_type)
5227           break;
5228       if (ent == NULL)
5229         {
5230           bfd_size_type amt = sizeof (*ent);
5231           ent = bfd_alloc (abfd, amt);
5232           if (ent == NULL)
5233             return FALSE;
5234           ent->next = local_got_ents[r_symndx];
5235           ent->addend = r_addend;
5236           ent->owner = abfd;
5237           ent->tls_type = tls_type;
5238           ent->is_indirect = FALSE;
5239           ent->got.refcount = 0;
5240           local_got_ents[r_symndx] = ent;
5241         }
5242       ent->got.refcount += 1;
5243     }
5244
5245   local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5246   local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5247   local_got_tls_masks[r_symndx] |= tls_type;
5248
5249   return local_plt + r_symndx;
5250 }
5251
5252 static bfd_boolean
5253 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5254 {
5255   struct plt_entry *ent;
5256
5257   for (ent = *plist; ent != NULL; ent = ent->next)
5258     if (ent->addend == addend)
5259       break;
5260   if (ent == NULL)
5261     {
5262       bfd_size_type amt = sizeof (*ent);
5263       ent = bfd_alloc (abfd, amt);
5264       if (ent == NULL)
5265         return FALSE;
5266       ent->next = *plist;
5267       ent->addend = addend;
5268       ent->plt.refcount = 0;
5269       *plist = ent;
5270     }
5271   ent->plt.refcount += 1;
5272   return TRUE;
5273 }
5274
5275 static bfd_boolean
5276 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5277 {
5278   return (r_type == R_PPC64_REL24
5279           || r_type == R_PPC64_REL14
5280           || r_type == R_PPC64_REL14_BRTAKEN
5281           || r_type == R_PPC64_REL14_BRNTAKEN
5282           || r_type == R_PPC64_ADDR24
5283           || r_type == R_PPC64_ADDR14
5284           || r_type == R_PPC64_ADDR14_BRTAKEN
5285           || r_type == R_PPC64_ADDR14_BRNTAKEN);
5286 }
5287
5288 /* Look through the relocs for a section during the first phase, and
5289    calculate needed space in the global offset table, procedure
5290    linkage table, and dynamic reloc sections.  */
5291
5292 static bfd_boolean
5293 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5294                         asection *sec, const Elf_Internal_Rela *relocs)
5295 {
5296   struct ppc_link_hash_table *htab;
5297   Elf_Internal_Shdr *symtab_hdr;
5298   struct elf_link_hash_entry **sym_hashes;
5299   const Elf_Internal_Rela *rel;
5300   const Elf_Internal_Rela *rel_end;
5301   asection *sreloc;
5302   asection **opd_sym_map;
5303   struct elf_link_hash_entry *tga, *dottga;
5304
5305   if (bfd_link_relocatable (info))
5306     return TRUE;
5307
5308   /* Don't do anything special with non-loaded, non-alloced sections.
5309      In particular, any relocs in such sections should not affect GOT
5310      and PLT reference counting (ie. we don't allow them to create GOT
5311      or PLT entries), there's no possibility or desire to optimize TLS
5312      relocs, and there's not much point in propagating relocs to shared
5313      libs that the dynamic linker won't relocate.  */
5314   if ((sec->flags & SEC_ALLOC) == 0)
5315     return TRUE;
5316
5317   BFD_ASSERT (is_ppc64_elf (abfd));
5318
5319   htab = ppc_hash_table (info);
5320   if (htab == NULL)
5321     return FALSE;
5322
5323   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5324                               FALSE, FALSE, TRUE);
5325   dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5326                                  FALSE, FALSE, TRUE);
5327   symtab_hdr = &elf_symtab_hdr (abfd);
5328   sym_hashes = elf_sym_hashes (abfd);
5329   sreloc = NULL;
5330   opd_sym_map = NULL;
5331   if (ppc64_elf_section_data (sec) != NULL
5332       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
5333     opd_sym_map = ppc64_elf_section_data (sec)->u.opd.func_sec;
5334
5335   rel_end = relocs + sec->reloc_count;
5336   for (rel = relocs; rel < rel_end; rel++)
5337     {
5338       unsigned long r_symndx;
5339       struct elf_link_hash_entry *h;
5340       enum elf_ppc64_reloc_type r_type;
5341       int tls_type;
5342       struct _ppc64_elf_section_data *ppc64_sec;
5343       struct plt_entry **ifunc, **plt_list;
5344
5345       r_symndx = ELF64_R_SYM (rel->r_info);
5346       if (r_symndx < symtab_hdr->sh_info)
5347         h = NULL;
5348       else
5349         {
5350           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5351           h = elf_follow_link (h);
5352
5353           /* PR15323, ref flags aren't set for references in the same
5354              object.  */
5355           h->root.non_ir_ref = 1;
5356
5357           if (h == htab->elf.hgot)
5358             sec->has_toc_reloc = 1;
5359         }
5360
5361       tls_type = 0;
5362       ifunc = NULL;
5363       if (h != NULL)
5364         {
5365           if (h->type == STT_GNU_IFUNC)
5366             {
5367               h->needs_plt = 1;
5368               ifunc = &h->plt.plist;
5369             }
5370         }
5371       else
5372         {
5373           Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5374                                                           abfd, r_symndx);
5375           if (isym == NULL)
5376             return FALSE;
5377
5378           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5379             {
5380               ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5381                                              rel->r_addend, PLT_IFUNC);
5382               if (ifunc == NULL)
5383                 return FALSE;
5384             }
5385         }
5386
5387       r_type = ELF64_R_TYPE (rel->r_info);
5388       switch (r_type)
5389         {
5390         case R_PPC64_TLSGD:
5391         case R_PPC64_TLSLD:
5392           /* These special tls relocs tie a call to __tls_get_addr with
5393              its parameter symbol.  */
5394           break;
5395
5396         case R_PPC64_GOT_TLSLD16:
5397         case R_PPC64_GOT_TLSLD16_LO:
5398         case R_PPC64_GOT_TLSLD16_HI:
5399         case R_PPC64_GOT_TLSLD16_HA:
5400           tls_type = TLS_TLS | TLS_LD;
5401           goto dogottls;
5402
5403         case R_PPC64_GOT_TLSGD16:
5404         case R_PPC64_GOT_TLSGD16_LO:
5405         case R_PPC64_GOT_TLSGD16_HI:
5406         case R_PPC64_GOT_TLSGD16_HA:
5407           tls_type = TLS_TLS | TLS_GD;
5408           goto dogottls;
5409
5410         case R_PPC64_GOT_TPREL16_DS:
5411         case R_PPC64_GOT_TPREL16_LO_DS:
5412         case R_PPC64_GOT_TPREL16_HI:
5413         case R_PPC64_GOT_TPREL16_HA:
5414           if (bfd_link_pic (info))
5415             info->flags |= DF_STATIC_TLS;
5416           tls_type = TLS_TLS | TLS_TPREL;
5417           goto dogottls;
5418
5419         case R_PPC64_GOT_DTPREL16_DS:
5420         case R_PPC64_GOT_DTPREL16_LO_DS:
5421         case R_PPC64_GOT_DTPREL16_HI:
5422         case R_PPC64_GOT_DTPREL16_HA:
5423           tls_type = TLS_TLS | TLS_DTPREL;
5424         dogottls:
5425           sec->has_tls_reloc = 1;
5426           /* Fall thru */
5427
5428         case R_PPC64_GOT16:
5429         case R_PPC64_GOT16_DS:
5430         case R_PPC64_GOT16_HA:
5431         case R_PPC64_GOT16_HI:
5432         case R_PPC64_GOT16_LO:
5433         case R_PPC64_GOT16_LO_DS:
5434           /* This symbol requires a global offset table entry.  */
5435           sec->has_toc_reloc = 1;
5436           if (r_type == R_PPC64_GOT_TLSLD16
5437               || r_type == R_PPC64_GOT_TLSGD16
5438               || r_type == R_PPC64_GOT_TPREL16_DS
5439               || r_type == R_PPC64_GOT_DTPREL16_DS
5440               || r_type == R_PPC64_GOT16
5441               || r_type == R_PPC64_GOT16_DS)
5442             {
5443               htab->do_multi_toc = 1;
5444               ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5445             }
5446
5447           if (ppc64_elf_tdata (abfd)->got == NULL
5448               && !create_got_section (abfd, info))
5449             return FALSE;
5450
5451           if (h != NULL)
5452             {
5453               struct ppc_link_hash_entry *eh;
5454               struct got_entry *ent;
5455
5456               eh = (struct ppc_link_hash_entry *) h;
5457               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5458                 if (ent->addend == rel->r_addend
5459                     && ent->owner == abfd
5460                     && ent->tls_type == tls_type)
5461                   break;
5462               if (ent == NULL)
5463                 {
5464                   bfd_size_type amt = sizeof (*ent);
5465                   ent = bfd_alloc (abfd, amt);
5466                   if (ent == NULL)
5467                     return FALSE;
5468                   ent->next = eh->elf.got.glist;
5469                   ent->addend = rel->r_addend;
5470                   ent->owner = abfd;
5471                   ent->tls_type = tls_type;
5472                   ent->is_indirect = FALSE;
5473                   ent->got.refcount = 0;
5474                   eh->elf.got.glist = ent;
5475                 }
5476               ent->got.refcount += 1;
5477               eh->tls_mask |= tls_type;
5478             }
5479           else
5480             /* This is a global offset table entry for a local symbol.  */
5481             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5482                                         rel->r_addend, tls_type))
5483               return FALSE;
5484
5485           /* We may also need a plt entry if the symbol turns out to be
5486              an ifunc.  */
5487           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1)
5488             {
5489               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5490                 return FALSE;
5491             }
5492           break;
5493
5494         case R_PPC64_PLT16_HA:
5495         case R_PPC64_PLT16_HI:
5496         case R_PPC64_PLT16_LO:
5497         case R_PPC64_PLT32:
5498         case R_PPC64_PLT64:
5499           /* This symbol requires a procedure linkage table entry.  */
5500           plt_list = ifunc;
5501           if (h != NULL)
5502             {
5503               h->needs_plt = 1;
5504               if (h->root.root.string[0] == '.'
5505                   && h->root.root.string[1] != '\0')
5506                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5507               plt_list = &h->plt.plist;
5508             }
5509           if (plt_list == NULL)
5510             {
5511               /* It does not make sense to have a procedure linkage
5512                  table entry for a non-ifunc local symbol.  */
5513               info->callbacks->einfo
5514                 (_("%P: %H: %s reloc against local symbol\n"),
5515                  abfd, sec, rel->r_offset,
5516                  ppc64_elf_howto_table[r_type]->name);
5517               bfd_set_error (bfd_error_bad_value);
5518               return FALSE;
5519             }
5520           if (!update_plt_info (abfd, plt_list, rel->r_addend))
5521             return FALSE;
5522           break;
5523
5524           /* The following relocations don't need to propagate the
5525              relocation if linking a shared object since they are
5526              section relative.  */
5527         case R_PPC64_SECTOFF:
5528         case R_PPC64_SECTOFF_LO:
5529         case R_PPC64_SECTOFF_HI:
5530         case R_PPC64_SECTOFF_HA:
5531         case R_PPC64_SECTOFF_DS:
5532         case R_PPC64_SECTOFF_LO_DS:
5533         case R_PPC64_DTPREL16:
5534         case R_PPC64_DTPREL16_LO:
5535         case R_PPC64_DTPREL16_HI:
5536         case R_PPC64_DTPREL16_HA:
5537         case R_PPC64_DTPREL16_DS:
5538         case R_PPC64_DTPREL16_LO_DS:
5539         case R_PPC64_DTPREL16_HIGH:
5540         case R_PPC64_DTPREL16_HIGHA:
5541         case R_PPC64_DTPREL16_HIGHER:
5542         case R_PPC64_DTPREL16_HIGHERA:
5543         case R_PPC64_DTPREL16_HIGHEST:
5544         case R_PPC64_DTPREL16_HIGHESTA:
5545           break;
5546
5547           /* Nor do these.  */
5548         case R_PPC64_REL16:
5549         case R_PPC64_REL16_LO:
5550         case R_PPC64_REL16_HI:
5551         case R_PPC64_REL16_HA:
5552         case R_PPC64_REL16DX_HA:
5553           break;
5554
5555           /* Not supported as a dynamic relocation.  */
5556         case R_PPC64_ADDR64_LOCAL:
5557           if (bfd_link_pic (info))
5558             {
5559               if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5560                 ppc_howto_init ();
5561               info->callbacks->einfo (_("%P: %H: %s reloc unsupported "
5562                                         "in shared libraries and PIEs.\n"),
5563                                       abfd, sec, rel->r_offset,
5564                                       ppc64_elf_howto_table[r_type]->name);
5565               bfd_set_error (bfd_error_bad_value);
5566               return FALSE;
5567             }
5568           break;
5569
5570         case R_PPC64_TOC16:
5571         case R_PPC64_TOC16_DS:
5572           htab->do_multi_toc = 1;
5573           ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5574         case R_PPC64_TOC16_LO:
5575         case R_PPC64_TOC16_HI:
5576         case R_PPC64_TOC16_HA:
5577         case R_PPC64_TOC16_LO_DS:
5578           sec->has_toc_reloc = 1;
5579           break;
5580
5581           /* Marker reloc.  */
5582         case R_PPC64_ENTRY:
5583           break;
5584
5585           /* This relocation describes the C++ object vtable hierarchy.
5586              Reconstruct it for later use during GC.  */
5587         case R_PPC64_GNU_VTINHERIT:
5588           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5589             return FALSE;
5590           break;
5591
5592           /* This relocation describes which C++ vtable entries are actually
5593              used.  Record for later use during GC.  */
5594         case R_PPC64_GNU_VTENTRY:
5595           BFD_ASSERT (h != NULL);
5596           if (h != NULL
5597               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5598             return FALSE;
5599           break;
5600
5601         case R_PPC64_REL14:
5602         case R_PPC64_REL14_BRTAKEN:
5603         case R_PPC64_REL14_BRNTAKEN:
5604           {
5605             asection *dest = NULL;
5606
5607             /* Heuristic: If jumping outside our section, chances are
5608                we are going to need a stub.  */
5609             if (h != NULL)
5610               {
5611                 /* If the sym is weak it may be overridden later, so
5612                    don't assume we know where a weak sym lives.  */
5613                 if (h->root.type == bfd_link_hash_defined)
5614                   dest = h->root.u.def.section;
5615               }
5616             else
5617               {
5618                 Elf_Internal_Sym *isym;
5619
5620                 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5621                                               abfd, r_symndx);
5622                 if (isym == NULL)
5623                   return FALSE;
5624
5625                 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5626               }
5627
5628             if (dest != sec)
5629               ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5630           }
5631           /* Fall through.  */
5632
5633         case R_PPC64_REL24:
5634           plt_list = ifunc;
5635           if (h != NULL)
5636             {
5637               h->needs_plt = 1;
5638               if (h->root.root.string[0] == '.'
5639                   && h->root.root.string[1] != '\0')
5640                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5641
5642               if (h == tga || h == dottga)
5643                 {
5644                   sec->has_tls_reloc = 1;
5645                   if (rel != relocs
5646                       && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5647                           || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5648                     /* We have a new-style __tls_get_addr call with
5649                        a marker reloc.  */
5650                     ;
5651                   else
5652                     /* Mark this section as having an old-style call.  */
5653                     sec->has_tls_get_addr_call = 1;
5654                 }
5655               plt_list = &h->plt.plist;
5656             }
5657
5658           /* We may need a .plt entry if the function this reloc
5659              refers to is in a shared lib.  */
5660           if (plt_list
5661               && !update_plt_info (abfd, plt_list, rel->r_addend))
5662             return FALSE;
5663           break;
5664
5665         case R_PPC64_ADDR14:
5666         case R_PPC64_ADDR14_BRNTAKEN:
5667         case R_PPC64_ADDR14_BRTAKEN:
5668         case R_PPC64_ADDR24:
5669           goto dodyn;
5670
5671         case R_PPC64_TPREL64:
5672           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5673           if (bfd_link_pic (info))
5674             info->flags |= DF_STATIC_TLS;
5675           goto dotlstoc;
5676
5677         case R_PPC64_DTPMOD64:
5678           if (rel + 1 < rel_end
5679               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5680               && rel[1].r_offset == rel->r_offset + 8)
5681             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5682           else
5683             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5684           goto dotlstoc;
5685
5686         case R_PPC64_DTPREL64:
5687           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5688           if (rel != relocs
5689               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5690               && rel[-1].r_offset == rel->r_offset - 8)
5691             /* This is the second reloc of a dtpmod, dtprel pair.
5692                Don't mark with TLS_DTPREL.  */
5693             goto dodyn;
5694
5695         dotlstoc:
5696           sec->has_tls_reloc = 1;
5697           if (h != NULL)
5698             {
5699               struct ppc_link_hash_entry *eh;
5700               eh = (struct ppc_link_hash_entry *) h;
5701               eh->tls_mask |= tls_type;
5702             }
5703           else
5704             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5705                                         rel->r_addend, tls_type))
5706               return FALSE;
5707
5708           ppc64_sec = ppc64_elf_section_data (sec);
5709           if (ppc64_sec->sec_type != sec_toc)
5710             {
5711               bfd_size_type amt;
5712
5713               /* One extra to simplify get_tls_mask.  */
5714               amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5715               ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5716               if (ppc64_sec->u.toc.symndx == NULL)
5717                 return FALSE;
5718               amt = sec->size * sizeof (bfd_vma) / 8;
5719               ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5720               if (ppc64_sec->u.toc.add == NULL)
5721                 return FALSE;
5722               BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5723               ppc64_sec->sec_type = sec_toc;
5724             }
5725           BFD_ASSERT (rel->r_offset % 8 == 0);
5726           ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5727           ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5728
5729           /* Mark the second slot of a GD or LD entry.
5730              -1 to indicate GD and -2 to indicate LD.  */
5731           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5732             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5733           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5734             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5735           goto dodyn;
5736
5737         case R_PPC64_TPREL16:
5738         case R_PPC64_TPREL16_LO:
5739         case R_PPC64_TPREL16_HI:
5740         case R_PPC64_TPREL16_HA:
5741         case R_PPC64_TPREL16_DS:
5742         case R_PPC64_TPREL16_LO_DS:
5743         case R_PPC64_TPREL16_HIGH:
5744         case R_PPC64_TPREL16_HIGHA:
5745         case R_PPC64_TPREL16_HIGHER:
5746         case R_PPC64_TPREL16_HIGHERA:
5747         case R_PPC64_TPREL16_HIGHEST:
5748         case R_PPC64_TPREL16_HIGHESTA:
5749           if (bfd_link_pic (info))
5750             {
5751               info->flags |= DF_STATIC_TLS;
5752               goto dodyn;
5753             }
5754           break;
5755
5756         case R_PPC64_ADDR64:
5757           if (opd_sym_map != NULL
5758               && rel + 1 < rel_end
5759               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5760             {
5761               if (h != NULL)
5762                 {
5763                   if (h->root.root.string[0] == '.'
5764                       && h->root.root.string[1] != 0
5765                       && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
5766                     ;
5767                   else
5768                     ((struct ppc_link_hash_entry *) h)->is_func = 1;
5769                 }
5770               else
5771                 {
5772                   asection *s;
5773                   Elf_Internal_Sym *isym;
5774
5775                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5776                                                 abfd, r_symndx);
5777                   if (isym == NULL)
5778                     return FALSE;
5779
5780                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5781                   if (s != NULL && s != sec)
5782                     opd_sym_map[OPD_NDX (rel->r_offset)] = s;
5783                 }
5784             }
5785           /* Fall through.  */
5786
5787         case R_PPC64_ADDR16:
5788         case R_PPC64_ADDR16_DS:
5789         case R_PPC64_ADDR16_HA:
5790         case R_PPC64_ADDR16_HI:
5791         case R_PPC64_ADDR16_HIGH:
5792         case R_PPC64_ADDR16_HIGHA:
5793         case R_PPC64_ADDR16_HIGHER:
5794         case R_PPC64_ADDR16_HIGHERA:
5795         case R_PPC64_ADDR16_HIGHEST:
5796         case R_PPC64_ADDR16_HIGHESTA:
5797         case R_PPC64_ADDR16_LO:
5798         case R_PPC64_ADDR16_LO_DS:
5799           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1
5800               && rel->r_addend == 0)
5801             {
5802               /* We may need a .plt entry if this reloc refers to a
5803                  function in a shared lib.  */
5804               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5805                 return FALSE;
5806               h->pointer_equality_needed = 1;
5807             }
5808           /* Fall through.  */
5809
5810         case R_PPC64_REL30:
5811         case R_PPC64_REL32:
5812         case R_PPC64_REL64:
5813         case R_PPC64_ADDR32:
5814         case R_PPC64_UADDR16:
5815         case R_PPC64_UADDR32:
5816         case R_PPC64_UADDR64:
5817         case R_PPC64_TOC:
5818           if (h != NULL && !bfd_link_pic (info))
5819             /* We may need a copy reloc.  */
5820             h->non_got_ref = 1;
5821
5822           /* Don't propagate .opd relocs.  */
5823           if (NO_OPD_RELOCS && opd_sym_map != NULL)
5824             break;
5825
5826           /* If we are creating a shared library, and this is a reloc
5827              against a global symbol, or a non PC relative reloc
5828              against a local symbol, then we need to copy the reloc
5829              into the shared library.  However, if we are linking with
5830              -Bsymbolic, we do not need to copy a reloc against a
5831              global symbol which is defined in an object we are
5832              including in the link (i.e., DEF_REGULAR is set).  At
5833              this point we have not seen all the input files, so it is
5834              possible that DEF_REGULAR is not set now but will be set
5835              later (it is never cleared).  In case of a weak definition,
5836              DEF_REGULAR may be cleared later by a strong definition in
5837              a shared library.  We account for that possibility below by
5838              storing information in the dyn_relocs field of the hash
5839              table entry.  A similar situation occurs when creating
5840              shared libraries and symbol visibility changes render the
5841              symbol local.
5842
5843              If on the other hand, we are creating an executable, we
5844              may need to keep relocations for symbols satisfied by a
5845              dynamic library if we manage to avoid copy relocs for the
5846              symbol.  */
5847         dodyn:
5848           if ((bfd_link_pic (info)
5849                && (must_be_dyn_reloc (info, r_type)
5850                    || (h != NULL
5851                        && (!SYMBOLIC_BIND (info, h)
5852                            || h->root.type == bfd_link_hash_defweak
5853                            || !h->def_regular))))
5854               || (ELIMINATE_COPY_RELOCS
5855                   && !bfd_link_pic (info)
5856                   && h != NULL
5857                   && (h->root.type == bfd_link_hash_defweak
5858                       || !h->def_regular))
5859               || (!bfd_link_pic (info)
5860                   && ifunc != NULL))
5861             {
5862               /* We must copy these reloc types into the output file.
5863                  Create a reloc section in dynobj and make room for
5864                  this reloc.  */
5865               if (sreloc == NULL)
5866                 {
5867                   sreloc = _bfd_elf_make_dynamic_reloc_section
5868                     (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5869
5870                   if (sreloc == NULL)
5871                     return FALSE;
5872                 }
5873
5874               /* If this is a global symbol, we count the number of
5875                  relocations we need for this symbol.  */
5876               if (h != NULL)
5877                 {
5878                   struct elf_dyn_relocs *p;
5879                   struct elf_dyn_relocs **head;
5880
5881                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5882                   p = *head;
5883                   if (p == NULL || p->sec != sec)
5884                     {
5885                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5886                       if (p == NULL)
5887                         return FALSE;
5888                       p->next = *head;
5889                       *head = p;
5890                       p->sec = sec;
5891                       p->count = 0;
5892                       p->pc_count = 0;
5893                     }
5894                   p->count += 1;
5895                   if (!must_be_dyn_reloc (info, r_type))
5896                     p->pc_count += 1;
5897                 }
5898               else
5899                 {
5900                   /* Track dynamic relocs needed for local syms too.
5901                      We really need local syms available to do this
5902                      easily.  Oh well.  */
5903                   struct ppc_dyn_relocs *p;
5904                   struct ppc_dyn_relocs **head;
5905                   bfd_boolean is_ifunc;
5906                   asection *s;
5907                   void *vpp;
5908                   Elf_Internal_Sym *isym;
5909
5910                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5911                                                 abfd, r_symndx);
5912                   if (isym == NULL)
5913                     return FALSE;
5914
5915                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5916                   if (s == NULL)
5917                     s = sec;
5918
5919                   vpp = &elf_section_data (s)->local_dynrel;
5920                   head = (struct ppc_dyn_relocs **) vpp;
5921                   is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5922                   p = *head;
5923                   if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5924                     p = p->next;
5925                   if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5926                     {
5927                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5928                       if (p == NULL)
5929                         return FALSE;
5930                       p->next = *head;
5931                       *head = p;
5932                       p->sec = sec;
5933                       p->ifunc = is_ifunc;
5934                       p->count = 0;
5935                     }
5936                   p->count += 1;
5937                 }
5938             }
5939           break;
5940
5941         default:
5942           break;
5943         }
5944     }
5945
5946   return TRUE;
5947 }
5948
5949 /* Merge backend specific data from an object file to the output
5950    object file when linking.  */
5951
5952 static bfd_boolean
5953 ppc64_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
5954 {
5955   unsigned long iflags, oflags;
5956
5957   if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
5958     return TRUE;
5959
5960   if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
5961     return TRUE;
5962
5963   if (!_bfd_generic_verify_endian_match (ibfd, obfd))
5964     return FALSE;
5965
5966   iflags = elf_elfheader (ibfd)->e_flags;
5967   oflags = elf_elfheader (obfd)->e_flags;
5968
5969   if (iflags & ~EF_PPC64_ABI)
5970     {
5971       (*_bfd_error_handler)
5972         (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
5973       bfd_set_error (bfd_error_bad_value);
5974       return FALSE;
5975     }
5976   else if (iflags != oflags && iflags != 0)
5977     {
5978       (*_bfd_error_handler)
5979         (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
5980          ibfd, iflags, oflags);
5981       bfd_set_error (bfd_error_bad_value);
5982       return FALSE;
5983     }
5984
5985   /* Merge Tag_compatibility attributes and any common GNU ones.  */
5986   _bfd_elf_merge_object_attributes (ibfd, obfd);
5987
5988   return TRUE;
5989 }
5990
5991 static bfd_boolean
5992 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
5993 {
5994   /* Print normal ELF private data.  */
5995   _bfd_elf_print_private_bfd_data (abfd, ptr);
5996
5997   if (elf_elfheader (abfd)->e_flags != 0)
5998     {
5999       FILE *file = ptr;
6000
6001       /* xgettext:c-format */
6002       fprintf (file, _("private flags = 0x%lx:"),
6003                elf_elfheader (abfd)->e_flags);
6004
6005       if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
6006         fprintf (file, _(" [abiv%ld]"),
6007                  elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
6008       fputc ('\n', file);
6009     }
6010
6011   return TRUE;
6012 }
6013
6014 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
6015    of the code entry point, and its section, which must be in the same
6016    object as OPD_SEC.  Returns (bfd_vma) -1 on error.  */
6017
6018 static bfd_vma
6019 opd_entry_value (asection *opd_sec,
6020                  bfd_vma offset,
6021                  asection **code_sec,
6022                  bfd_vma *code_off,
6023                  bfd_boolean in_code_sec)
6024 {
6025   bfd *opd_bfd = opd_sec->owner;
6026   Elf_Internal_Rela *relocs;
6027   Elf_Internal_Rela *lo, *hi, *look;
6028   bfd_vma val;
6029
6030   /* No relocs implies we are linking a --just-symbols object, or looking
6031      at a final linked executable with addr2line or somesuch.  */
6032   if (opd_sec->reloc_count == 0)
6033     {
6034       bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
6035
6036       if (contents == NULL)
6037         {
6038           if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
6039             return (bfd_vma) -1;
6040           ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
6041         }
6042
6043       /* PR 17512: file: 64b9dfbb.  */
6044       if (offset + 7 >= opd_sec->size || offset + 7 < offset)
6045         return (bfd_vma) -1;
6046
6047       val = bfd_get_64 (opd_bfd, contents + offset);
6048       if (code_sec != NULL)
6049         {
6050           asection *sec, *likely = NULL;
6051
6052           if (in_code_sec)
6053             {
6054               sec = *code_sec;
6055               if (sec->vma <= val
6056                   && val < sec->vma + sec->size)
6057                 likely = sec;
6058               else
6059                 val = -1;
6060             }
6061           else
6062             for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
6063               if (sec->vma <= val
6064                   && (sec->flags & SEC_LOAD) != 0
6065                   && (sec->flags & SEC_ALLOC) != 0)
6066                 likely = sec;
6067           if (likely != NULL)
6068             {
6069               *code_sec = likely;
6070               if (code_off != NULL)
6071                 *code_off = val - likely->vma;
6072             }
6073         }
6074       return val;
6075     }
6076
6077   BFD_ASSERT (is_ppc64_elf (opd_bfd));
6078
6079   relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
6080   if (relocs == NULL)
6081     relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
6082   /* PR 17512: file: df8e1fd6.  */
6083   if (relocs == NULL)
6084     return (bfd_vma) -1;
6085
6086   /* Go find the opd reloc at the sym address.  */
6087   lo = relocs;
6088   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
6089   val = (bfd_vma) -1;
6090   while (lo < hi)
6091     {
6092       look = lo + (hi - lo) / 2;
6093       if (look->r_offset < offset)
6094         lo = look + 1;
6095       else if (look->r_offset > offset)
6096         hi = look;
6097       else
6098         {
6099           Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
6100
6101           if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
6102               && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
6103             {
6104               unsigned long symndx = ELF64_R_SYM (look->r_info);
6105               asection *sec = NULL;
6106
6107               if (symndx >= symtab_hdr->sh_info
6108                   && elf_sym_hashes (opd_bfd) != NULL)
6109                 {
6110                   struct elf_link_hash_entry **sym_hashes;
6111                   struct elf_link_hash_entry *rh;
6112
6113                   sym_hashes = elf_sym_hashes (opd_bfd);
6114                   rh = sym_hashes[symndx - symtab_hdr->sh_info];
6115                   if (rh != NULL)
6116                     {
6117                       rh = elf_follow_link (rh);
6118                       if (rh->root.type != bfd_link_hash_defined
6119                           && rh->root.type != bfd_link_hash_defweak)
6120                         break;
6121                       if (rh->root.u.def.section->owner == opd_bfd)
6122                         {
6123                           val = rh->root.u.def.value;
6124                           sec = rh->root.u.def.section;
6125                         }
6126                     }
6127                 }
6128
6129               if (sec == NULL)
6130                 {
6131                   Elf_Internal_Sym *sym;
6132
6133                   if (symndx < symtab_hdr->sh_info)
6134                     {
6135                       sym = (Elf_Internal_Sym *) symtab_hdr->contents;
6136                       if (sym == NULL)
6137                         {
6138                           size_t symcnt = symtab_hdr->sh_info;
6139                           sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6140                                                       symcnt, 0,
6141                                                       NULL, NULL, NULL);
6142                           if (sym == NULL)
6143                             break;
6144                           symtab_hdr->contents = (bfd_byte *) sym;
6145                         }
6146                       sym += symndx;
6147                     }
6148                   else
6149                     {
6150                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6151                                                   1, symndx,
6152                                                   NULL, NULL, NULL);
6153                       if (sym == NULL)
6154                         break;
6155                     }
6156                   sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6157                   if (sec == NULL)
6158                     break;
6159                   BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
6160                   val = sym->st_value;
6161                 }
6162
6163               val += look->r_addend;
6164               if (code_off != NULL)
6165                 *code_off = val;
6166               if (code_sec != NULL)
6167                 {
6168                   if (in_code_sec && *code_sec != sec)
6169                     return -1;
6170                   else
6171                     *code_sec = sec;
6172                 }
6173               if (sec->output_section != NULL)
6174                 val += sec->output_section->vma + sec->output_offset;
6175             }
6176           break;
6177         }
6178     }
6179
6180   return val;
6181 }
6182
6183 /* If the ELF symbol SYM might be a function in SEC, return the
6184    function size and set *CODE_OFF to the function's entry point,
6185    otherwise return zero.  */
6186
6187 static bfd_size_type
6188 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6189                               bfd_vma *code_off)
6190 {
6191   bfd_size_type size;
6192
6193   if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6194                      | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6195     return 0;
6196
6197   size = 0;
6198   if (!(sym->flags & BSF_SYNTHETIC))
6199     size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6200
6201   if (strcmp (sym->section->name, ".opd") == 0)
6202     {
6203       struct _opd_sec_data *opd = get_opd_info (sym->section);
6204       bfd_vma symval = sym->value;
6205
6206       if (opd != NULL
6207           && opd->adjust != NULL
6208           && elf_section_data (sym->section)->relocs != NULL)
6209         {
6210           /* opd_entry_value will use cached relocs that have been
6211              adjusted, but with raw symbols.  That means both local
6212              and global symbols need adjusting.  */
6213           long adjust = opd->adjust[OPD_NDX (symval)];
6214           if (adjust == -1)
6215             return 0;
6216           symval += adjust;
6217         }
6218
6219       if (opd_entry_value (sym->section, symval,
6220                            &sec, code_off, TRUE) == (bfd_vma) -1)
6221         return 0;
6222       /* An old ABI binary with dot-syms has a size of 24 on the .opd
6223          symbol.  This size has nothing to do with the code size of the
6224          function, which is what we're supposed to return, but the
6225          code size isn't available without looking up the dot-sym.
6226          However, doing that would be a waste of time particularly
6227          since elf_find_function will look at the dot-sym anyway.
6228          Now, elf_find_function will keep the largest size of any
6229          function sym found at the code address of interest, so return
6230          1 here to avoid it incorrectly caching a larger function size
6231          for a small function.  This does mean we return the wrong
6232          size for a new-ABI function of size 24, but all that does is
6233          disable caching for such functions.  */
6234       if (size == 24)
6235         size = 1;
6236     }
6237   else
6238     {
6239       if (sym->section != sec)
6240         return 0;
6241       *code_off = sym->value;
6242     }
6243   if (size == 0)
6244     size = 1;
6245   return size;
6246 }
6247
6248 /* Return true if symbol is defined in a regular object file.  */
6249
6250 static bfd_boolean
6251 is_static_defined (struct elf_link_hash_entry *h)
6252 {
6253   return ((h->root.type == bfd_link_hash_defined
6254            || h->root.type == bfd_link_hash_defweak)
6255           && h->root.u.def.section != NULL
6256           && h->root.u.def.section->output_section != NULL);
6257 }
6258
6259 /* If FDH is a function descriptor symbol, return the associated code
6260    entry symbol if it is defined.  Return NULL otherwise.  */
6261
6262 static struct ppc_link_hash_entry *
6263 defined_code_entry (struct ppc_link_hash_entry *fdh)
6264 {
6265   if (fdh->is_func_descriptor)
6266     {
6267       struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6268       if (fh->elf.root.type == bfd_link_hash_defined
6269           || fh->elf.root.type == bfd_link_hash_defweak)
6270         return fh;
6271     }
6272   return NULL;
6273 }
6274
6275 /* If FH is a function code entry symbol, return the associated
6276    function descriptor symbol if it is defined.  Return NULL otherwise.  */
6277
6278 static struct ppc_link_hash_entry *
6279 defined_func_desc (struct ppc_link_hash_entry *fh)
6280 {
6281   if (fh->oh != NULL
6282       && fh->oh->is_func_descriptor)
6283     {
6284       struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6285       if (fdh->elf.root.type == bfd_link_hash_defined
6286           || fdh->elf.root.type == bfd_link_hash_defweak)
6287         return fdh;
6288     }
6289   return NULL;
6290 }
6291
6292 /* Mark all our entry sym sections, both opd and code section.  */
6293
6294 static void
6295 ppc64_elf_gc_keep (struct bfd_link_info *info)
6296 {
6297   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6298   struct bfd_sym_chain *sym;
6299
6300   if (htab == NULL)
6301     return;
6302
6303   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6304     {
6305       struct ppc_link_hash_entry *eh, *fh;
6306       asection *sec;
6307
6308       eh = (struct ppc_link_hash_entry *)
6309         elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6310       if (eh == NULL)
6311         continue;
6312       if (eh->elf.root.type != bfd_link_hash_defined
6313           && eh->elf.root.type != bfd_link_hash_defweak)
6314         continue;
6315
6316       fh = defined_code_entry (eh);
6317       if (fh != NULL)
6318         {
6319           sec = fh->elf.root.u.def.section;
6320           sec->flags |= SEC_KEEP;
6321         }
6322       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6323                && opd_entry_value (eh->elf.root.u.def.section,
6324                                    eh->elf.root.u.def.value,
6325                                    &sec, NULL, FALSE) != (bfd_vma) -1)
6326         sec->flags |= SEC_KEEP;
6327
6328       sec = eh->elf.root.u.def.section;
6329       sec->flags |= SEC_KEEP;
6330     }
6331 }
6332
6333 /* Mark sections containing dynamically referenced symbols.  When
6334    building shared libraries, we must assume that any visible symbol is
6335    referenced.  */
6336
6337 static bfd_boolean
6338 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6339 {
6340   struct bfd_link_info *info = (struct bfd_link_info *) inf;
6341   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6342   struct ppc_link_hash_entry *fdh;
6343   struct bfd_elf_dynamic_list *d = info->dynamic_list;
6344
6345   /* Dynamic linking info is on the func descriptor sym.  */
6346   fdh = defined_func_desc (eh);
6347   if (fdh != NULL)
6348     eh = fdh;
6349
6350   if ((eh->elf.root.type == bfd_link_hash_defined
6351        || eh->elf.root.type == bfd_link_hash_defweak)
6352       && (eh->elf.ref_dynamic
6353           || ((eh->elf.def_regular || ELF_COMMON_DEF_P (&eh->elf))
6354               && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6355               && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6356               && (!bfd_link_executable (info)
6357                   || info->export_dynamic
6358                   || (eh->elf.dynamic
6359                       && d != NULL
6360                       && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
6361               && (strchr (eh->elf.root.root.string, ELF_VER_CHR) != NULL
6362                   || !bfd_hide_sym_by_version (info->version_info,
6363                                                eh->elf.root.root.string)))))
6364     {
6365       asection *code_sec;
6366       struct ppc_link_hash_entry *fh;
6367
6368       eh->elf.root.u.def.section->flags |= SEC_KEEP;
6369
6370       /* Function descriptor syms cause the associated
6371          function code sym section to be marked.  */
6372       fh = defined_code_entry (eh);
6373       if (fh != NULL)
6374         {
6375           code_sec = fh->elf.root.u.def.section;
6376           code_sec->flags |= SEC_KEEP;
6377         }
6378       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6379                && opd_entry_value (eh->elf.root.u.def.section,
6380                                    eh->elf.root.u.def.value,
6381                                    &code_sec, NULL, FALSE) != (bfd_vma) -1)
6382         code_sec->flags |= SEC_KEEP;
6383     }
6384
6385   return TRUE;
6386 }
6387
6388 /* Return the section that should be marked against GC for a given
6389    relocation.  */
6390
6391 static asection *
6392 ppc64_elf_gc_mark_hook (asection *sec,
6393                         struct bfd_link_info *info,
6394                         Elf_Internal_Rela *rel,
6395                         struct elf_link_hash_entry *h,
6396                         Elf_Internal_Sym *sym)
6397 {
6398   asection *rsec;
6399
6400   /* Syms return NULL if we're marking .opd, so we avoid marking all
6401      function sections, as all functions are referenced in .opd.  */
6402   rsec = NULL;
6403   if (get_opd_info (sec) != NULL)
6404     return rsec;
6405
6406   if (h != NULL)
6407     {
6408       enum elf_ppc64_reloc_type r_type;
6409       struct ppc_link_hash_entry *eh, *fh, *fdh;
6410
6411       r_type = ELF64_R_TYPE (rel->r_info);
6412       switch (r_type)
6413         {
6414         case R_PPC64_GNU_VTINHERIT:
6415         case R_PPC64_GNU_VTENTRY:
6416           break;
6417
6418         default:
6419           switch (h->root.type)
6420             {
6421             case bfd_link_hash_defined:
6422             case bfd_link_hash_defweak:
6423               eh = (struct ppc_link_hash_entry *) h;
6424               fdh = defined_func_desc (eh);
6425               if (fdh != NULL)
6426                 eh = fdh;
6427
6428               /* Function descriptor syms cause the associated
6429                  function code sym section to be marked.  */
6430               fh = defined_code_entry (eh);
6431               if (fh != NULL)
6432                 {
6433                   /* They also mark their opd section.  */
6434                   eh->elf.root.u.def.section->gc_mark = 1;
6435
6436                   rsec = fh->elf.root.u.def.section;
6437                 }
6438               else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6439                        && opd_entry_value (eh->elf.root.u.def.section,
6440                                            eh->elf.root.u.def.value,
6441                                            &rsec, NULL, FALSE) != (bfd_vma) -1)
6442                 eh->elf.root.u.def.section->gc_mark = 1;
6443               else
6444                 rsec = h->root.u.def.section;
6445               break;
6446
6447             case bfd_link_hash_common:
6448               rsec = h->root.u.c.p->section;
6449               break;
6450
6451             default:
6452               return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6453             }
6454         }
6455     }
6456   else
6457     {
6458       struct _opd_sec_data *opd;
6459
6460       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6461       opd = get_opd_info (rsec);
6462       if (opd != NULL && opd->func_sec != NULL)
6463         {
6464           rsec->gc_mark = 1;
6465
6466           rsec = opd->func_sec[OPD_NDX (sym->st_value + rel->r_addend)];
6467         }
6468     }
6469
6470   return rsec;
6471 }
6472
6473 /* Update the .got, .plt. and dynamic reloc reference counts for the
6474    section being removed.  */
6475
6476 static bfd_boolean
6477 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
6478                          asection *sec, const Elf_Internal_Rela *relocs)
6479 {
6480   struct ppc_link_hash_table *htab;
6481   Elf_Internal_Shdr *symtab_hdr;
6482   struct elf_link_hash_entry **sym_hashes;
6483   struct got_entry **local_got_ents;
6484   const Elf_Internal_Rela *rel, *relend;
6485
6486   if (bfd_link_relocatable (info))
6487     return TRUE;
6488
6489   if ((sec->flags & SEC_ALLOC) == 0)
6490     return TRUE;
6491
6492   elf_section_data (sec)->local_dynrel = NULL;
6493
6494   htab = ppc_hash_table (info);
6495   if (htab == NULL)
6496     return FALSE;
6497
6498   symtab_hdr = &elf_symtab_hdr (abfd);
6499   sym_hashes = elf_sym_hashes (abfd);
6500   local_got_ents = elf_local_got_ents (abfd);
6501
6502   relend = relocs + sec->reloc_count;
6503   for (rel = relocs; rel < relend; rel++)
6504     {
6505       unsigned long r_symndx;
6506       enum elf_ppc64_reloc_type r_type;
6507       struct elf_link_hash_entry *h = NULL;
6508       struct plt_entry **plt_list;
6509       unsigned char tls_type = 0;
6510
6511       r_symndx = ELF64_R_SYM (rel->r_info);
6512       r_type = ELF64_R_TYPE (rel->r_info);
6513       if (r_symndx >= symtab_hdr->sh_info)
6514         {
6515           struct ppc_link_hash_entry *eh;
6516           struct elf_dyn_relocs **pp;
6517           struct elf_dyn_relocs *p;
6518
6519           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6520           h = elf_follow_link (h);
6521           eh = (struct ppc_link_hash_entry *) h;
6522
6523           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6524             if (p->sec == sec)
6525               {
6526                 /* Everything must go for SEC.  */
6527                 *pp = p->next;
6528                 break;
6529               }
6530         }
6531
6532       switch (r_type)
6533         {
6534         case R_PPC64_GOT_TLSLD16:
6535         case R_PPC64_GOT_TLSLD16_LO:
6536         case R_PPC64_GOT_TLSLD16_HI:
6537         case R_PPC64_GOT_TLSLD16_HA:
6538           tls_type = TLS_TLS | TLS_LD;
6539           goto dogot;
6540
6541         case R_PPC64_GOT_TLSGD16:
6542         case R_PPC64_GOT_TLSGD16_LO:
6543         case R_PPC64_GOT_TLSGD16_HI:
6544         case R_PPC64_GOT_TLSGD16_HA:
6545           tls_type = TLS_TLS | TLS_GD;
6546           goto dogot;
6547
6548         case R_PPC64_GOT_TPREL16_DS:
6549         case R_PPC64_GOT_TPREL16_LO_DS:
6550         case R_PPC64_GOT_TPREL16_HI:
6551         case R_PPC64_GOT_TPREL16_HA:
6552           tls_type = TLS_TLS | TLS_TPREL;
6553           goto dogot;
6554
6555         case R_PPC64_GOT_DTPREL16_DS:
6556         case R_PPC64_GOT_DTPREL16_LO_DS:
6557         case R_PPC64_GOT_DTPREL16_HI:
6558         case R_PPC64_GOT_DTPREL16_HA:
6559           tls_type = TLS_TLS | TLS_DTPREL;
6560           goto dogot;
6561
6562         case R_PPC64_GOT16:
6563         case R_PPC64_GOT16_DS:
6564         case R_PPC64_GOT16_HA:
6565         case R_PPC64_GOT16_HI:
6566         case R_PPC64_GOT16_LO:
6567         case R_PPC64_GOT16_LO_DS:
6568         dogot:
6569           {
6570             struct got_entry *ent;
6571
6572             if (h != NULL)
6573               ent = h->got.glist;
6574             else
6575               ent = local_got_ents[r_symndx];
6576
6577             for (; ent != NULL; ent = ent->next)
6578               if (ent->addend == rel->r_addend
6579                   && ent->owner == abfd
6580                   && ent->tls_type == tls_type)
6581                 break;
6582             if (ent == NULL)
6583               abort ();
6584             if (ent->got.refcount > 0)
6585               ent->got.refcount -= 1;
6586           }
6587           break;
6588
6589         case R_PPC64_PLT16_HA:
6590         case R_PPC64_PLT16_HI:
6591         case R_PPC64_PLT16_LO:
6592         case R_PPC64_PLT32:
6593         case R_PPC64_PLT64:
6594         case R_PPC64_REL14:
6595         case R_PPC64_REL14_BRNTAKEN:
6596         case R_PPC64_REL14_BRTAKEN:
6597         case R_PPC64_REL24:
6598           plt_list = NULL;
6599           if (h != NULL)
6600             plt_list = &h->plt.plist;
6601           else if (local_got_ents != NULL)
6602             {
6603               struct plt_entry **local_plt = (struct plt_entry **)
6604                 (local_got_ents + symtab_hdr->sh_info);
6605               unsigned char *local_got_tls_masks = (unsigned char *)
6606                 (local_plt + symtab_hdr->sh_info);
6607               if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6608                 plt_list = local_plt + r_symndx;
6609             }
6610           if (plt_list)
6611             {
6612               struct plt_entry *ent;
6613
6614               for (ent = *plt_list; ent != NULL; ent = ent->next)
6615                 if (ent->addend == rel->r_addend)
6616                   break;
6617               if (ent != NULL && ent->plt.refcount > 0)
6618                 ent->plt.refcount -= 1;
6619             }
6620           break;
6621
6622         default:
6623           break;
6624         }
6625     }
6626   return TRUE;
6627 }
6628
6629 /* The maximum size of .sfpr.  */
6630 #define SFPR_MAX (218*4)
6631
6632 struct sfpr_def_parms
6633 {
6634   const char name[12];
6635   unsigned char lo, hi;
6636   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6637   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6638 };
6639
6640 /* Auto-generate _save*, _rest* functions in .sfpr.
6641    If STUB_SEC is non-null, define alias symbols in STUB_SEC
6642    instead.  */
6643
6644 static bfd_boolean
6645 sfpr_define (struct bfd_link_info *info,
6646              const struct sfpr_def_parms *parm,
6647              asection *stub_sec)
6648 {
6649   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6650   unsigned int i;
6651   size_t len = strlen (parm->name);
6652   bfd_boolean writing = FALSE;
6653   char sym[16];
6654
6655   if (htab == NULL)
6656     return FALSE;
6657
6658   memcpy (sym, parm->name, len);
6659   sym[len + 2] = 0;
6660
6661   for (i = parm->lo; i <= parm->hi; i++)
6662     {
6663       struct ppc_link_hash_entry *h;
6664
6665       sym[len + 0] = i / 10 + '0';
6666       sym[len + 1] = i % 10 + '0';
6667       h = (struct ppc_link_hash_entry *)
6668         elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE);
6669       if (stub_sec != NULL)
6670         {
6671           if (h != NULL
6672               && h->elf.root.type == bfd_link_hash_defined
6673               && h->elf.root.u.def.section == htab->sfpr)
6674             {
6675               struct elf_link_hash_entry *s;
6676               char buf[32];
6677               sprintf (buf, "%08x.%s", stub_sec->id & 0xffffffff, sym);
6678               s = elf_link_hash_lookup (&htab->elf, buf, TRUE, TRUE, FALSE);
6679               if (s == NULL)
6680                 return FALSE;
6681               if (s->root.type == bfd_link_hash_new
6682                   || (s->root.type = bfd_link_hash_defined
6683                       && s->root.u.def.section == stub_sec))
6684                 {
6685                   s->root.type = bfd_link_hash_defined;
6686                   s->root.u.def.section = stub_sec;
6687                   s->root.u.def.value = (stub_sec->size
6688                                          + h->elf.root.u.def.value);
6689                   s->ref_regular = 1;
6690                   s->def_regular = 1;
6691                   s->ref_regular_nonweak = 1;
6692                   s->forced_local = 1;
6693                   s->non_elf = 0;
6694                   s->root.linker_def = 1;
6695                 }
6696             }
6697           continue;
6698         }
6699       if (h != NULL)
6700         {
6701           h->save_res = 1;
6702           if (!h->elf.def_regular)
6703             {
6704               h->elf.root.type = bfd_link_hash_defined;
6705               h->elf.root.u.def.section = htab->sfpr;
6706               h->elf.root.u.def.value = htab->sfpr->size;
6707               h->elf.type = STT_FUNC;
6708               h->elf.def_regular = 1;
6709               _bfd_elf_link_hash_hide_symbol (info, &h->elf, TRUE);
6710               writing = TRUE;
6711               if (htab->sfpr->contents == NULL)
6712                 {
6713                   htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6714                   if (htab->sfpr->contents == NULL)
6715                     return FALSE;
6716                 }
6717             }
6718         }
6719       if (writing)
6720         {
6721           bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6722           if (i != parm->hi)
6723             p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6724           else
6725             p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6726           htab->sfpr->size = p - htab->sfpr->contents;
6727         }
6728     }
6729
6730   return TRUE;
6731 }
6732
6733 static bfd_byte *
6734 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6735 {
6736   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6737   return p + 4;
6738 }
6739
6740 static bfd_byte *
6741 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6742 {
6743   p = savegpr0 (abfd, p, r);
6744   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6745   p = p + 4;
6746   bfd_put_32 (abfd, BLR, p);
6747   return p + 4;
6748 }
6749
6750 static bfd_byte *
6751 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6752 {
6753   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6754   return p + 4;
6755 }
6756
6757 static bfd_byte *
6758 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6759 {
6760   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6761   p = p + 4;
6762   p = restgpr0 (abfd, p, r);
6763   bfd_put_32 (abfd, MTLR_R0, p);
6764   p = p + 4;
6765   if (r == 29)
6766     {
6767       p = restgpr0 (abfd, p, 30);
6768       p = restgpr0 (abfd, p, 31);
6769     }
6770   bfd_put_32 (abfd, BLR, p);
6771   return p + 4;
6772 }
6773
6774 static bfd_byte *
6775 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6776 {
6777   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6778   return p + 4;
6779 }
6780
6781 static bfd_byte *
6782 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6783 {
6784   p = savegpr1 (abfd, p, r);
6785   bfd_put_32 (abfd, BLR, p);
6786   return p + 4;
6787 }
6788
6789 static bfd_byte *
6790 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6791 {
6792   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6793   return p + 4;
6794 }
6795
6796 static bfd_byte *
6797 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6798 {
6799   p = restgpr1 (abfd, p, r);
6800   bfd_put_32 (abfd, BLR, p);
6801   return p + 4;
6802 }
6803
6804 static bfd_byte *
6805 savefpr (bfd *abfd, bfd_byte *p, int r)
6806 {
6807   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6808   return p + 4;
6809 }
6810
6811 static bfd_byte *
6812 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6813 {
6814   p = savefpr (abfd, p, r);
6815   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6816   p = p + 4;
6817   bfd_put_32 (abfd, BLR, p);
6818   return p + 4;
6819 }
6820
6821 static bfd_byte *
6822 restfpr (bfd *abfd, bfd_byte *p, int r)
6823 {
6824   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6825   return p + 4;
6826 }
6827
6828 static bfd_byte *
6829 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6830 {
6831   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6832   p = p + 4;
6833   p = restfpr (abfd, p, r);
6834   bfd_put_32 (abfd, MTLR_R0, p);
6835   p = p + 4;
6836   if (r == 29)
6837     {
6838       p = restfpr (abfd, p, 30);
6839       p = restfpr (abfd, p, 31);
6840     }
6841   bfd_put_32 (abfd, BLR, p);
6842   return p + 4;
6843 }
6844
6845 static bfd_byte *
6846 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6847 {
6848   p = savefpr (abfd, p, r);
6849   bfd_put_32 (abfd, BLR, p);
6850   return p + 4;
6851 }
6852
6853 static bfd_byte *
6854 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6855 {
6856   p = restfpr (abfd, p, r);
6857   bfd_put_32 (abfd, BLR, p);
6858   return p + 4;
6859 }
6860
6861 static bfd_byte *
6862 savevr (bfd *abfd, bfd_byte *p, int r)
6863 {
6864   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6865   p = p + 4;
6866   bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6867   return p + 4;
6868 }
6869
6870 static bfd_byte *
6871 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6872 {
6873   p = savevr (abfd, p, r);
6874   bfd_put_32 (abfd, BLR, p);
6875   return p + 4;
6876 }
6877
6878 static bfd_byte *
6879 restvr (bfd *abfd, bfd_byte *p, int r)
6880 {
6881   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6882   p = p + 4;
6883   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6884   return p + 4;
6885 }
6886
6887 static bfd_byte *
6888 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6889 {
6890   p = restvr (abfd, p, r);
6891   bfd_put_32 (abfd, BLR, p);
6892   return p + 4;
6893 }
6894
6895 /* Called via elf_link_hash_traverse to transfer dynamic linking
6896    information on function code symbol entries to their corresponding
6897    function descriptor symbol entries.  */
6898
6899 static bfd_boolean
6900 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6901 {
6902   struct bfd_link_info *info;
6903   struct ppc_link_hash_table *htab;
6904   struct plt_entry *ent;
6905   struct ppc_link_hash_entry *fh;
6906   struct ppc_link_hash_entry *fdh;
6907   bfd_boolean force_local;
6908
6909   fh = (struct ppc_link_hash_entry *) h;
6910   if (fh->elf.root.type == bfd_link_hash_indirect)
6911     return TRUE;
6912
6913   info = inf;
6914   htab = ppc_hash_table (info);
6915   if (htab == NULL)
6916     return FALSE;
6917
6918   /* Resolve undefined references to dot-symbols as the value
6919      in the function descriptor, if we have one in a regular object.
6920      This is to satisfy cases like ".quad .foo".  Calls to functions
6921      in dynamic objects are handled elsewhere.  */
6922   if (fh->elf.root.type == bfd_link_hash_undefweak
6923       && fh->was_undefined
6924       && (fdh = defined_func_desc (fh)) != NULL
6925       && get_opd_info (fdh->elf.root.u.def.section) != NULL
6926       && opd_entry_value (fdh->elf.root.u.def.section,
6927                           fdh->elf.root.u.def.value,
6928                           &fh->elf.root.u.def.section,
6929                           &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
6930     {
6931       fh->elf.root.type = fdh->elf.root.type;
6932       fh->elf.forced_local = 1;
6933       fh->elf.def_regular = fdh->elf.def_regular;
6934       fh->elf.def_dynamic = fdh->elf.def_dynamic;
6935     }
6936
6937   /* If this is a function code symbol, transfer dynamic linking
6938      information to the function descriptor symbol.  */
6939   if (!fh->is_func)
6940     return TRUE;
6941
6942   for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6943     if (ent->plt.refcount > 0)
6944       break;
6945   if (ent == NULL
6946       || fh->elf.root.root.string[0] != '.'
6947       || fh->elf.root.root.string[1] == '\0')
6948     return TRUE;
6949
6950   /* Find the corresponding function descriptor symbol.  Create it
6951      as undefined if necessary.  */
6952
6953   fdh = lookup_fdh (fh, htab);
6954   if (fdh == NULL
6955       && !bfd_link_executable (info)
6956       && (fh->elf.root.type == bfd_link_hash_undefined
6957           || fh->elf.root.type == bfd_link_hash_undefweak))
6958     {
6959       fdh = make_fdh (info, fh);
6960       if (fdh == NULL)
6961         return FALSE;
6962     }
6963
6964   /* Fake function descriptors are made undefweak.  If the function
6965      code symbol is strong undefined, make the fake sym the same.
6966      If the function code symbol is defined, then force the fake
6967      descriptor local;  We can't support overriding of symbols in a
6968      shared library on a fake descriptor.  */
6969
6970   if (fdh != NULL
6971       && fdh->fake
6972       && fdh->elf.root.type == bfd_link_hash_undefweak)
6973     {
6974       if (fh->elf.root.type == bfd_link_hash_undefined)
6975         {
6976           fdh->elf.root.type = bfd_link_hash_undefined;
6977           bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
6978         }
6979       else if (fh->elf.root.type == bfd_link_hash_defined
6980                || fh->elf.root.type == bfd_link_hash_defweak)
6981         {
6982           _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6983         }
6984     }
6985
6986   if (fdh != NULL
6987       && !fdh->elf.forced_local
6988       && (!bfd_link_executable (info)
6989           || fdh->elf.def_dynamic
6990           || fdh->elf.ref_dynamic
6991           || (fdh->elf.root.type == bfd_link_hash_undefweak
6992               && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
6993     {
6994       if (fdh->elf.dynindx == -1)
6995         if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
6996           return FALSE;
6997       fdh->elf.ref_regular |= fh->elf.ref_regular;
6998       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
6999       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
7000       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
7001       if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
7002         {
7003           move_plt_plist (fh, fdh);
7004           fdh->elf.needs_plt = 1;
7005         }
7006       fdh->is_func_descriptor = 1;
7007       fdh->oh = fh;
7008       fh->oh = fdh;
7009     }
7010
7011   /* Now that the info is on the function descriptor, clear the
7012      function code sym info.  Any function code syms for which we
7013      don't have a definition in a regular file, we force local.
7014      This prevents a shared library from exporting syms that have
7015      been imported from another library.  Function code syms that
7016      are really in the library we must leave global to prevent the
7017      linker dragging in a definition from a static library.  */
7018   force_local = (!fh->elf.def_regular
7019                  || fdh == NULL
7020                  || !fdh->elf.def_regular
7021                  || fdh->elf.forced_local);
7022   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7023
7024   return TRUE;
7025 }
7026
7027 static const struct sfpr_def_parms save_res_funcs[] =
7028   {
7029     { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
7030     { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
7031     { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
7032     { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
7033     { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
7034     { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
7035     { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
7036     { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
7037     { "._savef", 14, 31, savefpr, savefpr1_tail },
7038     { "._restf", 14, 31, restfpr, restfpr1_tail },
7039     { "_savevr_", 20, 31, savevr, savevr_tail },
7040     { "_restvr_", 20, 31, restvr, restvr_tail }
7041   };
7042
7043 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
7044    this hook to a) provide some gcc support functions, and b) transfer
7045    dynamic linking information gathered so far on function code symbol
7046    entries, to their corresponding function descriptor symbol entries.  */
7047
7048 static bfd_boolean
7049 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
7050                             struct bfd_link_info *info)
7051 {
7052   struct ppc_link_hash_table *htab;
7053   unsigned int i;
7054
7055   htab = ppc_hash_table (info);
7056   if (htab == NULL)
7057     return FALSE;
7058
7059   if (!bfd_link_relocatable (info)
7060       && htab->elf.hgot != NULL)
7061     {
7062       _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
7063       /* Make .TOC. defined so as to prevent it being made dynamic.
7064          The wrong value here is fixed later in ppc64_elf_set_toc.  */
7065       if (!htab->elf.hgot->def_regular
7066           || htab->elf.hgot->root.type != bfd_link_hash_defined)
7067         {
7068           htab->elf.hgot->root.type = bfd_link_hash_defined;
7069           htab->elf.hgot->root.u.def.value = 0;
7070           htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
7071           htab->elf.hgot->def_regular = 1;
7072           htab->elf.hgot->root.linker_def = 1;
7073         }
7074       htab->elf.hgot->type = STT_OBJECT;
7075       htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
7076                                | STV_HIDDEN);
7077     }
7078
7079   if (htab->sfpr == NULL)
7080     /* We don't have any relocs.  */
7081     return TRUE;
7082
7083   /* Provide any missing _save* and _rest* functions.  */
7084   htab->sfpr->size = 0;
7085   if (htab->params->save_restore_funcs)
7086     for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
7087       if (!sfpr_define (info, &save_res_funcs[i], NULL))
7088         return FALSE;
7089
7090   elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
7091
7092   if (htab->sfpr->size == 0)
7093     htab->sfpr->flags |= SEC_EXCLUDE;
7094
7095   return TRUE;
7096 }
7097
7098 /* Return true if we have dynamic relocs that apply to read-only sections.  */
7099
7100 static bfd_boolean
7101 readonly_dynrelocs (struct elf_link_hash_entry *h)
7102 {
7103   struct ppc_link_hash_entry *eh;
7104   struct elf_dyn_relocs *p;
7105
7106   eh = (struct ppc_link_hash_entry *) h;
7107   for (p = eh->dyn_relocs; p != NULL; p = p->next)
7108     {
7109       asection *s = p->sec->output_section;
7110
7111       if (s != NULL && (s->flags & SEC_READONLY) != 0)
7112         return TRUE;
7113     }
7114   return FALSE;
7115 }
7116
7117 /* Adjust a symbol defined by a dynamic object and referenced by a
7118    regular object.  The current definition is in some section of the
7119    dynamic object, but we're not including those sections.  We have to
7120    change the definition to something the rest of the link can
7121    understand.  */
7122
7123 static bfd_boolean
7124 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
7125                                  struct elf_link_hash_entry *h)
7126 {
7127   struct ppc_link_hash_table *htab;
7128   asection *s;
7129
7130   htab = ppc_hash_table (info);
7131   if (htab == NULL)
7132     return FALSE;
7133
7134   /* Deal with function syms.  */
7135   if (h->type == STT_FUNC
7136       || h->type == STT_GNU_IFUNC
7137       || h->needs_plt)
7138     {
7139       /* Clear procedure linkage table information for any symbol that
7140          won't need a .plt entry.  */
7141       struct plt_entry *ent;
7142       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
7143         if (ent->plt.refcount > 0)
7144           break;
7145       if (ent == NULL
7146           || (h->type != STT_GNU_IFUNC
7147               && (SYMBOL_CALLS_LOCAL (info, h)
7148                   || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
7149                       && h->root.type == bfd_link_hash_undefweak)))
7150           || ((struct ppc_link_hash_entry *) h)->save_res)
7151         {
7152           h->plt.plist = NULL;
7153           h->needs_plt = 0;
7154           h->pointer_equality_needed = 0;
7155         }
7156       else if (abiversion (info->output_bfd) == 2)
7157         {
7158           /* Taking a function's address in a read/write section
7159              doesn't require us to define the function symbol in the
7160              executable on a global entry stub.  A dynamic reloc can
7161              be used instead.  */
7162           if (h->pointer_equality_needed
7163               && h->type != STT_GNU_IFUNC
7164               && !readonly_dynrelocs (h))
7165             {
7166               h->pointer_equality_needed = 0;
7167               h->non_got_ref = 0;
7168             }
7169
7170           /* After adjust_dynamic_symbol, non_got_ref set in the
7171              non-shared case means that we have allocated space in
7172              .dynbss for the symbol and thus dyn_relocs for this
7173              symbol should be discarded.
7174              If we get here we know we are making a PLT entry for this
7175              symbol, and in an executable we'd normally resolve
7176              relocations against this symbol to the PLT entry.  Allow
7177              dynamic relocs if the reference is weak, and the dynamic
7178              relocs will not cause text relocation.  */
7179           else if (!h->ref_regular_nonweak
7180                    && h->non_got_ref
7181                    && h->type != STT_GNU_IFUNC
7182                    && !readonly_dynrelocs (h))
7183             h->non_got_ref = 0;
7184
7185           /* If making a plt entry, then we don't need copy relocs.  */
7186           return TRUE;
7187         }
7188     }
7189   else
7190     h->plt.plist = NULL;
7191
7192   /* If this is a weak symbol, and there is a real definition, the
7193      processor independent code will have arranged for us to see the
7194      real definition first, and we can just use the same value.  */
7195   if (h->u.weakdef != NULL)
7196     {
7197       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
7198                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
7199       h->root.u.def.section = h->u.weakdef->root.u.def.section;
7200       h->root.u.def.value = h->u.weakdef->root.u.def.value;
7201       if (ELIMINATE_COPY_RELOCS)
7202         h->non_got_ref = h->u.weakdef->non_got_ref;
7203       return TRUE;
7204     }
7205
7206   /* If we are creating a shared library, we must presume that the
7207      only references to the symbol are via the global offset table.
7208      For such cases we need not do anything here; the relocations will
7209      be handled correctly by relocate_section.  */
7210   if (bfd_link_pic (info))
7211     return TRUE;
7212
7213   /* If there are no references to this symbol that do not use the
7214      GOT, we don't need to generate a copy reloc.  */
7215   if (!h->non_got_ref)
7216     return TRUE;
7217
7218   /* Don't generate a copy reloc for symbols defined in the executable.  */
7219   if (!h->def_dynamic || !h->ref_regular || h->def_regular)
7220     return TRUE;
7221
7222   /* If -z nocopyreloc was given, don't generate them either.  */
7223   if (info->nocopyreloc)
7224     {
7225       h->non_got_ref = 0;
7226       return TRUE;
7227     }
7228
7229   /* If we didn't find any dynamic relocs in read-only sections, then
7230      we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
7231   if (ELIMINATE_COPY_RELOCS && !readonly_dynrelocs (h))
7232     {
7233       h->non_got_ref = 0;
7234       return TRUE;
7235     }
7236
7237   /* Protected variables do not work with .dynbss.  The copy in
7238      .dynbss won't be used by the shared library with the protected
7239      definition for the variable.  Text relocations are preferable
7240      to an incorrect program.  */
7241   if (h->protected_def)
7242     {
7243       h->non_got_ref = 0;
7244       return TRUE;
7245     }
7246
7247   if (h->plt.plist != NULL)
7248     {
7249       /* We should never get here, but unfortunately there are versions
7250          of gcc out there that improperly (for this ABI) put initialized
7251          function pointers, vtable refs and suchlike in read-only
7252          sections.  Allow them to proceed, but warn that this might
7253          break at runtime.  */
7254       info->callbacks->einfo
7255         (_("%P: copy reloc against `%T' requires lazy plt linking; "
7256            "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7257          h->root.root.string);
7258     }
7259
7260   /* This is a reference to a symbol defined by a dynamic object which
7261      is not a function.  */
7262
7263   /* We must allocate the symbol in our .dynbss section, which will
7264      become part of the .bss section of the executable.  There will be
7265      an entry for this symbol in the .dynsym section.  The dynamic
7266      object will contain position independent code, so all references
7267      from the dynamic object to this symbol will go through the global
7268      offset table.  The dynamic linker will use the .dynsym entry to
7269      determine the address it must put in the global offset table, so
7270      both the dynamic object and the regular object will refer to the
7271      same memory location for the variable.  */
7272
7273   /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
7274      to copy the initial value out of the dynamic object and into the
7275      runtime process image.  We need to remember the offset into the
7276      .rela.bss section we are going to use.  */
7277   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7278     {
7279       htab->relbss->size += sizeof (Elf64_External_Rela);
7280       h->needs_copy = 1;
7281     }
7282
7283   s = htab->dynbss;
7284
7285   return _bfd_elf_adjust_dynamic_copy (info, h, s);
7286 }
7287
7288 /* If given a function descriptor symbol, hide both the function code
7289    sym and the descriptor.  */
7290 static void
7291 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7292                        struct elf_link_hash_entry *h,
7293                        bfd_boolean force_local)
7294 {
7295   struct ppc_link_hash_entry *eh;
7296   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7297
7298   eh = (struct ppc_link_hash_entry *) h;
7299   if (eh->is_func_descriptor)
7300     {
7301       struct ppc_link_hash_entry *fh = eh->oh;
7302
7303       if (fh == NULL)
7304         {
7305           const char *p, *q;
7306           struct ppc_link_hash_table *htab;
7307           char save;
7308
7309           /* We aren't supposed to use alloca in BFD because on
7310              systems which do not have alloca the version in libiberty
7311              calls xmalloc, which might cause the program to crash
7312              when it runs out of memory.  This function doesn't have a
7313              return status, so there's no way to gracefully return an
7314              error.  So cheat.  We know that string[-1] can be safely
7315              accessed;  It's either a string in an ELF string table,
7316              or allocated in an objalloc structure.  */
7317
7318           p = eh->elf.root.root.string - 1;
7319           save = *p;
7320           *(char *) p = '.';
7321           htab = ppc_hash_table (info);
7322           if (htab == NULL)
7323             return;
7324
7325           fh = (struct ppc_link_hash_entry *)
7326             elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7327           *(char *) p = save;
7328
7329           /* Unfortunately, if it so happens that the string we were
7330              looking for was allocated immediately before this string,
7331              then we overwrote the string terminator.  That's the only
7332              reason the lookup should fail.  */
7333           if (fh == NULL)
7334             {
7335               q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7336               while (q >= eh->elf.root.root.string && *q == *p)
7337                 --q, --p;
7338               if (q < eh->elf.root.root.string && *p == '.')
7339                 fh = (struct ppc_link_hash_entry *)
7340                   elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7341             }
7342           if (fh != NULL)
7343             {
7344               eh->oh = fh;
7345               fh->oh = eh;
7346             }
7347         }
7348       if (fh != NULL)
7349         _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7350     }
7351 }
7352
7353 static bfd_boolean
7354 get_sym_h (struct elf_link_hash_entry **hp,
7355            Elf_Internal_Sym **symp,
7356            asection **symsecp,
7357            unsigned char **tls_maskp,
7358            Elf_Internal_Sym **locsymsp,
7359            unsigned long r_symndx,
7360            bfd *ibfd)
7361 {
7362   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7363
7364   if (r_symndx >= symtab_hdr->sh_info)
7365     {
7366       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7367       struct elf_link_hash_entry *h;
7368
7369       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7370       h = elf_follow_link (h);
7371
7372       if (hp != NULL)
7373         *hp = h;
7374
7375       if (symp != NULL)
7376         *symp = NULL;
7377
7378       if (symsecp != NULL)
7379         {
7380           asection *symsec = NULL;
7381           if (h->root.type == bfd_link_hash_defined
7382               || h->root.type == bfd_link_hash_defweak)
7383             symsec = h->root.u.def.section;
7384           *symsecp = symsec;
7385         }
7386
7387       if (tls_maskp != NULL)
7388         {
7389           struct ppc_link_hash_entry *eh;
7390
7391           eh = (struct ppc_link_hash_entry *) h;
7392           *tls_maskp = &eh->tls_mask;
7393         }
7394     }
7395   else
7396     {
7397       Elf_Internal_Sym *sym;
7398       Elf_Internal_Sym *locsyms = *locsymsp;
7399
7400       if (locsyms == NULL)
7401         {
7402           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7403           if (locsyms == NULL)
7404             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7405                                             symtab_hdr->sh_info,
7406                                             0, NULL, NULL, NULL);
7407           if (locsyms == NULL)
7408             return FALSE;
7409           *locsymsp = locsyms;
7410         }
7411       sym = locsyms + r_symndx;
7412
7413       if (hp != NULL)
7414         *hp = NULL;
7415
7416       if (symp != NULL)
7417         *symp = sym;
7418
7419       if (symsecp != NULL)
7420         *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7421
7422       if (tls_maskp != NULL)
7423         {
7424           struct got_entry **lgot_ents;
7425           unsigned char *tls_mask;
7426
7427           tls_mask = NULL;
7428           lgot_ents = elf_local_got_ents (ibfd);
7429           if (lgot_ents != NULL)
7430             {
7431               struct plt_entry **local_plt = (struct plt_entry **)
7432                 (lgot_ents + symtab_hdr->sh_info);
7433               unsigned char *lgot_masks = (unsigned char *)
7434                 (local_plt + symtab_hdr->sh_info);
7435               tls_mask = &lgot_masks[r_symndx];
7436             }
7437           *tls_maskp = tls_mask;
7438         }
7439     }
7440   return TRUE;
7441 }
7442
7443 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
7444    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7445    type suitable for optimization, and 1 otherwise.  */
7446
7447 static int
7448 get_tls_mask (unsigned char **tls_maskp,
7449               unsigned long *toc_symndx,
7450               bfd_vma *toc_addend,
7451               Elf_Internal_Sym **locsymsp,
7452               const Elf_Internal_Rela *rel,
7453               bfd *ibfd)
7454 {
7455   unsigned long r_symndx;
7456   int next_r;
7457   struct elf_link_hash_entry *h;
7458   Elf_Internal_Sym *sym;
7459   asection *sec;
7460   bfd_vma off;
7461
7462   r_symndx = ELF64_R_SYM (rel->r_info);
7463   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7464     return 0;
7465
7466   if ((*tls_maskp != NULL && **tls_maskp != 0)
7467       || sec == NULL
7468       || ppc64_elf_section_data (sec) == NULL
7469       || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7470     return 1;
7471
7472   /* Look inside a TOC section too.  */
7473   if (h != NULL)
7474     {
7475       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7476       off = h->root.u.def.value;
7477     }
7478   else
7479     off = sym->st_value;
7480   off += rel->r_addend;
7481   BFD_ASSERT (off % 8 == 0);
7482   r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7483   next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7484   if (toc_symndx != NULL)
7485     *toc_symndx = r_symndx;
7486   if (toc_addend != NULL)
7487     *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7488   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7489     return 0;
7490   if ((h == NULL || is_static_defined (h))
7491       && (next_r == -1 || next_r == -2))
7492     return 1 - next_r;
7493   return 1;
7494 }
7495
7496 /* Find (or create) an entry in the tocsave hash table.  */
7497
7498 static struct tocsave_entry *
7499 tocsave_find (struct ppc_link_hash_table *htab,
7500               enum insert_option insert,
7501               Elf_Internal_Sym **local_syms,
7502               const Elf_Internal_Rela *irela,
7503               bfd *ibfd)
7504 {
7505   unsigned long r_indx;
7506   struct elf_link_hash_entry *h;
7507   Elf_Internal_Sym *sym;
7508   struct tocsave_entry ent, *p;
7509   hashval_t hash;
7510   struct tocsave_entry **slot;
7511
7512   r_indx = ELF64_R_SYM (irela->r_info);
7513   if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7514     return NULL;
7515   if (ent.sec == NULL || ent.sec->output_section == NULL)
7516     {
7517       (*_bfd_error_handler)
7518         (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"));
7519       return NULL;
7520     }
7521
7522   if (h != NULL)
7523     ent.offset = h->root.u.def.value;
7524   else
7525     ent.offset = sym->st_value;
7526   ent.offset += irela->r_addend;
7527
7528   hash = tocsave_htab_hash (&ent);
7529   slot = ((struct tocsave_entry **)
7530           htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7531   if (slot == NULL)
7532     return NULL;
7533
7534   if (*slot == NULL)
7535     {
7536       p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7537       if (p == NULL)
7538         return NULL;
7539       *p = ent;
7540       *slot = p;
7541     }
7542   return *slot;
7543 }
7544
7545 /* Adjust all global syms defined in opd sections.  In gcc generated
7546    code for the old ABI, these will already have been done.  */
7547
7548 static bfd_boolean
7549 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7550 {
7551   struct ppc_link_hash_entry *eh;
7552   asection *sym_sec;
7553   struct _opd_sec_data *opd;
7554
7555   if (h->root.type == bfd_link_hash_indirect)
7556     return TRUE;
7557
7558   if (h->root.type != bfd_link_hash_defined
7559       && h->root.type != bfd_link_hash_defweak)
7560     return TRUE;
7561
7562   eh = (struct ppc_link_hash_entry *) h;
7563   if (eh->adjust_done)
7564     return TRUE;
7565
7566   sym_sec = eh->elf.root.u.def.section;
7567   opd = get_opd_info (sym_sec);
7568   if (opd != NULL && opd->adjust != NULL)
7569     {
7570       long adjust = opd->adjust[OPD_NDX (eh->elf.root.u.def.value)];
7571       if (adjust == -1)
7572         {
7573           /* This entry has been deleted.  */
7574           asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7575           if (dsec == NULL)
7576             {
7577               for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7578                 if (discarded_section (dsec))
7579                   {
7580                     ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7581                     break;
7582                   }
7583             }
7584           eh->elf.root.u.def.value = 0;
7585           eh->elf.root.u.def.section = dsec;
7586         }
7587       else
7588         eh->elf.root.u.def.value += adjust;
7589       eh->adjust_done = 1;
7590     }
7591   return TRUE;
7592 }
7593
7594 /* Handles decrementing dynamic reloc counts for the reloc specified by
7595    R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM
7596    have already been determined.  */
7597
7598 static bfd_boolean
7599 dec_dynrel_count (bfd_vma r_info,
7600                   asection *sec,
7601                   struct bfd_link_info *info,
7602                   Elf_Internal_Sym **local_syms,
7603                   struct elf_link_hash_entry *h,
7604                   Elf_Internal_Sym *sym)
7605 {
7606   enum elf_ppc64_reloc_type r_type;
7607   asection *sym_sec = NULL;
7608
7609   /* Can this reloc be dynamic?  This switch, and later tests here
7610      should be kept in sync with the code in check_relocs.  */
7611   r_type = ELF64_R_TYPE (r_info);
7612   switch (r_type)
7613     {
7614     default:
7615       return TRUE;
7616
7617     case R_PPC64_TPREL16:
7618     case R_PPC64_TPREL16_LO:
7619     case R_PPC64_TPREL16_HI:
7620     case R_PPC64_TPREL16_HA:
7621     case R_PPC64_TPREL16_DS:
7622     case R_PPC64_TPREL16_LO_DS:
7623     case R_PPC64_TPREL16_HIGH:
7624     case R_PPC64_TPREL16_HIGHA:
7625     case R_PPC64_TPREL16_HIGHER:
7626     case R_PPC64_TPREL16_HIGHERA:
7627     case R_PPC64_TPREL16_HIGHEST:
7628     case R_PPC64_TPREL16_HIGHESTA:
7629       if (!bfd_link_pic (info))
7630         return TRUE;
7631
7632     case R_PPC64_TPREL64:
7633     case R_PPC64_DTPMOD64:
7634     case R_PPC64_DTPREL64:
7635     case R_PPC64_ADDR64:
7636     case R_PPC64_REL30:
7637     case R_PPC64_REL32:
7638     case R_PPC64_REL64:
7639     case R_PPC64_ADDR14:
7640     case R_PPC64_ADDR14_BRNTAKEN:
7641     case R_PPC64_ADDR14_BRTAKEN:
7642     case R_PPC64_ADDR16:
7643     case R_PPC64_ADDR16_DS:
7644     case R_PPC64_ADDR16_HA:
7645     case R_PPC64_ADDR16_HI:
7646     case R_PPC64_ADDR16_HIGH:
7647     case R_PPC64_ADDR16_HIGHA:
7648     case R_PPC64_ADDR16_HIGHER:
7649     case R_PPC64_ADDR16_HIGHERA:
7650     case R_PPC64_ADDR16_HIGHEST:
7651     case R_PPC64_ADDR16_HIGHESTA:
7652     case R_PPC64_ADDR16_LO:
7653     case R_PPC64_ADDR16_LO_DS:
7654     case R_PPC64_ADDR24:
7655     case R_PPC64_ADDR32:
7656     case R_PPC64_UADDR16:
7657     case R_PPC64_UADDR32:
7658     case R_PPC64_UADDR64:
7659     case R_PPC64_TOC:
7660       break;
7661     }
7662
7663   if (local_syms != NULL)
7664     {
7665       unsigned long r_symndx;
7666       bfd *ibfd = sec->owner;
7667
7668       r_symndx = ELF64_R_SYM (r_info);
7669       if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7670         return FALSE;
7671     }
7672
7673   if ((bfd_link_pic (info)
7674        && (must_be_dyn_reloc (info, r_type)
7675            || (h != NULL
7676                && (!SYMBOLIC_BIND (info, h)
7677                    || h->root.type == bfd_link_hash_defweak
7678                    || !h->def_regular))))
7679       || (ELIMINATE_COPY_RELOCS
7680           && !bfd_link_pic (info)
7681           && h != NULL
7682           && (h->root.type == bfd_link_hash_defweak
7683               || !h->def_regular)))
7684     ;
7685   else
7686     return TRUE;
7687
7688   if (h != NULL)
7689     {
7690       struct elf_dyn_relocs *p;
7691       struct elf_dyn_relocs **pp;
7692       pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7693
7694       /* elf_gc_sweep may have already removed all dyn relocs associated
7695          with local syms for a given section.  Also, symbol flags are
7696          changed by elf_gc_sweep_symbol, confusing the test above.  Don't
7697          report a dynreloc miscount.  */
7698       if (*pp == NULL && info->gc_sections)
7699         return TRUE;
7700
7701       while ((p = *pp) != NULL)
7702         {
7703           if (p->sec == sec)
7704             {
7705               if (!must_be_dyn_reloc (info, r_type))
7706                 p->pc_count -= 1;
7707               p->count -= 1;
7708               if (p->count == 0)
7709                 *pp = p->next;
7710               return TRUE;
7711             }
7712           pp = &p->next;
7713         }
7714     }
7715   else
7716     {
7717       struct ppc_dyn_relocs *p;
7718       struct ppc_dyn_relocs **pp;
7719       void *vpp;
7720       bfd_boolean is_ifunc;
7721
7722       if (local_syms == NULL)
7723         sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7724       if (sym_sec == NULL)
7725         sym_sec = sec;
7726
7727       vpp = &elf_section_data (sym_sec)->local_dynrel;
7728       pp = (struct ppc_dyn_relocs **) vpp;
7729
7730       if (*pp == NULL && info->gc_sections)
7731         return TRUE;
7732
7733       is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7734       while ((p = *pp) != NULL)
7735         {
7736           if (p->sec == sec && p->ifunc == is_ifunc)
7737             {
7738               p->count -= 1;
7739               if (p->count == 0)
7740                 *pp = p->next;
7741               return TRUE;
7742             }
7743           pp = &p->next;
7744         }
7745     }
7746
7747   info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7748                           sec->owner, sec);
7749   bfd_set_error (bfd_error_bad_value);
7750   return FALSE;
7751 }
7752
7753 /* Remove unused Official Procedure Descriptor entries.  Currently we
7754    only remove those associated with functions in discarded link-once
7755    sections, or weakly defined functions that have been overridden.  It
7756    would be possible to remove many more entries for statically linked
7757    applications.  */
7758
7759 bfd_boolean
7760 ppc64_elf_edit_opd (struct bfd_link_info *info)
7761 {
7762   bfd *ibfd;
7763   bfd_boolean some_edited = FALSE;
7764   asection *need_pad = NULL;
7765   struct ppc_link_hash_table *htab;
7766
7767   htab = ppc_hash_table (info);
7768   if (htab == NULL)
7769     return FALSE;
7770
7771   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
7772     {
7773       asection *sec;
7774       Elf_Internal_Rela *relstart, *rel, *relend;
7775       Elf_Internal_Shdr *symtab_hdr;
7776       Elf_Internal_Sym *local_syms;
7777       struct _opd_sec_data *opd;
7778       bfd_boolean need_edit, add_aux_fields, broken;
7779       bfd_size_type cnt_16b = 0;
7780
7781       if (!is_ppc64_elf (ibfd))
7782         continue;
7783
7784       sec = bfd_get_section_by_name (ibfd, ".opd");
7785       if (sec == NULL || sec->size == 0)
7786         continue;
7787
7788       if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7789         continue;
7790
7791       if (sec->output_section == bfd_abs_section_ptr)
7792         continue;
7793
7794       /* Look through the section relocs.  */
7795       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7796         continue;
7797
7798       local_syms = NULL;
7799       symtab_hdr = &elf_symtab_hdr (ibfd);
7800
7801       /* Read the relocations.  */
7802       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7803                                             info->keep_memory);
7804       if (relstart == NULL)
7805         return FALSE;
7806
7807       /* First run through the relocs to check they are sane, and to
7808          determine whether we need to edit this opd section.  */
7809       need_edit = FALSE;
7810       broken = FALSE;
7811       need_pad = sec;
7812       relend = relstart + sec->reloc_count;
7813       for (rel = relstart; rel < relend; )
7814         {
7815           enum elf_ppc64_reloc_type r_type;
7816           unsigned long r_symndx;
7817           asection *sym_sec;
7818           struct elf_link_hash_entry *h;
7819           Elf_Internal_Sym *sym;
7820           bfd_vma offset;
7821
7822           /* .opd contains an array of 16 or 24 byte entries.  We're
7823              only interested in the reloc pointing to a function entry
7824              point.  */
7825           offset = rel->r_offset;
7826           if (rel + 1 == relend
7827               || rel[1].r_offset != offset + 8)
7828             {
7829               /* If someone messes with .opd alignment then after a
7830                  "ld -r" we might have padding in the middle of .opd.
7831                  Also, there's nothing to prevent someone putting
7832                  something silly in .opd with the assembler.  No .opd
7833                  optimization for them!  */
7834             broken_opd:
7835               (*_bfd_error_handler)
7836                 (_("%B: .opd is not a regular array of opd entries"), ibfd);
7837               broken = TRUE;
7838               break;
7839             }
7840
7841           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7842               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7843             {
7844               (*_bfd_error_handler)
7845                 (_("%B: unexpected reloc type %u in .opd section"),
7846                  ibfd, r_type);
7847               broken = TRUE;
7848               break;
7849             }
7850
7851           r_symndx = ELF64_R_SYM (rel->r_info);
7852           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7853                           r_symndx, ibfd))
7854             goto error_ret;
7855
7856           if (sym_sec == NULL || sym_sec->owner == NULL)
7857             {
7858               const char *sym_name;
7859               if (h != NULL)
7860                 sym_name = h->root.root.string;
7861               else
7862                 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7863                                              sym_sec);
7864
7865               (*_bfd_error_handler)
7866                 (_("%B: undefined sym `%s' in .opd section"),
7867                  ibfd, sym_name);
7868               broken = TRUE;
7869               break;
7870             }
7871
7872           /* opd entries are always for functions defined in the
7873              current input bfd.  If the symbol isn't defined in the
7874              input bfd, then we won't be using the function in this
7875              bfd;  It must be defined in a linkonce section in another
7876              bfd, or is weak.  It's also possible that we are
7877              discarding the function due to a linker script /DISCARD/,
7878              which we test for via the output_section.  */
7879           if (sym_sec->owner != ibfd
7880               || sym_sec->output_section == bfd_abs_section_ptr)
7881             need_edit = TRUE;
7882
7883           rel += 2;
7884           if (rel + 1 == relend
7885               || (rel + 2 < relend
7886                   && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC))
7887             ++rel;
7888
7889           if (rel == relend)
7890             {
7891               if (sec->size == offset + 24)
7892                 {
7893                   need_pad = NULL;
7894                   break;
7895                 }
7896               if (sec->size == offset + 16)
7897                 {
7898                   cnt_16b++;
7899                   break;
7900                 }
7901               goto broken_opd;
7902             }
7903           else if (rel + 1 < relend
7904                    && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7905                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7906             {
7907               if (rel[0].r_offset == offset + 16)
7908                 cnt_16b++;
7909               else if (rel[0].r_offset != offset + 24)
7910                 goto broken_opd;
7911             }
7912           else
7913             goto broken_opd;
7914         }
7915
7916       add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
7917
7918       if (!broken && (need_edit || add_aux_fields))
7919         {
7920           Elf_Internal_Rela *write_rel;
7921           Elf_Internal_Shdr *rel_hdr;
7922           bfd_byte *rptr, *wptr;
7923           bfd_byte *new_contents;
7924           bfd_size_type amt;
7925
7926           new_contents = NULL;
7927           amt = OPD_NDX (sec->size) * sizeof (long);
7928           opd = &ppc64_elf_section_data (sec)->u.opd;
7929           opd->adjust = bfd_zalloc (sec->owner, amt);
7930           if (opd->adjust == NULL)
7931             return FALSE;
7932           ppc64_elf_section_data (sec)->sec_type = sec_opd;
7933
7934           /* This seems a waste of time as input .opd sections are all
7935              zeros as generated by gcc, but I suppose there's no reason
7936              this will always be so.  We might start putting something in
7937              the third word of .opd entries.  */
7938           if ((sec->flags & SEC_IN_MEMORY) == 0)
7939             {
7940               bfd_byte *loc;
7941               if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7942                 {
7943                   if (loc != NULL)
7944                     free (loc);
7945                 error_ret:
7946                   if (local_syms != NULL
7947                       && symtab_hdr->contents != (unsigned char *) local_syms)
7948                     free (local_syms);
7949                   if (elf_section_data (sec)->relocs != relstart)
7950                     free (relstart);
7951                   return FALSE;
7952                 }
7953               sec->contents = loc;
7954               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7955             }
7956
7957           elf_section_data (sec)->relocs = relstart;
7958
7959           new_contents = sec->contents;
7960           if (add_aux_fields)
7961             {
7962               new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7963               if (new_contents == NULL)
7964                 return FALSE;
7965               need_pad = NULL;
7966             }
7967           wptr = new_contents;
7968           rptr = sec->contents;
7969           write_rel = relstart;
7970           for (rel = relstart; rel < relend; )
7971             {
7972               unsigned long r_symndx;
7973               asection *sym_sec;
7974               struct elf_link_hash_entry *h;
7975               struct ppc_link_hash_entry *fdh = NULL;
7976               Elf_Internal_Sym *sym;
7977               long opd_ent_size;
7978               Elf_Internal_Rela *next_rel;
7979               bfd_boolean skip;
7980
7981               r_symndx = ELF64_R_SYM (rel->r_info);
7982               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7983                               r_symndx, ibfd))
7984                 goto error_ret;
7985
7986               next_rel = rel + 2;
7987               if (next_rel + 1 == relend
7988                   || (next_rel + 2 < relend
7989                       && ELF64_R_TYPE (next_rel[2].r_info) == R_PPC64_TOC))
7990                 ++next_rel;
7991
7992               /* See if the .opd entry is full 24 byte or
7993                  16 byte (with fd_aux entry overlapped with next
7994                  fd_func).  */
7995               opd_ent_size = 24;
7996               if (next_rel == relend)
7997                 {
7998                   if (sec->size == rel->r_offset + 16)
7999                     opd_ent_size = 16;
8000                 }
8001               else if (next_rel->r_offset == rel->r_offset + 16)
8002                 opd_ent_size = 16;
8003
8004               if (h != NULL
8005                   && h->root.root.string[0] == '.')
8006                 {
8007                   fdh = lookup_fdh ((struct ppc_link_hash_entry *) h, htab);
8008                   if (fdh != NULL
8009                       && fdh->elf.root.type != bfd_link_hash_defined
8010                       && fdh->elf.root.type != bfd_link_hash_defweak)
8011                     fdh = NULL;
8012                 }
8013
8014               skip = (sym_sec->owner != ibfd
8015                       || sym_sec->output_section == bfd_abs_section_ptr);
8016               if (skip)
8017                 {
8018                   if (fdh != NULL && sym_sec->owner == ibfd)
8019                     {
8020                       /* Arrange for the function descriptor sym
8021                          to be dropped.  */
8022                       fdh->elf.root.u.def.value = 0;
8023                       fdh->elf.root.u.def.section = sym_sec;
8024                     }
8025                   opd->adjust[OPD_NDX (rel->r_offset)] = -1;
8026
8027                   if (NO_OPD_RELOCS || bfd_link_relocatable (info))
8028                     rel = next_rel;
8029                   else
8030                     while (1)
8031                       {
8032                         if (!dec_dynrel_count (rel->r_info, sec, info,
8033                                                NULL, h, sym))
8034                           goto error_ret;
8035
8036                         if (++rel == next_rel)
8037                           break;
8038
8039                         r_symndx = ELF64_R_SYM (rel->r_info);
8040                         if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8041                                         r_symndx, ibfd))
8042                           goto error_ret;
8043                       }
8044                 }
8045               else
8046                 {
8047                   /* We'll be keeping this opd entry.  */
8048                   long adjust;
8049
8050                   if (fdh != NULL)
8051                     {
8052                       /* Redefine the function descriptor symbol to
8053                          this location in the opd section.  It is
8054                          necessary to update the value here rather
8055                          than using an array of adjustments as we do
8056                          for local symbols, because various places
8057                          in the generic ELF code use the value
8058                          stored in u.def.value.  */
8059                       fdh->elf.root.u.def.value = wptr - new_contents;
8060                       fdh->adjust_done = 1;
8061                     }
8062
8063                   /* Local syms are a bit tricky.  We could
8064                      tweak them as they can be cached, but
8065                      we'd need to look through the local syms
8066                      for the function descriptor sym which we
8067                      don't have at the moment.  So keep an
8068                      array of adjustments.  */
8069                   adjust = (wptr - new_contents) - (rptr - sec->contents);
8070                   opd->adjust[OPD_NDX (rel->r_offset)] = adjust;
8071
8072                   if (wptr != rptr)
8073                     memcpy (wptr, rptr, opd_ent_size);
8074                   wptr += opd_ent_size;
8075                   if (add_aux_fields && opd_ent_size == 16)
8076                     {
8077                       memset (wptr, '\0', 8);
8078                       wptr += 8;
8079                     }
8080
8081                   /* We need to adjust any reloc offsets to point to the
8082                      new opd entries.  */
8083                   for ( ; rel != next_rel; ++rel)
8084                     {
8085                       rel->r_offset += adjust;
8086                       if (write_rel != rel)
8087                         memcpy (write_rel, rel, sizeof (*rel));
8088                       ++write_rel;
8089                     }
8090                 }
8091
8092               rptr += opd_ent_size;
8093             }
8094
8095           sec->size = wptr - new_contents;
8096           sec->reloc_count = write_rel - relstart;
8097           if (add_aux_fields)
8098             {
8099               free (sec->contents);
8100               sec->contents = new_contents;
8101             }
8102
8103           /* Fudge the header size too, as this is used later in
8104              elf_bfd_final_link if we are emitting relocs.  */
8105           rel_hdr = _bfd_elf_single_rel_hdr (sec);
8106           rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
8107           some_edited = TRUE;
8108         }
8109       else if (elf_section_data (sec)->relocs != relstart)
8110         free (relstart);
8111
8112       if (local_syms != NULL
8113           && symtab_hdr->contents != (unsigned char *) local_syms)
8114         {
8115           if (!info->keep_memory)
8116             free (local_syms);
8117           else
8118             symtab_hdr->contents = (unsigned char *) local_syms;
8119         }
8120     }
8121
8122   if (some_edited)
8123     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
8124
8125   /* If we are doing a final link and the last .opd entry is just 16 byte
8126      long, add a 8 byte padding after it.  */
8127   if (need_pad != NULL && !bfd_link_relocatable (info))
8128     {
8129       bfd_byte *p;
8130
8131       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
8132         {
8133           BFD_ASSERT (need_pad->size > 0);
8134
8135           p = bfd_malloc (need_pad->size + 8);
8136           if (p == NULL)
8137             return FALSE;
8138
8139           if (! bfd_get_section_contents (need_pad->owner, need_pad,
8140                                           p, 0, need_pad->size))
8141             return FALSE;
8142
8143           need_pad->contents = p;
8144           need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8145         }
8146       else
8147         {
8148           p = bfd_realloc (need_pad->contents, need_pad->size + 8);
8149           if (p == NULL)
8150             return FALSE;
8151
8152           need_pad->contents = p;
8153         }
8154
8155       memset (need_pad->contents + need_pad->size, 0, 8);
8156       need_pad->size += 8;
8157     }
8158
8159   return TRUE;
8160 }
8161
8162 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
8163
8164 asection *
8165 ppc64_elf_tls_setup (struct bfd_link_info *info)
8166 {
8167   struct ppc_link_hash_table *htab;
8168
8169   htab = ppc_hash_table (info);
8170   if (htab == NULL)
8171     return NULL;
8172
8173   if (abiversion (info->output_bfd) == 1)
8174     htab->opd_abi = 1;
8175
8176   if (htab->params->no_multi_toc)
8177     htab->do_multi_toc = 0;
8178   else if (!htab->do_multi_toc)
8179     htab->params->no_multi_toc = 1;
8180
8181   htab->tls_get_addr = ((struct ppc_link_hash_entry *)
8182                         elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
8183                                               FALSE, FALSE, TRUE));
8184   /* Move dynamic linking info to the function descriptor sym.  */
8185   if (htab->tls_get_addr != NULL)
8186     func_desc_adjust (&htab->tls_get_addr->elf, info);
8187   htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
8188                            elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
8189                                                  FALSE, FALSE, TRUE));
8190   if (htab->params->tls_get_addr_opt)
8191     {
8192       struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
8193
8194       opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
8195                                   FALSE, FALSE, TRUE);
8196       if (opt != NULL)
8197         func_desc_adjust (opt, info);
8198       opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
8199                                      FALSE, FALSE, TRUE);
8200       if (opt_fd != NULL
8201           && (opt_fd->root.type == bfd_link_hash_defined
8202               || opt_fd->root.type == bfd_link_hash_defweak))
8203         {
8204           /* If glibc supports an optimized __tls_get_addr call stub,
8205              signalled by the presence of __tls_get_addr_opt, and we'll
8206              be calling __tls_get_addr via a plt call stub, then
8207              make __tls_get_addr point to __tls_get_addr_opt.  */
8208           tga_fd = &htab->tls_get_addr_fd->elf;
8209           if (htab->elf.dynamic_sections_created
8210               && tga_fd != NULL
8211               && (tga_fd->type == STT_FUNC
8212                   || tga_fd->needs_plt)
8213               && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
8214                    || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
8215                        && tga_fd->root.type == bfd_link_hash_undefweak)))
8216             {
8217               struct plt_entry *ent;
8218
8219               for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
8220                 if (ent->plt.refcount > 0)
8221                   break;
8222               if (ent != NULL)
8223                 {
8224                   tga_fd->root.type = bfd_link_hash_indirect;
8225                   tga_fd->root.u.i.link = &opt_fd->root;
8226                   ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
8227                   if (opt_fd->dynindx != -1)
8228                     {
8229                       /* Use __tls_get_addr_opt in dynamic relocations.  */
8230                       opt_fd->dynindx = -1;
8231                       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8232                                               opt_fd->dynstr_index);
8233                       if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8234                         return NULL;
8235                     }
8236                   htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8237                   tga = &htab->tls_get_addr->elf;
8238                   if (opt != NULL && tga != NULL)
8239                     {
8240                       tga->root.type = bfd_link_hash_indirect;
8241                       tga->root.u.i.link = &opt->root;
8242                       ppc64_elf_copy_indirect_symbol (info, opt, tga);
8243                       _bfd_elf_link_hash_hide_symbol (info, opt,
8244                                                       tga->forced_local);
8245                       htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8246                     }
8247                   htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8248                   htab->tls_get_addr_fd->is_func_descriptor = 1;
8249                   if (htab->tls_get_addr != NULL)
8250                     {
8251                       htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8252                       htab->tls_get_addr->is_func = 1;
8253                     }
8254                 }
8255             }
8256         }
8257       else if (htab->params->tls_get_addr_opt < 0)
8258         htab->params->tls_get_addr_opt = 0;
8259     }
8260   return _bfd_elf_tls_setup (info->output_bfd, info);
8261 }
8262
8263 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8264    HASH1 or HASH2.  */
8265
8266 static bfd_boolean
8267 branch_reloc_hash_match (const bfd *ibfd,
8268                          const Elf_Internal_Rela *rel,
8269                          const struct ppc_link_hash_entry *hash1,
8270                          const struct ppc_link_hash_entry *hash2)
8271 {
8272   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8273   enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8274   unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8275
8276   if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8277     {
8278       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8279       struct elf_link_hash_entry *h;
8280
8281       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8282       h = elf_follow_link (h);
8283       if (h == &hash1->elf || h == &hash2->elf)
8284         return TRUE;
8285     }
8286   return FALSE;
8287 }
8288
8289 /* Run through all the TLS relocs looking for optimization
8290    opportunities.  The linker has been hacked (see ppc64elf.em) to do
8291    a preliminary section layout so that we know the TLS segment
8292    offsets.  We can't optimize earlier because some optimizations need
8293    to know the tp offset, and we need to optimize before allocating
8294    dynamic relocations.  */
8295
8296 bfd_boolean
8297 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8298 {
8299   bfd *ibfd;
8300   asection *sec;
8301   struct ppc_link_hash_table *htab;
8302   unsigned char *toc_ref;
8303   int pass;
8304
8305   if (!bfd_link_executable (info))
8306     return TRUE;
8307
8308   htab = ppc_hash_table (info);
8309   if (htab == NULL)
8310     return FALSE;
8311
8312   /* Make two passes over the relocs.  On the first pass, mark toc
8313      entries involved with tls relocs, and check that tls relocs
8314      involved in setting up a tls_get_addr call are indeed followed by
8315      such a call.  If they are not, we can't do any tls optimization.
8316      On the second pass twiddle tls_mask flags to notify
8317      relocate_section that optimization can be done, and adjust got
8318      and plt refcounts.  */
8319   toc_ref = NULL;
8320   for (pass = 0; pass < 2; ++pass)
8321     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8322       {
8323         Elf_Internal_Sym *locsyms = NULL;
8324         asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8325
8326         for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8327           if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8328             {
8329               Elf_Internal_Rela *relstart, *rel, *relend;
8330               bfd_boolean found_tls_get_addr_arg = 0;
8331
8332               /* Read the relocations.  */
8333               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8334                                                     info->keep_memory);
8335               if (relstart == NULL)
8336                 {
8337                   free (toc_ref);
8338                   return FALSE;
8339                 }
8340
8341               relend = relstart + sec->reloc_count;
8342               for (rel = relstart; rel < relend; rel++)
8343                 {
8344                   enum elf_ppc64_reloc_type r_type;
8345                   unsigned long r_symndx;
8346                   struct elf_link_hash_entry *h;
8347                   Elf_Internal_Sym *sym;
8348                   asection *sym_sec;
8349                   unsigned char *tls_mask;
8350                   unsigned char tls_set, tls_clear, tls_type = 0;
8351                   bfd_vma value;
8352                   bfd_boolean ok_tprel, is_local;
8353                   long toc_ref_index = 0;
8354                   int expecting_tls_get_addr = 0;
8355                   bfd_boolean ret = FALSE;
8356
8357                   r_symndx = ELF64_R_SYM (rel->r_info);
8358                   if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8359                                   r_symndx, ibfd))
8360                     {
8361                     err_free_rel:
8362                       if (elf_section_data (sec)->relocs != relstart)
8363                         free (relstart);
8364                       if (toc_ref != NULL)
8365                         free (toc_ref);
8366                       if (locsyms != NULL
8367                           && (elf_symtab_hdr (ibfd).contents
8368                               != (unsigned char *) locsyms))
8369                         free (locsyms);
8370                       return ret;
8371                     }
8372
8373                   if (h != NULL)
8374                     {
8375                       if (h->root.type == bfd_link_hash_defined
8376                           || h->root.type == bfd_link_hash_defweak)
8377                         value = h->root.u.def.value;
8378                       else if (h->root.type == bfd_link_hash_undefweak)
8379                         value = 0;
8380                       else
8381                         {
8382                           found_tls_get_addr_arg = 0;
8383                           continue;
8384                         }
8385                     }
8386                   else
8387                     /* Symbols referenced by TLS relocs must be of type
8388                        STT_TLS.  So no need for .opd local sym adjust.  */
8389                     value = sym->st_value;
8390
8391                   ok_tprel = FALSE;
8392                   is_local = FALSE;
8393                   if (h == NULL
8394                       || !h->def_dynamic)
8395                     {
8396                       is_local = TRUE;
8397                       if (h != NULL
8398                           && h->root.type == bfd_link_hash_undefweak)
8399                         ok_tprel = TRUE;
8400                       else if (sym_sec != NULL
8401                                && sym_sec->output_section != NULL)
8402                         {
8403                           value += sym_sec->output_offset;
8404                           value += sym_sec->output_section->vma;
8405                           value -= htab->elf.tls_sec->vma;
8406                           ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8407                                       < (bfd_vma) 1 << 32);
8408                         }
8409                     }
8410
8411                   r_type = ELF64_R_TYPE (rel->r_info);
8412                   /* If this section has old-style __tls_get_addr calls
8413                      without marker relocs, then check that each
8414                      __tls_get_addr call reloc is preceded by a reloc
8415                      that conceivably belongs to the __tls_get_addr arg
8416                      setup insn.  If we don't find matching arg setup
8417                      relocs, don't do any tls optimization.  */
8418                   if (pass == 0
8419                       && sec->has_tls_get_addr_call
8420                       && h != NULL
8421                       && (h == &htab->tls_get_addr->elf
8422                           || h == &htab->tls_get_addr_fd->elf)
8423                       && !found_tls_get_addr_arg
8424                       && is_branch_reloc (r_type))
8425                     {
8426                       info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8427                                                 "TLS optimization disabled\n"),
8428                                               ibfd, sec, rel->r_offset);
8429                       ret = TRUE;
8430                       goto err_free_rel;
8431                     }
8432
8433                   found_tls_get_addr_arg = 0;
8434                   switch (r_type)
8435                     {
8436                     case R_PPC64_GOT_TLSLD16:
8437                     case R_PPC64_GOT_TLSLD16_LO:
8438                       expecting_tls_get_addr = 1;
8439                       found_tls_get_addr_arg = 1;
8440                       /* Fall thru */
8441
8442                     case R_PPC64_GOT_TLSLD16_HI:
8443                     case R_PPC64_GOT_TLSLD16_HA:
8444                       /* These relocs should never be against a symbol
8445                          defined in a shared lib.  Leave them alone if
8446                          that turns out to be the case.  */
8447                       if (!is_local)
8448                         continue;
8449
8450                       /* LD -> LE */
8451                       tls_set = 0;
8452                       tls_clear = TLS_LD;
8453                       tls_type = TLS_TLS | TLS_LD;
8454                       break;
8455
8456                     case R_PPC64_GOT_TLSGD16:
8457                     case R_PPC64_GOT_TLSGD16_LO:
8458                       expecting_tls_get_addr = 1;
8459                       found_tls_get_addr_arg = 1;
8460                       /* Fall thru */
8461
8462                     case R_PPC64_GOT_TLSGD16_HI:
8463                     case R_PPC64_GOT_TLSGD16_HA:
8464                       if (ok_tprel)
8465                         /* GD -> LE */
8466                         tls_set = 0;
8467                       else
8468                         /* GD -> IE */
8469                         tls_set = TLS_TLS | TLS_TPRELGD;
8470                       tls_clear = TLS_GD;
8471                       tls_type = TLS_TLS | TLS_GD;
8472                       break;
8473
8474                     case R_PPC64_GOT_TPREL16_DS:
8475                     case R_PPC64_GOT_TPREL16_LO_DS:
8476                     case R_PPC64_GOT_TPREL16_HI:
8477                     case R_PPC64_GOT_TPREL16_HA:
8478                       if (ok_tprel)
8479                         {
8480                           /* IE -> LE */
8481                           tls_set = 0;
8482                           tls_clear = TLS_TPREL;
8483                           tls_type = TLS_TLS | TLS_TPREL;
8484                           break;
8485                         }
8486                       continue;
8487
8488                     case R_PPC64_TLSGD:
8489                     case R_PPC64_TLSLD:
8490                       found_tls_get_addr_arg = 1;
8491                       /* Fall thru */
8492
8493                     case R_PPC64_TLS:
8494                     case R_PPC64_TOC16:
8495                     case R_PPC64_TOC16_LO:
8496                       if (sym_sec == NULL || sym_sec != toc)
8497                         continue;
8498
8499                       /* Mark this toc entry as referenced by a TLS
8500                          code sequence.  We can do that now in the
8501                          case of R_PPC64_TLS, and after checking for
8502                          tls_get_addr for the TOC16 relocs.  */
8503                       if (toc_ref == NULL)
8504                         toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8505                       if (toc_ref == NULL)
8506                         goto err_free_rel;
8507
8508                       if (h != NULL)
8509                         value = h->root.u.def.value;
8510                       else
8511                         value = sym->st_value;
8512                       value += rel->r_addend;
8513                       if (value % 8 != 0)
8514                         continue;
8515                       BFD_ASSERT (value < toc->size
8516                                   && toc->output_offset % 8 == 0);
8517                       toc_ref_index = (value + toc->output_offset) / 8;
8518                       if (r_type == R_PPC64_TLS
8519                           || r_type == R_PPC64_TLSGD
8520                           || r_type == R_PPC64_TLSLD)
8521                         {
8522                           toc_ref[toc_ref_index] = 1;
8523                           continue;
8524                         }
8525
8526                       if (pass != 0 && toc_ref[toc_ref_index] == 0)
8527                         continue;
8528
8529                       tls_set = 0;
8530                       tls_clear = 0;
8531                       expecting_tls_get_addr = 2;
8532                       break;
8533
8534                     case R_PPC64_TPREL64:
8535                       if (pass == 0
8536                           || sec != toc
8537                           || toc_ref == NULL
8538                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8539                         continue;
8540                       if (ok_tprel)
8541                         {
8542                           /* IE -> LE */
8543                           tls_set = TLS_EXPLICIT;
8544                           tls_clear = TLS_TPREL;
8545                           break;
8546                         }
8547                       continue;
8548
8549                     case R_PPC64_DTPMOD64:
8550                       if (pass == 0
8551                           || sec != toc
8552                           || toc_ref == NULL
8553                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8554                         continue;
8555                       if (rel + 1 < relend
8556                           && (rel[1].r_info
8557                               == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8558                           && rel[1].r_offset == rel->r_offset + 8)
8559                         {
8560                           if (ok_tprel)
8561                             /* GD -> LE */
8562                             tls_set = TLS_EXPLICIT | TLS_GD;
8563                           else
8564                             /* GD -> IE */
8565                             tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8566                           tls_clear = TLS_GD;
8567                         }
8568                       else
8569                         {
8570                           if (!is_local)
8571                             continue;
8572
8573                           /* LD -> LE */
8574                           tls_set = TLS_EXPLICIT;
8575                           tls_clear = TLS_LD;
8576                         }
8577                       break;
8578
8579                     default:
8580                       continue;
8581                     }
8582
8583                   if (pass == 0)
8584                     {
8585                       if (!expecting_tls_get_addr
8586                           || !sec->has_tls_get_addr_call)
8587                         continue;
8588
8589                       if (rel + 1 < relend
8590                           && branch_reloc_hash_match (ibfd, rel + 1,
8591                                                       htab->tls_get_addr,
8592                                                       htab->tls_get_addr_fd))
8593                         {
8594                           if (expecting_tls_get_addr == 2)
8595                             {
8596                               /* Check for toc tls entries.  */
8597                               unsigned char *toc_tls;
8598                               int retval;
8599
8600                               retval = get_tls_mask (&toc_tls, NULL, NULL,
8601                                                      &locsyms,
8602                                                      rel, ibfd);
8603                               if (retval == 0)
8604                                 goto err_free_rel;
8605                               if (toc_tls != NULL)
8606                                 {
8607                                   if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8608                                     found_tls_get_addr_arg = 1;
8609                                   if (retval > 1)
8610                                     toc_ref[toc_ref_index] = 1;
8611                                 }
8612                             }
8613                           continue;
8614                         }
8615
8616                       if (expecting_tls_get_addr != 1)
8617                         continue;
8618
8619                       /* Uh oh, we didn't find the expected call.  We
8620                          could just mark this symbol to exclude it
8621                          from tls optimization but it's safer to skip
8622                          the entire optimization.  */
8623                       info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8624                                                 "TLS optimization disabled\n"),
8625                                               ibfd, sec, rel->r_offset);
8626                       ret = TRUE;
8627                       goto err_free_rel;
8628                     }
8629
8630                   if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8631                     {
8632                       struct plt_entry *ent;
8633                       for (ent = htab->tls_get_addr->elf.plt.plist;
8634                            ent != NULL;
8635                            ent = ent->next)
8636                         if (ent->addend == 0)
8637                           {
8638                             if (ent->plt.refcount > 0)
8639                               {
8640                                 ent->plt.refcount -= 1;
8641                                 expecting_tls_get_addr = 0;
8642                               }
8643                             break;
8644                           }
8645                     }
8646
8647                   if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8648                     {
8649                       struct plt_entry *ent;
8650                       for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8651                            ent != NULL;
8652                            ent = ent->next)
8653                         if (ent->addend == 0)
8654                           {
8655                             if (ent->plt.refcount > 0)
8656                               ent->plt.refcount -= 1;
8657                             break;
8658                           }
8659                     }
8660
8661                   if (tls_clear == 0)
8662                     continue;
8663
8664                   if ((tls_set & TLS_EXPLICIT) == 0)
8665                     {
8666                       struct got_entry *ent;
8667
8668                       /* Adjust got entry for this reloc.  */
8669                       if (h != NULL)
8670                         ent = h->got.glist;
8671                       else
8672                         ent = elf_local_got_ents (ibfd)[r_symndx];
8673
8674                       for (; ent != NULL; ent = ent->next)
8675                         if (ent->addend == rel->r_addend
8676                             && ent->owner == ibfd
8677                             && ent->tls_type == tls_type)
8678                           break;
8679                       if (ent == NULL)
8680                         abort ();
8681
8682                       if (tls_set == 0)
8683                         {
8684                           /* We managed to get rid of a got entry.  */
8685                           if (ent->got.refcount > 0)
8686                             ent->got.refcount -= 1;
8687                         }
8688                     }
8689                   else
8690                     {
8691                       /* If we got rid of a DTPMOD/DTPREL reloc pair then
8692                          we'll lose one or two dyn relocs.  */
8693                       if (!dec_dynrel_count (rel->r_info, sec, info,
8694                                              NULL, h, sym))
8695                         return FALSE;
8696
8697                       if (tls_set == (TLS_EXPLICIT | TLS_GD))
8698                         {
8699                           if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8700                                                  NULL, h, sym))
8701                             return FALSE;
8702                         }
8703                     }
8704
8705                   *tls_mask |= tls_set;
8706                   *tls_mask &= ~tls_clear;
8707                 }
8708
8709               if (elf_section_data (sec)->relocs != relstart)
8710                 free (relstart);
8711             }
8712
8713         if (locsyms != NULL
8714             && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8715           {
8716             if (!info->keep_memory)
8717               free (locsyms);
8718             else
8719               elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8720           }
8721       }
8722
8723   if (toc_ref != NULL)
8724     free (toc_ref);
8725   return TRUE;
8726 }
8727
8728 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8729    the values of any global symbols in a toc section that has been
8730    edited.  Globals in toc sections should be a rarity, so this function
8731    sets a flag if any are found in toc sections other than the one just
8732    edited, so that futher hash table traversals can be avoided.  */
8733
8734 struct adjust_toc_info
8735 {
8736   asection *toc;
8737   unsigned long *skip;
8738   bfd_boolean global_toc_syms;
8739 };
8740
8741 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8742
8743 static bfd_boolean
8744 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8745 {
8746   struct ppc_link_hash_entry *eh;
8747   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8748   unsigned long i;
8749
8750   if (h->root.type != bfd_link_hash_defined
8751       && h->root.type != bfd_link_hash_defweak)
8752     return TRUE;
8753
8754   eh = (struct ppc_link_hash_entry *) h;
8755   if (eh->adjust_done)
8756     return TRUE;
8757
8758   if (eh->elf.root.u.def.section == toc_inf->toc)
8759     {
8760       if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8761         i = toc_inf->toc->rawsize >> 3;
8762       else
8763         i = eh->elf.root.u.def.value >> 3;
8764
8765       if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8766         {
8767           (*_bfd_error_handler)
8768             (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8769           do
8770             ++i;
8771           while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8772           eh->elf.root.u.def.value = (bfd_vma) i << 3;
8773         }
8774
8775       eh->elf.root.u.def.value -= toc_inf->skip[i];
8776       eh->adjust_done = 1;
8777     }
8778   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8779     toc_inf->global_toc_syms = TRUE;
8780
8781   return TRUE;
8782 }
8783
8784 /* Return TRUE iff INSN is one we expect on a _LO variety toc/got reloc.  */
8785
8786 static bfd_boolean
8787 ok_lo_toc_insn (unsigned int insn)
8788 {
8789   return ((insn & (0x3f << 26)) == 14u << 26 /* addi */
8790           || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8791           || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8792           || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8793           || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8794           || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8795           || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8796           || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8797           || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8798           || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8799           || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8800           || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8801           || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8802           || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8803           || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
8804               && (insn & 3) != 1)
8805           || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
8806               && ((insn & 3) == 0 || (insn & 3) == 3))
8807           || (insn & (0x3f << 26)) == 12u << 26 /* addic */);
8808 }
8809
8810 /* Examine all relocs referencing .toc sections in order to remove
8811    unused .toc entries.  */
8812
8813 bfd_boolean
8814 ppc64_elf_edit_toc (struct bfd_link_info *info)
8815 {
8816   bfd *ibfd;
8817   struct adjust_toc_info toc_inf;
8818   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8819
8820   htab->do_toc_opt = 1;
8821   toc_inf.global_toc_syms = TRUE;
8822   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8823     {
8824       asection *toc, *sec;
8825       Elf_Internal_Shdr *symtab_hdr;
8826       Elf_Internal_Sym *local_syms;
8827       Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8828       unsigned long *skip, *drop;
8829       unsigned char *used;
8830       unsigned char *keep, last, some_unused;
8831
8832       if (!is_ppc64_elf (ibfd))
8833         continue;
8834
8835       toc = bfd_get_section_by_name (ibfd, ".toc");
8836       if (toc == NULL
8837           || toc->size == 0
8838           || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8839           || discarded_section (toc))
8840         continue;
8841
8842       toc_relocs = NULL;
8843       local_syms = NULL;
8844       symtab_hdr = &elf_symtab_hdr (ibfd);
8845
8846       /* Look at sections dropped from the final link.  */
8847       skip = NULL;
8848       relstart = NULL;
8849       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8850         {
8851           if (sec->reloc_count == 0
8852               || !discarded_section (sec)
8853               || get_opd_info (sec)
8854               || (sec->flags & SEC_ALLOC) == 0
8855               || (sec->flags & SEC_DEBUGGING) != 0)
8856             continue;
8857
8858           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8859           if (relstart == NULL)
8860             goto error_ret;
8861
8862           /* Run through the relocs to see which toc entries might be
8863              unused.  */
8864           for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8865             {
8866               enum elf_ppc64_reloc_type r_type;
8867               unsigned long r_symndx;
8868               asection *sym_sec;
8869               struct elf_link_hash_entry *h;
8870               Elf_Internal_Sym *sym;
8871               bfd_vma val;
8872
8873               r_type = ELF64_R_TYPE (rel->r_info);
8874               switch (r_type)
8875                 {
8876                 default:
8877                   continue;
8878
8879                 case R_PPC64_TOC16:
8880                 case R_PPC64_TOC16_LO:
8881                 case R_PPC64_TOC16_HI:
8882                 case R_PPC64_TOC16_HA:
8883                 case R_PPC64_TOC16_DS:
8884                 case R_PPC64_TOC16_LO_DS:
8885                   break;
8886                 }
8887
8888               r_symndx = ELF64_R_SYM (rel->r_info);
8889               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8890                               r_symndx, ibfd))
8891                 goto error_ret;
8892
8893               if (sym_sec != toc)
8894                 continue;
8895
8896               if (h != NULL)
8897                 val = h->root.u.def.value;
8898               else
8899                 val = sym->st_value;
8900               val += rel->r_addend;
8901
8902               if (val >= toc->size)
8903                 continue;
8904
8905               /* Anything in the toc ought to be aligned to 8 bytes.
8906                  If not, don't mark as unused.  */
8907               if (val & 7)
8908                 continue;
8909
8910               if (skip == NULL)
8911                 {
8912                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8913                   if (skip == NULL)
8914                     goto error_ret;
8915                 }
8916
8917               skip[val >> 3] = ref_from_discarded;
8918             }
8919
8920           if (elf_section_data (sec)->relocs != relstart)
8921             free (relstart);
8922         }
8923
8924       /* For largetoc loads of address constants, we can convert
8925          .  addis rx,2,addr@got@ha
8926          .  ld ry,addr@got@l(rx)
8927          to
8928          .  addis rx,2,addr@toc@ha
8929          .  addi ry,rx,addr@toc@l
8930          when addr is within 2G of the toc pointer.  This then means
8931          that the word storing "addr" in the toc is no longer needed.  */
8932
8933       if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
8934           && toc->output_section->rawsize < (bfd_vma) 1 << 31
8935           && toc->reloc_count != 0)
8936         {
8937           /* Read toc relocs.  */
8938           toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8939                                                   info->keep_memory);
8940           if (toc_relocs == NULL)
8941             goto error_ret;
8942
8943           for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8944             {
8945               enum elf_ppc64_reloc_type r_type;
8946               unsigned long r_symndx;
8947               asection *sym_sec;
8948               struct elf_link_hash_entry *h;
8949               Elf_Internal_Sym *sym;
8950               bfd_vma val, addr;
8951
8952               r_type = ELF64_R_TYPE (rel->r_info);
8953               if (r_type != R_PPC64_ADDR64)
8954                 continue;
8955
8956               r_symndx = ELF64_R_SYM (rel->r_info);
8957               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8958                               r_symndx, ibfd))
8959                 goto error_ret;
8960
8961               if (sym_sec == NULL
8962                   || sym_sec->output_section == NULL
8963                   || discarded_section (sym_sec))
8964                 continue;
8965
8966               if (!SYMBOL_REFERENCES_LOCAL (info, h))
8967                 continue;
8968
8969               if (h != NULL)
8970                 {
8971                   if (h->type == STT_GNU_IFUNC)
8972                     continue;
8973                   val = h->root.u.def.value;
8974                 }
8975               else
8976                 {
8977                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
8978                     continue;
8979                   val = sym->st_value;
8980                 }
8981               val += rel->r_addend;
8982               val += sym_sec->output_section->vma + sym_sec->output_offset;
8983
8984               /* We don't yet know the exact toc pointer value, but we
8985                  know it will be somewhere in the toc section.  Don't
8986                  optimize if the difference from any possible toc
8987                  pointer is outside [ff..f80008000, 7fff7fff].  */
8988               addr = toc->output_section->vma + TOC_BASE_OFF;
8989               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8990                 continue;
8991
8992               addr = toc->output_section->vma + toc->output_section->rawsize;
8993               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8994                 continue;
8995
8996               if (skip == NULL)
8997                 {
8998                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8999                   if (skip == NULL)
9000                     goto error_ret;
9001                 }
9002
9003               skip[rel->r_offset >> 3]
9004                 |= can_optimize | ((rel - toc_relocs) << 2);
9005             }
9006         }
9007
9008       if (skip == NULL)
9009         continue;
9010
9011       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
9012       if (used == NULL)
9013         {
9014         error_ret:
9015           if (local_syms != NULL
9016               && symtab_hdr->contents != (unsigned char *) local_syms)
9017             free (local_syms);
9018           if (sec != NULL
9019               && relstart != NULL
9020               && elf_section_data (sec)->relocs != relstart)
9021             free (relstart);
9022           if (toc_relocs != NULL
9023               && elf_section_data (toc)->relocs != toc_relocs)
9024             free (toc_relocs);
9025           if (skip != NULL)
9026             free (skip);
9027           return FALSE;
9028         }
9029
9030       /* Now check all kept sections that might reference the toc.
9031          Check the toc itself last.  */
9032       for (sec = (ibfd->sections == toc && toc->next ? toc->next
9033                   : ibfd->sections);
9034            sec != NULL;
9035            sec = (sec == toc ? NULL
9036                   : sec->next == NULL ? toc
9037                   : sec->next == toc && toc->next ? toc->next
9038                   : sec->next))
9039         {
9040           int repeat;
9041
9042           if (sec->reloc_count == 0
9043               || discarded_section (sec)
9044               || get_opd_info (sec)
9045               || (sec->flags & SEC_ALLOC) == 0
9046               || (sec->flags & SEC_DEBUGGING) != 0)
9047             continue;
9048
9049           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9050                                                 info->keep_memory);
9051           if (relstart == NULL)
9052             {
9053               free (used);
9054               goto error_ret;
9055             }
9056
9057           /* Mark toc entries referenced as used.  */
9058           do
9059             {
9060               repeat = 0;
9061               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9062                 {
9063                   enum elf_ppc64_reloc_type r_type;
9064                   unsigned long r_symndx;
9065                   asection *sym_sec;
9066                   struct elf_link_hash_entry *h;
9067                   Elf_Internal_Sym *sym;
9068                   bfd_vma val;
9069                   enum {no_check, check_lo, check_ha} insn_check;
9070
9071                   r_type = ELF64_R_TYPE (rel->r_info);
9072                   switch (r_type)
9073                     {
9074                     default:
9075                       insn_check = no_check;
9076                       break;
9077
9078                     case R_PPC64_GOT_TLSLD16_HA:
9079                     case R_PPC64_GOT_TLSGD16_HA:
9080                     case R_PPC64_GOT_TPREL16_HA:
9081                     case R_PPC64_GOT_DTPREL16_HA:
9082                     case R_PPC64_GOT16_HA:
9083                     case R_PPC64_TOC16_HA:
9084                       insn_check = check_ha;
9085                       break;
9086
9087                     case R_PPC64_GOT_TLSLD16_LO:
9088                     case R_PPC64_GOT_TLSGD16_LO:
9089                     case R_PPC64_GOT_TPREL16_LO_DS:
9090                     case R_PPC64_GOT_DTPREL16_LO_DS:
9091                     case R_PPC64_GOT16_LO:
9092                     case R_PPC64_GOT16_LO_DS:
9093                     case R_PPC64_TOC16_LO:
9094                     case R_PPC64_TOC16_LO_DS:
9095                       insn_check = check_lo;
9096                       break;
9097                     }
9098
9099                   if (insn_check != no_check)
9100                     {
9101                       bfd_vma off = rel->r_offset & ~3;
9102                       unsigned char buf[4];
9103                       unsigned int insn;
9104
9105                       if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
9106                         {
9107                           free (used);
9108                           goto error_ret;
9109                         }
9110                       insn = bfd_get_32 (ibfd, buf);
9111                       if (insn_check == check_lo
9112                           ? !ok_lo_toc_insn (insn)
9113                           : ((insn & ((0x3f << 26) | 0x1f << 16))
9114                              != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9115                         {
9116                           char str[12];
9117
9118                           ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
9119                           sprintf (str, "%#08x", insn);
9120                           info->callbacks->einfo
9121                             (_("%P: %H: toc optimization is not supported for"
9122                                " %s instruction.\n"),
9123                              ibfd, sec, rel->r_offset & ~3, str);
9124                         }
9125                     }
9126
9127                   switch (r_type)
9128                     {
9129                     case R_PPC64_TOC16:
9130                     case R_PPC64_TOC16_LO:
9131                     case R_PPC64_TOC16_HI:
9132                     case R_PPC64_TOC16_HA:
9133                     case R_PPC64_TOC16_DS:
9134                     case R_PPC64_TOC16_LO_DS:
9135                       /* In case we're taking addresses of toc entries.  */
9136                     case R_PPC64_ADDR64:
9137                       break;
9138
9139                     default:
9140                       continue;
9141                     }
9142
9143                   r_symndx = ELF64_R_SYM (rel->r_info);
9144                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9145                                   r_symndx, ibfd))
9146                     {
9147                       free (used);
9148                       goto error_ret;
9149                     }
9150
9151                   if (sym_sec != toc)
9152                     continue;
9153
9154                   if (h != NULL)
9155                     val = h->root.u.def.value;
9156                   else
9157                     val = sym->st_value;
9158                   val += rel->r_addend;
9159
9160                   if (val >= toc->size)
9161                     continue;
9162
9163                   if ((skip[val >> 3] & can_optimize) != 0)
9164                     {
9165                       bfd_vma off;
9166                       unsigned char opc;
9167
9168                       switch (r_type)
9169                         {
9170                         case R_PPC64_TOC16_HA:
9171                           break;
9172
9173                         case R_PPC64_TOC16_LO_DS:
9174                           off = rel->r_offset;
9175                           off += (bfd_big_endian (ibfd) ? -2 : 3);
9176                           if (!bfd_get_section_contents (ibfd, sec, &opc,
9177                                                          off, 1))
9178                             {
9179                               free (used);
9180                               goto error_ret;
9181                             }
9182                           if ((opc & (0x3f << 2)) == (58u << 2))
9183                             break;
9184                           /* Fall thru */
9185
9186                         default:
9187                           /* Wrong sort of reloc, or not a ld.  We may
9188                              as well clear ref_from_discarded too.  */
9189                           skip[val >> 3] = 0;
9190                         }
9191                     }
9192
9193                   if (sec != toc)
9194                     used[val >> 3] = 1;
9195                   /* For the toc section, we only mark as used if this
9196                      entry itself isn't unused.  */
9197                   else if ((used[rel->r_offset >> 3]
9198                             || !(skip[rel->r_offset >> 3] & ref_from_discarded))
9199                            && !used[val >> 3])
9200                     {
9201                       /* Do all the relocs again, to catch reference
9202                          chains.  */
9203                       repeat = 1;
9204                       used[val >> 3] = 1;
9205                     }
9206                 }
9207             }
9208           while (repeat);
9209
9210           if (elf_section_data (sec)->relocs != relstart)
9211             free (relstart);
9212         }
9213
9214       /* Merge the used and skip arrays.  Assume that TOC
9215          doublewords not appearing as either used or unused belong
9216          to to an entry more than one doubleword in size.  */
9217       for (drop = skip, keep = used, last = 0, some_unused = 0;
9218            drop < skip + (toc->size + 7) / 8;
9219            ++drop, ++keep)
9220         {
9221           if (*keep)
9222             {
9223               *drop &= ~ref_from_discarded;
9224               if ((*drop & can_optimize) != 0)
9225                 some_unused = 1;
9226               last = 0;
9227             }
9228           else if ((*drop & ref_from_discarded) != 0)
9229             {
9230               some_unused = 1;
9231               last = ref_from_discarded;
9232             }
9233           else
9234             *drop = last;
9235         }
9236
9237       free (used);
9238
9239       if (some_unused)
9240         {
9241           bfd_byte *contents, *src;
9242           unsigned long off;
9243           Elf_Internal_Sym *sym;
9244           bfd_boolean local_toc_syms = FALSE;
9245
9246           /* Shuffle the toc contents, and at the same time convert the
9247              skip array from booleans into offsets.  */
9248           if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9249             goto error_ret;
9250
9251           elf_section_data (toc)->this_hdr.contents = contents;
9252
9253           for (src = contents, off = 0, drop = skip;
9254                src < contents + toc->size;
9255                src += 8, ++drop)
9256             {
9257               if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9258                 off += 8;
9259               else if (off != 0)
9260                 {
9261                   *drop = off;
9262                   memcpy (src - off, src, 8);
9263                 }
9264             }
9265           *drop = off;
9266           toc->rawsize = toc->size;
9267           toc->size = src - contents - off;
9268
9269           /* Adjust addends for relocs against the toc section sym,
9270              and optimize any accesses we can.  */
9271           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9272             {
9273               if (sec->reloc_count == 0
9274                   || discarded_section (sec))
9275                 continue;
9276
9277               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9278                                                     info->keep_memory);
9279               if (relstart == NULL)
9280                 goto error_ret;
9281
9282               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9283                 {
9284                   enum elf_ppc64_reloc_type r_type;
9285                   unsigned long r_symndx;
9286                   asection *sym_sec;
9287                   struct elf_link_hash_entry *h;
9288                   bfd_vma val;
9289
9290                   r_type = ELF64_R_TYPE (rel->r_info);
9291                   switch (r_type)
9292                     {
9293                     default:
9294                       continue;
9295
9296                     case R_PPC64_TOC16:
9297                     case R_PPC64_TOC16_LO:
9298                     case R_PPC64_TOC16_HI:
9299                     case R_PPC64_TOC16_HA:
9300                     case R_PPC64_TOC16_DS:
9301                     case R_PPC64_TOC16_LO_DS:
9302                     case R_PPC64_ADDR64:
9303                       break;
9304                     }
9305
9306                   r_symndx = ELF64_R_SYM (rel->r_info);
9307                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9308                                   r_symndx, ibfd))
9309                     goto error_ret;
9310
9311                   if (sym_sec != toc)
9312                     continue;
9313
9314                   if (h != NULL)
9315                     val = h->root.u.def.value;
9316                   else
9317                     {
9318                       val = sym->st_value;
9319                       if (val != 0)
9320                         local_toc_syms = TRUE;
9321                     }
9322
9323                   val += rel->r_addend;
9324
9325                   if (val > toc->rawsize)
9326                     val = toc->rawsize;
9327                   else if ((skip[val >> 3] & ref_from_discarded) != 0)
9328                     continue;
9329                   else if ((skip[val >> 3] & can_optimize) != 0)
9330                     {
9331                       Elf_Internal_Rela *tocrel
9332                         = toc_relocs + (skip[val >> 3] >> 2);
9333                       unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9334
9335                       switch (r_type)
9336                         {
9337                         case R_PPC64_TOC16_HA:
9338                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9339                           break;
9340
9341                         case R_PPC64_TOC16_LO_DS:
9342                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9343                           break;
9344
9345                         default:
9346                           if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9347                             ppc_howto_init ();
9348                           info->callbacks->einfo
9349                             (_("%P: %H: %s references "
9350                                "optimized away TOC entry\n"),
9351                              ibfd, sec, rel->r_offset,
9352                              ppc64_elf_howto_table[r_type]->name);
9353                           bfd_set_error (bfd_error_bad_value);
9354                           goto error_ret;
9355                         }
9356                       rel->r_addend = tocrel->r_addend;
9357                       elf_section_data (sec)->relocs = relstart;
9358                       continue;
9359                     }
9360
9361                   if (h != NULL || sym->st_value != 0)
9362                     continue;
9363
9364                   rel->r_addend -= skip[val >> 3];
9365                   elf_section_data (sec)->relocs = relstart;
9366                 }
9367
9368               if (elf_section_data (sec)->relocs != relstart)
9369                 free (relstart);
9370             }
9371
9372           /* We shouldn't have local or global symbols defined in the TOC,
9373              but handle them anyway.  */
9374           if (local_syms != NULL)
9375             for (sym = local_syms;
9376                  sym < local_syms + symtab_hdr->sh_info;
9377                  ++sym)
9378               if (sym->st_value != 0
9379                   && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9380                 {
9381                   unsigned long i;
9382
9383                   if (sym->st_value > toc->rawsize)
9384                     i = toc->rawsize >> 3;
9385                   else
9386                     i = sym->st_value >> 3;
9387
9388                   if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9389                     {
9390                       if (local_toc_syms)
9391                         (*_bfd_error_handler)
9392                           (_("%s defined on removed toc entry"),
9393                            bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9394                       do
9395                         ++i;
9396                       while ((skip[i] & (ref_from_discarded | can_optimize)));
9397                       sym->st_value = (bfd_vma) i << 3;
9398                     }
9399
9400                   sym->st_value -= skip[i];
9401                   symtab_hdr->contents = (unsigned char *) local_syms;
9402                 }
9403
9404           /* Adjust any global syms defined in this toc input section.  */
9405           if (toc_inf.global_toc_syms)
9406             {
9407               toc_inf.toc = toc;
9408               toc_inf.skip = skip;
9409               toc_inf.global_toc_syms = FALSE;
9410               elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9411                                       &toc_inf);
9412             }
9413
9414           if (toc->reloc_count != 0)
9415             {
9416               Elf_Internal_Shdr *rel_hdr;
9417               Elf_Internal_Rela *wrel;
9418               bfd_size_type sz;
9419
9420               /* Remove unused toc relocs, and adjust those we keep.  */
9421               if (toc_relocs == NULL)
9422                 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9423                                                         info->keep_memory);
9424               if (toc_relocs == NULL)
9425                 goto error_ret;
9426
9427               wrel = toc_relocs;
9428               for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9429                 if ((skip[rel->r_offset >> 3]
9430                      & (ref_from_discarded | can_optimize)) == 0)
9431                   {
9432                     wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9433                     wrel->r_info = rel->r_info;
9434                     wrel->r_addend = rel->r_addend;
9435                     ++wrel;
9436                   }
9437                 else if (!dec_dynrel_count (rel->r_info, toc, info,
9438                                             &local_syms, NULL, NULL))
9439                   goto error_ret;
9440
9441               elf_section_data (toc)->relocs = toc_relocs;
9442               toc->reloc_count = wrel - toc_relocs;
9443               rel_hdr = _bfd_elf_single_rel_hdr (toc);
9444               sz = rel_hdr->sh_entsize;
9445               rel_hdr->sh_size = toc->reloc_count * sz;
9446             }
9447         }
9448       else if (toc_relocs != NULL
9449                && elf_section_data (toc)->relocs != toc_relocs)
9450         free (toc_relocs);
9451
9452       if (local_syms != NULL
9453           && symtab_hdr->contents != (unsigned char *) local_syms)
9454         {
9455           if (!info->keep_memory)
9456             free (local_syms);
9457           else
9458             symtab_hdr->contents = (unsigned char *) local_syms;
9459         }
9460       free (skip);
9461     }
9462
9463   return TRUE;
9464 }
9465
9466 /* Return true iff input section I references the TOC using
9467    instructions limited to +/-32k offsets.  */
9468
9469 bfd_boolean
9470 ppc64_elf_has_small_toc_reloc (asection *i)
9471 {
9472   return (is_ppc64_elf (i->owner)
9473           && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9474 }
9475
9476 /* Allocate space for one GOT entry.  */
9477
9478 static void
9479 allocate_got (struct elf_link_hash_entry *h,
9480               struct bfd_link_info *info,
9481               struct got_entry *gent)
9482 {
9483   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9484   bfd_boolean dyn;
9485   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9486   int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9487                  ? 16 : 8);
9488   int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9489                   ? 2 : 1) * sizeof (Elf64_External_Rela);
9490   asection *got = ppc64_elf_tdata (gent->owner)->got;
9491
9492   gent->got.offset = got->size;
9493   got->size += entsize;
9494
9495   dyn = htab->elf.dynamic_sections_created;
9496   if (h->type == STT_GNU_IFUNC)
9497     {
9498       htab->elf.irelplt->size += rentsize;
9499       htab->got_reli_size += rentsize;
9500     }
9501   else if ((bfd_link_pic (info)
9502             || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
9503            && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9504                || h->root.type != bfd_link_hash_undefweak))
9505     {
9506       asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9507       relgot->size += rentsize;
9508     }
9509 }
9510
9511 /* This function merges got entries in the same toc group.  */
9512
9513 static void
9514 merge_got_entries (struct got_entry **pent)
9515 {
9516   struct got_entry *ent, *ent2;
9517
9518   for (ent = *pent; ent != NULL; ent = ent->next)
9519     if (!ent->is_indirect)
9520       for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9521         if (!ent2->is_indirect
9522             && ent2->addend == ent->addend
9523             && ent2->tls_type == ent->tls_type
9524             && elf_gp (ent2->owner) == elf_gp (ent->owner))
9525           {
9526             ent2->is_indirect = TRUE;
9527             ent2->got.ent = ent;
9528           }
9529 }
9530
9531 /* Allocate space in .plt, .got and associated reloc sections for
9532    dynamic relocs.  */
9533
9534 static bfd_boolean
9535 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9536 {
9537   struct bfd_link_info *info;
9538   struct ppc_link_hash_table *htab;
9539   asection *s;
9540   struct ppc_link_hash_entry *eh;
9541   struct elf_dyn_relocs *p;
9542   struct got_entry **pgent, *gent;
9543
9544   if (h->root.type == bfd_link_hash_indirect)
9545     return TRUE;
9546
9547   info = (struct bfd_link_info *) inf;
9548   htab = ppc_hash_table (info);
9549   if (htab == NULL)
9550     return FALSE;
9551
9552   if ((htab->elf.dynamic_sections_created
9553        && h->dynindx != -1
9554        && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
9555       || h->type == STT_GNU_IFUNC)
9556     {
9557       struct plt_entry *pent;
9558       bfd_boolean doneone = FALSE;
9559       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9560         if (pent->plt.refcount > 0)
9561           {
9562             if (!htab->elf.dynamic_sections_created
9563                 || h->dynindx == -1)
9564               {
9565                 s = htab->elf.iplt;
9566                 pent->plt.offset = s->size;
9567                 s->size += PLT_ENTRY_SIZE (htab);
9568                 s = htab->elf.irelplt;
9569               }
9570             else
9571               {
9572                 /* If this is the first .plt entry, make room for the special
9573                    first entry.  */
9574                 s = htab->elf.splt;
9575                 if (s->size == 0)
9576                   s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9577
9578                 pent->plt.offset = s->size;
9579
9580                 /* Make room for this entry.  */
9581                 s->size += PLT_ENTRY_SIZE (htab);
9582
9583                 /* Make room for the .glink code.  */
9584                 s = htab->glink;
9585                 if (s->size == 0)
9586                   s->size += GLINK_CALL_STUB_SIZE;
9587                 if (htab->opd_abi)
9588                   {
9589                     /* We need bigger stubs past index 32767.  */
9590                     if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9591                       s->size += 4;
9592                     s->size += 2*4;
9593                   }
9594                 else
9595                   s->size += 4;
9596
9597                 /* We also need to make an entry in the .rela.plt section.  */
9598                 s = htab->elf.srelplt;
9599               }
9600             s->size += sizeof (Elf64_External_Rela);
9601             doneone = TRUE;
9602           }
9603         else
9604           pent->plt.offset = (bfd_vma) -1;
9605       if (!doneone)
9606         {
9607           h->plt.plist = NULL;
9608           h->needs_plt = 0;
9609         }
9610     }
9611   else
9612     {
9613       h->plt.plist = NULL;
9614       h->needs_plt = 0;
9615     }
9616
9617   eh = (struct ppc_link_hash_entry *) h;
9618   /* Run through the TLS GD got entries first if we're changing them
9619      to TPREL.  */
9620   if ((eh->tls_mask & TLS_TPRELGD) != 0)
9621     for (gent = h->got.glist; gent != NULL; gent = gent->next)
9622       if (gent->got.refcount > 0
9623           && (gent->tls_type & TLS_GD) != 0)
9624         {
9625           /* This was a GD entry that has been converted to TPREL.  If
9626              there happens to be a TPREL entry we can use that one.  */
9627           struct got_entry *ent;
9628           for (ent = h->got.glist; ent != NULL; ent = ent->next)
9629             if (ent->got.refcount > 0
9630                 && (ent->tls_type & TLS_TPREL) != 0
9631                 && ent->addend == gent->addend
9632                 && ent->owner == gent->owner)
9633               {
9634                 gent->got.refcount = 0;
9635                 break;
9636               }
9637
9638           /* If not, then we'll be using our own TPREL entry.  */
9639           if (gent->got.refcount != 0)
9640             gent->tls_type = TLS_TLS | TLS_TPREL;
9641         }
9642
9643   /* Remove any list entry that won't generate a word in the GOT before
9644      we call merge_got_entries.  Otherwise we risk merging to empty
9645      entries.  */
9646   pgent = &h->got.glist;
9647   while ((gent = *pgent) != NULL)
9648     if (gent->got.refcount > 0)
9649       {
9650         if ((gent->tls_type & TLS_LD) != 0
9651             && !h->def_dynamic)
9652           {
9653             ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9654             *pgent = gent->next;
9655           }
9656         else
9657           pgent = &gent->next;
9658       }
9659     else
9660       *pgent = gent->next;
9661
9662   if (!htab->do_multi_toc)
9663     merge_got_entries (&h->got.glist);
9664
9665   for (gent = h->got.glist; gent != NULL; gent = gent->next)
9666     if (!gent->is_indirect)
9667       {
9668         /* Make sure this symbol is output as a dynamic symbol.
9669            Undefined weak syms won't yet be marked as dynamic,
9670            nor will all TLS symbols.  */
9671         if (h->dynindx == -1
9672             && !h->forced_local
9673             && h->type != STT_GNU_IFUNC
9674             && htab->elf.dynamic_sections_created)
9675           {
9676             if (! bfd_elf_link_record_dynamic_symbol (info, h))
9677               return FALSE;
9678           }
9679
9680         if (!is_ppc64_elf (gent->owner))
9681           abort ();
9682
9683         allocate_got (h, info, gent);
9684       }
9685
9686   if (eh->dyn_relocs == NULL
9687       || (!htab->elf.dynamic_sections_created
9688           && h->type != STT_GNU_IFUNC))
9689     return TRUE;
9690
9691   /* In the shared -Bsymbolic case, discard space allocated for
9692      dynamic pc-relative relocs against symbols which turn out to be
9693      defined in regular objects.  For the normal shared case, discard
9694      space for relocs that have become local due to symbol visibility
9695      changes.  */
9696
9697   if (bfd_link_pic (info))
9698     {
9699       /* Relocs that use pc_count are those that appear on a call insn,
9700          or certain REL relocs (see must_be_dyn_reloc) that can be
9701          generated via assembly.  We want calls to protected symbols to
9702          resolve directly to the function rather than going via the plt.
9703          If people want function pointer comparisons to work as expected
9704          then they should avoid writing weird assembly.  */
9705       if (SYMBOL_CALLS_LOCAL (info, h))
9706         {
9707           struct elf_dyn_relocs **pp;
9708
9709           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9710             {
9711               p->count -= p->pc_count;
9712               p->pc_count = 0;
9713               if (p->count == 0)
9714                 *pp = p->next;
9715               else
9716                 pp = &p->next;
9717             }
9718         }
9719
9720       /* Also discard relocs on undefined weak syms with non-default
9721          visibility.  */
9722       if (eh->dyn_relocs != NULL
9723           && h->root.type == bfd_link_hash_undefweak)
9724         {
9725           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9726             eh->dyn_relocs = NULL;
9727
9728           /* Make sure this symbol is output as a dynamic symbol.
9729              Undefined weak syms won't yet be marked as dynamic.  */
9730           else if (h->dynindx == -1
9731                    && !h->forced_local)
9732             {
9733               if (! bfd_elf_link_record_dynamic_symbol (info, h))
9734                 return FALSE;
9735             }
9736         }
9737     }
9738   else if (h->type == STT_GNU_IFUNC)
9739     {
9740       if (!h->non_got_ref)
9741         eh->dyn_relocs = NULL;
9742     }
9743   else if (ELIMINATE_COPY_RELOCS)
9744     {
9745       /* For the non-shared case, discard space for relocs against
9746          symbols which turn out to need copy relocs or are not
9747          dynamic.  */
9748
9749       if (!h->non_got_ref
9750           && !h->def_regular)
9751         {
9752           /* Make sure this symbol is output as a dynamic symbol.
9753              Undefined weak syms won't yet be marked as dynamic.  */
9754           if (h->dynindx == -1
9755               && !h->forced_local)
9756             {
9757               if (! bfd_elf_link_record_dynamic_symbol (info, h))
9758                 return FALSE;
9759             }
9760
9761           /* If that succeeded, we know we'll be keeping all the
9762              relocs.  */
9763           if (h->dynindx != -1)
9764             goto keep;
9765         }
9766
9767       eh->dyn_relocs = NULL;
9768
9769     keep: ;
9770     }
9771
9772   /* Finally, allocate space.  */
9773   for (p = eh->dyn_relocs; p != NULL; p = p->next)
9774     {
9775       asection *sreloc = elf_section_data (p->sec)->sreloc;
9776       if (eh->elf.type == STT_GNU_IFUNC)
9777         sreloc = htab->elf.irelplt;
9778       sreloc->size += p->count * sizeof (Elf64_External_Rela);
9779     }
9780
9781   return TRUE;
9782 }
9783
9784 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9785    to set up space for global entry stubs.  These are put in glink,
9786    after the branch table.  */
9787
9788 static bfd_boolean
9789 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
9790 {
9791   struct bfd_link_info *info;
9792   struct ppc_link_hash_table *htab;
9793   struct plt_entry *pent;
9794   asection *s;
9795
9796   if (h->root.type == bfd_link_hash_indirect)
9797     return TRUE;
9798
9799   if (!h->pointer_equality_needed)
9800     return TRUE;
9801
9802   if (h->def_regular)
9803     return TRUE;
9804
9805   info = inf;
9806   htab = ppc_hash_table (info);
9807   if (htab == NULL)
9808     return FALSE;
9809
9810   s = htab->glink;
9811   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9812     if (pent->plt.offset != (bfd_vma) -1
9813         && pent->addend == 0)
9814       {
9815         /* For ELFv2, if this symbol is not defined in a regular file
9816            and we are not generating a shared library or pie, then we
9817            need to define the symbol in the executable on a call stub.
9818            This is to avoid text relocations.  */
9819         s->size = (s->size + 15) & -16;
9820         h->root.u.def.section = s;
9821         h->root.u.def.value = s->size;
9822         s->size += 16;
9823         break;
9824       }
9825   return TRUE;
9826 }
9827
9828 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9829    read-only sections.  */
9830
9831 static bfd_boolean
9832 maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
9833 {
9834   if (h->root.type == bfd_link_hash_indirect)
9835     return TRUE;
9836
9837   if (readonly_dynrelocs (h))
9838     {
9839       ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
9840
9841       /* Not an error, just cut short the traversal.  */
9842       return FALSE;
9843     }
9844   return TRUE;
9845 }
9846
9847 /* Set the sizes of the dynamic sections.  */
9848
9849 static bfd_boolean
9850 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
9851                                  struct bfd_link_info *info)
9852 {
9853   struct ppc_link_hash_table *htab;
9854   bfd *dynobj;
9855   asection *s;
9856   bfd_boolean relocs;
9857   bfd *ibfd;
9858   struct got_entry *first_tlsld;
9859
9860   htab = ppc_hash_table (info);
9861   if (htab == NULL)
9862     return FALSE;
9863
9864   dynobj = htab->elf.dynobj;
9865   if (dynobj == NULL)
9866     abort ();
9867
9868   if (htab->elf.dynamic_sections_created)
9869     {
9870       /* Set the contents of the .interp section to the interpreter.  */
9871       if (bfd_link_executable (info) && !info->nointerp)
9872         {
9873           s = bfd_get_linker_section (dynobj, ".interp");
9874           if (s == NULL)
9875             abort ();
9876           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
9877           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
9878         }
9879     }
9880
9881   /* Set up .got offsets for local syms, and space for local dynamic
9882      relocs.  */
9883   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9884     {
9885       struct got_entry **lgot_ents;
9886       struct got_entry **end_lgot_ents;
9887       struct plt_entry **local_plt;
9888       struct plt_entry **end_local_plt;
9889       unsigned char *lgot_masks;
9890       bfd_size_type locsymcount;
9891       Elf_Internal_Shdr *symtab_hdr;
9892
9893       if (!is_ppc64_elf (ibfd))
9894         continue;
9895
9896       for (s = ibfd->sections; s != NULL; s = s->next)
9897         {
9898           struct ppc_dyn_relocs *p;
9899
9900           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
9901             {
9902               if (!bfd_is_abs_section (p->sec)
9903                   && bfd_is_abs_section (p->sec->output_section))
9904                 {
9905                   /* Input section has been discarded, either because
9906                      it is a copy of a linkonce section or due to
9907                      linker script /DISCARD/, so we'll be discarding
9908                      the relocs too.  */
9909                 }
9910               else if (p->count != 0)
9911                 {
9912                   asection *srel = elf_section_data (p->sec)->sreloc;
9913                   if (p->ifunc)
9914                     srel = htab->elf.irelplt;
9915                   srel->size += p->count * sizeof (Elf64_External_Rela);
9916                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
9917                     info->flags |= DF_TEXTREL;
9918                 }
9919             }
9920         }
9921
9922       lgot_ents = elf_local_got_ents (ibfd);
9923       if (!lgot_ents)
9924         continue;
9925
9926       symtab_hdr = &elf_symtab_hdr (ibfd);
9927       locsymcount = symtab_hdr->sh_info;
9928       end_lgot_ents = lgot_ents + locsymcount;
9929       local_plt = (struct plt_entry **) end_lgot_ents;
9930       end_local_plt = local_plt + locsymcount;
9931       lgot_masks = (unsigned char *) end_local_plt;
9932       s = ppc64_elf_tdata (ibfd)->got;
9933       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
9934         {
9935           struct got_entry **pent, *ent;
9936
9937           pent = lgot_ents;
9938           while ((ent = *pent) != NULL)
9939             if (ent->got.refcount > 0)
9940               {
9941                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
9942                   {
9943                     ppc64_tlsld_got (ibfd)->got.refcount += 1;
9944                     *pent = ent->next;
9945                   }
9946                 else
9947                   {
9948                     unsigned int ent_size = 8;
9949                     unsigned int rel_size = sizeof (Elf64_External_Rela);
9950
9951                     ent->got.offset = s->size;
9952                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
9953                       {
9954                         ent_size *= 2;
9955                         rel_size *= 2;
9956                       }
9957                     s->size += ent_size;
9958                     if ((*lgot_masks & PLT_IFUNC) != 0)
9959                       {
9960                         htab->elf.irelplt->size += rel_size;
9961                         htab->got_reli_size += rel_size;
9962                       }
9963                     else if (bfd_link_pic (info))
9964                       {
9965                         asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9966                         srel->size += rel_size;
9967                       }
9968                     pent = &ent->next;
9969                   }
9970               }
9971             else
9972               *pent = ent->next;
9973         }
9974
9975       /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt.  */
9976       for (; local_plt < end_local_plt; ++local_plt)
9977         {
9978           struct plt_entry *ent;
9979
9980           for (ent = *local_plt; ent != NULL; ent = ent->next)
9981             if (ent->plt.refcount > 0)
9982               {
9983                 s = htab->elf.iplt;
9984                 ent->plt.offset = s->size;
9985                 s->size += PLT_ENTRY_SIZE (htab);
9986
9987                 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
9988               }
9989             else
9990               ent->plt.offset = (bfd_vma) -1;
9991         }
9992     }
9993
9994   /* Allocate global sym .plt and .got entries, and space for global
9995      sym dynamic relocs.  */
9996   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
9997   /* Stash the end of glink branch table.  */
9998   if (htab->glink != NULL)
9999     htab->glink->rawsize = htab->glink->size;
10000
10001   if (!htab->opd_abi && !bfd_link_pic (info))
10002     elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
10003
10004   first_tlsld = NULL;
10005   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10006     {
10007       struct got_entry *ent;
10008
10009       if (!is_ppc64_elf (ibfd))
10010         continue;
10011
10012       ent = ppc64_tlsld_got (ibfd);
10013       if (ent->got.refcount > 0)
10014         {
10015           if (!htab->do_multi_toc && first_tlsld != NULL)
10016             {
10017               ent->is_indirect = TRUE;
10018               ent->got.ent = first_tlsld;
10019             }
10020           else
10021             {
10022               if (first_tlsld == NULL)
10023                 first_tlsld = ent;
10024               s = ppc64_elf_tdata (ibfd)->got;
10025               ent->got.offset = s->size;
10026               ent->owner = ibfd;
10027               s->size += 16;
10028               if (bfd_link_pic (info))
10029                 {
10030                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10031                   srel->size += sizeof (Elf64_External_Rela);
10032                 }
10033             }
10034         }
10035       else
10036         ent->got.offset = (bfd_vma) -1;
10037     }
10038
10039   /* We now have determined the sizes of the various dynamic sections.
10040      Allocate memory for them.  */
10041   relocs = FALSE;
10042   for (s = dynobj->sections; s != NULL; s = s->next)
10043     {
10044       if ((s->flags & SEC_LINKER_CREATED) == 0)
10045         continue;
10046
10047       if (s == htab->brlt || s == htab->relbrlt)
10048         /* These haven't been allocated yet;  don't strip.  */
10049         continue;
10050       else if (s == htab->elf.sgot
10051                || s == htab->elf.splt
10052                || s == htab->elf.iplt
10053                || s == htab->glink
10054                || s == htab->dynbss)
10055         {
10056           /* Strip this section if we don't need it; see the
10057              comment below.  */
10058         }
10059       else if (s == htab->glink_eh_frame)
10060         {
10061           if (!bfd_is_abs_section (s->output_section))
10062             /* Not sized yet.  */
10063             continue;
10064         }
10065       else if (CONST_STRNEQ (s->name, ".rela"))
10066         {
10067           if (s->size != 0)
10068             {
10069               if (s != htab->elf.srelplt)
10070                 relocs = TRUE;
10071
10072               /* We use the reloc_count field as a counter if we need
10073                  to copy relocs into the output file.  */
10074               s->reloc_count = 0;
10075             }
10076         }
10077       else
10078         {
10079           /* It's not one of our sections, so don't allocate space.  */
10080           continue;
10081         }
10082
10083       if (s->size == 0)
10084         {
10085           /* If we don't need this section, strip it from the
10086              output file.  This is mostly to handle .rela.bss and
10087              .rela.plt.  We must create both sections in
10088              create_dynamic_sections, because they must be created
10089              before the linker maps input sections to output
10090              sections.  The linker does that before
10091              adjust_dynamic_symbol is called, and it is that
10092              function which decides whether anything needs to go
10093              into these sections.  */
10094           s->flags |= SEC_EXCLUDE;
10095           continue;
10096         }
10097
10098       if ((s->flags & SEC_HAS_CONTENTS) == 0)
10099         continue;
10100
10101       /* Allocate memory for the section contents.  We use bfd_zalloc
10102          here in case unused entries are not reclaimed before the
10103          section's contents are written out.  This should not happen,
10104          but this way if it does we get a R_PPC64_NONE reloc in .rela
10105          sections instead of garbage.
10106          We also rely on the section contents being zero when writing
10107          the GOT.  */
10108       s->contents = bfd_zalloc (dynobj, s->size);
10109       if (s->contents == NULL)
10110         return FALSE;
10111     }
10112
10113   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10114     {
10115       if (!is_ppc64_elf (ibfd))
10116         continue;
10117
10118       s = ppc64_elf_tdata (ibfd)->got;
10119       if (s != NULL && s != htab->elf.sgot)
10120         {
10121           if (s->size == 0)
10122             s->flags |= SEC_EXCLUDE;
10123           else
10124             {
10125               s->contents = bfd_zalloc (ibfd, s->size);
10126               if (s->contents == NULL)
10127                 return FALSE;
10128             }
10129         }
10130       s = ppc64_elf_tdata (ibfd)->relgot;
10131       if (s != NULL)
10132         {
10133           if (s->size == 0)
10134             s->flags |= SEC_EXCLUDE;
10135           else
10136             {
10137               s->contents = bfd_zalloc (ibfd, s->size);
10138               if (s->contents == NULL)
10139                 return FALSE;
10140               relocs = TRUE;
10141               s->reloc_count = 0;
10142             }
10143         }
10144     }
10145
10146   if (htab->elf.dynamic_sections_created)
10147     {
10148       bfd_boolean tls_opt;
10149
10150       /* Add some entries to the .dynamic section.  We fill in the
10151          values later, in ppc64_elf_finish_dynamic_sections, but we
10152          must add the entries now so that we get the correct size for
10153          the .dynamic section.  The DT_DEBUG entry is filled in by the
10154          dynamic linker and used by the debugger.  */
10155 #define add_dynamic_entry(TAG, VAL) \
10156   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10157
10158       if (bfd_link_executable (info))
10159         {
10160           if (!add_dynamic_entry (DT_DEBUG, 0))
10161             return FALSE;
10162         }
10163
10164       if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
10165         {
10166           if (!add_dynamic_entry (DT_PLTGOT, 0)
10167               || !add_dynamic_entry (DT_PLTRELSZ, 0)
10168               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
10169               || !add_dynamic_entry (DT_JMPREL, 0)
10170               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
10171             return FALSE;
10172         }
10173
10174       if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
10175         {
10176           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
10177               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
10178             return FALSE;
10179         }
10180
10181       tls_opt = (htab->params->tls_get_addr_opt
10182                  && htab->tls_get_addr_fd != NULL
10183                  && htab->tls_get_addr_fd->elf.plt.plist != NULL);
10184       if (tls_opt || !htab->opd_abi)
10185         {
10186           if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
10187             return FALSE;
10188         }
10189
10190       if (relocs)
10191         {
10192           if (!add_dynamic_entry (DT_RELA, 0)
10193               || !add_dynamic_entry (DT_RELASZ, 0)
10194               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
10195             return FALSE;
10196
10197           /* If any dynamic relocs apply to a read-only section,
10198              then we need a DT_TEXTREL entry.  */
10199           if ((info->flags & DF_TEXTREL) == 0)
10200             elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
10201
10202           if ((info->flags & DF_TEXTREL) != 0)
10203             {
10204               if (!add_dynamic_entry (DT_TEXTREL, 0))
10205                 return FALSE;
10206             }
10207         }
10208     }
10209 #undef add_dynamic_entry
10210
10211   return TRUE;
10212 }
10213
10214 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
10215
10216 static bfd_boolean
10217 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
10218 {
10219   if (h->plt.plist != NULL
10220       && !h->def_regular
10221       && !h->pointer_equality_needed)
10222     return FALSE;
10223
10224   return _bfd_elf_hash_symbol (h);
10225 }
10226
10227 /* Determine the type of stub needed, if any, for a call.  */
10228
10229 static inline enum ppc_stub_type
10230 ppc_type_of_stub (asection *input_sec,
10231                   const Elf_Internal_Rela *rel,
10232                   struct ppc_link_hash_entry **hash,
10233                   struct plt_entry **plt_ent,
10234                   bfd_vma destination,
10235                   unsigned long local_off)
10236 {
10237   struct ppc_link_hash_entry *h = *hash;
10238   bfd_vma location;
10239   bfd_vma branch_offset;
10240   bfd_vma max_branch_offset;
10241   enum elf_ppc64_reloc_type r_type;
10242
10243   if (h != NULL)
10244     {
10245       struct plt_entry *ent;
10246       struct ppc_link_hash_entry *fdh = h;
10247       if (h->oh != NULL
10248           && h->oh->is_func_descriptor)
10249         {
10250           fdh = ppc_follow_link (h->oh);
10251           *hash = fdh;
10252         }
10253
10254       for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10255         if (ent->addend == rel->r_addend
10256             && ent->plt.offset != (bfd_vma) -1)
10257           {
10258             *plt_ent = ent;
10259             return ppc_stub_plt_call;
10260           }
10261
10262       /* Here, we know we don't have a plt entry.  If we don't have a
10263          either a defined function descriptor or a defined entry symbol
10264          in a regular object file, then it is pointless trying to make
10265          any other type of stub.  */
10266       if (!is_static_defined (&fdh->elf)
10267           && !is_static_defined (&h->elf))
10268         return ppc_stub_none;
10269     }
10270   else if (elf_local_got_ents (input_sec->owner) != NULL)
10271     {
10272       Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10273       struct plt_entry **local_plt = (struct plt_entry **)
10274         elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10275       unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10276
10277       if (local_plt[r_symndx] != NULL)
10278         {
10279           struct plt_entry *ent;
10280
10281           for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10282             if (ent->addend == rel->r_addend
10283                 && ent->plt.offset != (bfd_vma) -1)
10284               {
10285                 *plt_ent = ent;
10286                 return ppc_stub_plt_call;
10287               }
10288         }
10289     }
10290
10291   /* Determine where the call point is.  */
10292   location = (input_sec->output_offset
10293               + input_sec->output_section->vma
10294               + rel->r_offset);
10295
10296   branch_offset = destination - location;
10297   r_type = ELF64_R_TYPE (rel->r_info);
10298
10299   /* Determine if a long branch stub is needed.  */
10300   max_branch_offset = 1 << 25;
10301   if (r_type != R_PPC64_REL24)
10302     max_branch_offset = 1 << 15;
10303
10304   if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10305     /* We need a stub.  Figure out whether a long_branch or plt_branch
10306        is needed later.  */
10307     return ppc_stub_long_branch;
10308
10309   return ppc_stub_none;
10310 }
10311
10312 /* With power7 weakly ordered memory model, it is possible for ld.so
10313    to update a plt entry in one thread and have another thread see a
10314    stale zero toc entry.  To avoid this we need some sort of acquire
10315    barrier in the call stub.  One solution is to make the load of the
10316    toc word seem to appear to depend on the load of the function entry
10317    word.  Another solution is to test for r2 being zero, and branch to
10318    the appropriate glink entry if so.
10319
10320    .    fake dep barrier        compare
10321    .    ld 12,xxx(2)            ld 12,xxx(2)
10322    .    mtctr 12                mtctr 12
10323    .    xor 11,12,12            ld 2,xxx+8(2)
10324    .    add 2,2,11              cmpldi 2,0
10325    .    ld 2,xxx+8(2)           bnectr+
10326    .    bctr                    b <glink_entry>
10327
10328    The solution involving the compare turns out to be faster, so
10329    that's what we use unless the branch won't reach.  */
10330
10331 #define ALWAYS_USE_FAKE_DEP 0
10332 #define ALWAYS_EMIT_R2SAVE 0
10333
10334 #define PPC_LO(v) ((v) & 0xffff)
10335 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10336 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10337
10338 static inline unsigned int
10339 plt_stub_size (struct ppc_link_hash_table *htab,
10340                struct ppc_stub_hash_entry *stub_entry,
10341                bfd_vma off)
10342 {
10343   unsigned size = 12;
10344
10345   if (ALWAYS_EMIT_R2SAVE
10346       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10347     size += 4;
10348   if (PPC_HA (off) != 0)
10349     size += 4;
10350   if (htab->opd_abi)
10351     {
10352       size += 4;
10353       if (htab->params->plt_static_chain)
10354         size += 4;
10355       if (htab->params->plt_thread_safe
10356           && htab->elf.dynamic_sections_created
10357           && stub_entry->h != NULL
10358           && stub_entry->h->elf.dynindx != -1)
10359         size += 8;
10360       if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
10361         size += 4;
10362     }
10363   if (stub_entry->h != NULL
10364       && (stub_entry->h == htab->tls_get_addr_fd
10365           || stub_entry->h == htab->tls_get_addr)
10366       && htab->params->tls_get_addr_opt)
10367     size += 13 * 4;
10368   return size;
10369 }
10370
10371 /* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
10372    then return the padding needed to do so.  */
10373 static inline unsigned int
10374 plt_stub_pad (struct ppc_link_hash_table *htab,
10375               struct ppc_stub_hash_entry *stub_entry,
10376               bfd_vma plt_off)
10377 {
10378   int stub_align = 1 << htab->params->plt_stub_align;
10379   unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10380   bfd_vma stub_off = stub_entry->group->stub_sec->size;
10381
10382   if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10383       > ((stub_size - 1) & -stub_align))
10384     return stub_align - (stub_off & (stub_align - 1));
10385   return 0;
10386 }
10387
10388 /* Build a .plt call stub.  */
10389
10390 static inline bfd_byte *
10391 build_plt_stub (struct ppc_link_hash_table *htab,
10392                 struct ppc_stub_hash_entry *stub_entry,
10393                 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10394 {
10395   bfd *obfd = htab->params->stub_bfd;
10396   bfd_boolean plt_load_toc = htab->opd_abi;
10397   bfd_boolean plt_static_chain = htab->params->plt_static_chain;
10398   bfd_boolean plt_thread_safe = (htab->params->plt_thread_safe
10399                                  && htab->elf.dynamic_sections_created
10400                                  && stub_entry->h != NULL
10401                                  && stub_entry->h->elf.dynindx != -1);
10402   bfd_boolean use_fake_dep = plt_thread_safe;
10403   bfd_vma cmp_branch_off = 0;
10404
10405   if (!ALWAYS_USE_FAKE_DEP
10406       && plt_load_toc
10407       && plt_thread_safe
10408       && !((stub_entry->h == htab->tls_get_addr_fd
10409             || stub_entry->h == htab->tls_get_addr)
10410            && htab->params->tls_get_addr_opt))
10411     {
10412       bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10413       bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10414                           / PLT_ENTRY_SIZE (htab));
10415       bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10416       bfd_vma to, from;
10417
10418       if (pltindex > 32768)
10419         glinkoff += (pltindex - 32768) * 4;
10420       to = (glinkoff
10421             + htab->glink->output_offset
10422             + htab->glink->output_section->vma);
10423       from = (p - stub_entry->group->stub_sec->contents
10424               + 4 * (ALWAYS_EMIT_R2SAVE
10425                      || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10426               + 4 * (PPC_HA (offset) != 0)
10427               + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10428                      != PPC_HA (offset))
10429               + 4 * (plt_static_chain != 0)
10430               + 20
10431               + stub_entry->group->stub_sec->output_offset
10432               + stub_entry->group->stub_sec->output_section->vma);
10433       cmp_branch_off = to - from;
10434       use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10435     }
10436
10437   if (PPC_HA (offset) != 0)
10438     {
10439       if (r != NULL)
10440         {
10441           if (ALWAYS_EMIT_R2SAVE
10442               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10443             r[0].r_offset += 4;
10444           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10445           r[1].r_offset = r[0].r_offset + 4;
10446           r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10447           r[1].r_addend = r[0].r_addend;
10448           if (plt_load_toc)
10449             {
10450               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10451                 {
10452                   r[2].r_offset = r[1].r_offset + 4;
10453                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10454                   r[2].r_addend = r[0].r_addend;
10455                 }
10456               else
10457                 {
10458                   r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10459                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10460                   r[2].r_addend = r[0].r_addend + 8;
10461                   if (plt_static_chain)
10462                     {
10463                       r[3].r_offset = r[2].r_offset + 4;
10464                       r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10465                       r[3].r_addend = r[0].r_addend + 16;
10466                     }
10467                 }
10468             }
10469         }
10470       if (ALWAYS_EMIT_R2SAVE
10471           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10472         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10473       if (plt_load_toc)
10474         {
10475           bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10476           bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p),  p += 4;
10477         }
10478       else
10479         {
10480           bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
10481           bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p),  p += 4;
10482         }
10483       if (plt_load_toc
10484           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10485         {
10486           bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10487           offset = 0;
10488         }
10489       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10490       if (plt_load_toc)
10491         {
10492           if (use_fake_dep)
10493             {
10494               bfd_put_32 (obfd, XOR_R2_R12_R12, p),             p += 4;
10495               bfd_put_32 (obfd, ADD_R11_R11_R2, p),             p += 4;
10496             }
10497           bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10498           if (plt_static_chain)
10499             bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10500         }
10501     }
10502   else
10503     {
10504       if (r != NULL)
10505         {
10506           if (ALWAYS_EMIT_R2SAVE
10507               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10508             r[0].r_offset += 4;
10509           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10510           if (plt_load_toc)
10511             {
10512               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10513                 {
10514                   r[1].r_offset = r[0].r_offset + 4;
10515                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10516                   r[1].r_addend = r[0].r_addend;
10517                 }
10518               else
10519                 {
10520                   r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10521                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10522                   r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10523                   if (plt_static_chain)
10524                     {
10525                       r[2].r_offset = r[1].r_offset + 4;
10526                       r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10527                       r[2].r_addend = r[0].r_addend + 8;
10528                     }
10529                 }
10530             }
10531         }
10532       if (ALWAYS_EMIT_R2SAVE
10533           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10534         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10535       bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p),       p += 4;
10536       if (plt_load_toc
10537           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10538         {
10539           bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),   p += 4;
10540           offset = 0;
10541         }
10542       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10543       if (plt_load_toc)
10544         {
10545           if (use_fake_dep)
10546             {
10547               bfd_put_32 (obfd, XOR_R11_R12_R12, p),            p += 4;
10548               bfd_put_32 (obfd, ADD_R2_R2_R11, p),              p += 4;
10549             }
10550           if (plt_static_chain)
10551             bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10552           bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10553         }
10554     }
10555   if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10556     {
10557       bfd_put_32 (obfd, CMPLDI_R2_0, p),                        p += 4;
10558       bfd_put_32 (obfd, BNECTR_P4, p),                          p += 4;
10559       bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10560     }
10561   else
10562     bfd_put_32 (obfd, BCTR, p),                                 p += 4;
10563   return p;
10564 }
10565
10566 /* Build a special .plt call stub for __tls_get_addr.  */
10567
10568 #define LD_R11_0R3      0xe9630000
10569 #define LD_R12_0R3      0xe9830000
10570 #define MR_R0_R3        0x7c601b78
10571 #define CMPDI_R11_0     0x2c2b0000
10572 #define ADD_R3_R12_R13  0x7c6c6a14
10573 #define BEQLR           0x4d820020
10574 #define MR_R3_R0        0x7c030378
10575 #define STD_R11_0R1     0xf9610000
10576 #define BCTRL           0x4e800421
10577 #define LD_R11_0R1      0xe9610000
10578 #define MTLR_R11        0x7d6803a6
10579
10580 static inline bfd_byte *
10581 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10582                          struct ppc_stub_hash_entry *stub_entry,
10583                          bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10584 {
10585   bfd *obfd = htab->params->stub_bfd;
10586
10587   bfd_put_32 (obfd, LD_R11_0R3 + 0, p),         p += 4;
10588   bfd_put_32 (obfd, LD_R12_0R3 + 8, p),         p += 4;
10589   bfd_put_32 (obfd, MR_R0_R3, p),               p += 4;
10590   bfd_put_32 (obfd, CMPDI_R11_0, p),            p += 4;
10591   bfd_put_32 (obfd, ADD_R3_R12_R13, p),         p += 4;
10592   bfd_put_32 (obfd, BEQLR, p),                  p += 4;
10593   bfd_put_32 (obfd, MR_R3_R0, p),               p += 4;
10594   bfd_put_32 (obfd, MFLR_R11, p),               p += 4;
10595   bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10596
10597   if (r != NULL)
10598     r[0].r_offset += 9 * 4;
10599   p = build_plt_stub (htab, stub_entry, p, offset, r);
10600   bfd_put_32 (obfd, BCTRL, p - 4);
10601
10602   bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p),     p += 4;
10603   bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10604   bfd_put_32 (obfd, MTLR_R11, p),               p += 4;
10605   bfd_put_32 (obfd, BLR, p),                    p += 4;
10606
10607   return p;
10608 }
10609
10610 static Elf_Internal_Rela *
10611 get_relocs (asection *sec, int count)
10612 {
10613   Elf_Internal_Rela *relocs;
10614   struct bfd_elf_section_data *elfsec_data;
10615
10616   elfsec_data = elf_section_data (sec);
10617   relocs = elfsec_data->relocs;
10618   if (relocs == NULL)
10619     {
10620       bfd_size_type relsize;
10621       relsize = sec->reloc_count * sizeof (*relocs);
10622       relocs = bfd_alloc (sec->owner, relsize);
10623       if (relocs == NULL)
10624         return NULL;
10625       elfsec_data->relocs = relocs;
10626       elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10627                                           sizeof (Elf_Internal_Shdr));
10628       if (elfsec_data->rela.hdr == NULL)
10629         return NULL;
10630       elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10631                                         * sizeof (Elf64_External_Rela));
10632       elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10633       sec->reloc_count = 0;
10634     }
10635   relocs += sec->reloc_count;
10636   sec->reloc_count += count;
10637   return relocs;
10638 }
10639
10640 static bfd_vma
10641 get_r2off (struct bfd_link_info *info,
10642            struct ppc_stub_hash_entry *stub_entry)
10643 {
10644   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10645   bfd_vma r2off = htab->sec_info[stub_entry->target_section->id].toc_off;
10646
10647   if (r2off == 0)
10648     {
10649       /* Support linking -R objects.  Get the toc pointer from the
10650          opd entry.  */
10651       char buf[8];
10652       if (!htab->opd_abi)
10653         return r2off;
10654       asection *opd = stub_entry->h->elf.root.u.def.section;
10655       bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10656
10657       if (strcmp (opd->name, ".opd") != 0
10658           || opd->reloc_count != 0)
10659         {
10660           info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
10661                                   stub_entry->h->elf.root.root.string);
10662           bfd_set_error (bfd_error_bad_value);
10663           return (bfd_vma) -1;
10664         }
10665       if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10666         return (bfd_vma) -1;
10667       r2off = bfd_get_64 (opd->owner, buf);
10668       r2off -= elf_gp (info->output_bfd);
10669     }
10670   r2off -= htab->sec_info[stub_entry->group->link_sec->id].toc_off;
10671   return r2off;
10672 }
10673
10674 static bfd_boolean
10675 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10676 {
10677   struct ppc_stub_hash_entry *stub_entry;
10678   struct ppc_branch_hash_entry *br_entry;
10679   struct bfd_link_info *info;
10680   struct ppc_link_hash_table *htab;
10681   bfd_byte *loc;
10682   bfd_byte *p;
10683   bfd_vma dest, off;
10684   int size;
10685   Elf_Internal_Rela *r;
10686   asection *plt;
10687
10688   /* Massage our args to the form they really have.  */
10689   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10690   info = in_arg;
10691
10692   htab = ppc_hash_table (info);
10693   if (htab == NULL)
10694     return FALSE;
10695
10696   /* Make a note of the offset within the stubs for this entry.  */
10697   stub_entry->stub_offset = stub_entry->group->stub_sec->size;
10698   loc = stub_entry->group->stub_sec->contents + stub_entry->stub_offset;
10699
10700   htab->stub_count[stub_entry->stub_type - 1] += 1;
10701   switch (stub_entry->stub_type)
10702     {
10703     case ppc_stub_long_branch:
10704     case ppc_stub_long_branch_r2off:
10705       /* Branches are relative.  This is where we are going to.  */
10706       dest = (stub_entry->target_value
10707               + stub_entry->target_section->output_offset
10708               + stub_entry->target_section->output_section->vma);
10709       dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10710       off = dest;
10711
10712       /* And this is where we are coming from.  */
10713       off -= (stub_entry->stub_offset
10714               + stub_entry->group->stub_sec->output_offset
10715               + stub_entry->group->stub_sec->output_section->vma);
10716
10717       size = 4;
10718       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10719         {
10720           bfd_vma r2off = get_r2off (info, stub_entry);
10721
10722           if (r2off == (bfd_vma) -1)
10723             {
10724               htab->stub_error = TRUE;
10725               return FALSE;
10726             }
10727           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10728           loc += 4;
10729           size = 8;
10730           if (PPC_HA (r2off) != 0)
10731             {
10732               bfd_put_32 (htab->params->stub_bfd,
10733                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
10734               loc += 4;
10735               size += 4;
10736             }
10737           if (PPC_LO (r2off) != 0)
10738             {
10739               bfd_put_32 (htab->params->stub_bfd,
10740                           ADDI_R2_R2 | PPC_LO (r2off), loc);
10741               loc += 4;
10742               size += 4;
10743             }
10744           off -= size - 4;
10745         }
10746       bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10747
10748       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10749         {
10750           info->callbacks->einfo
10751             (_("%P: long branch stub `%s' offset overflow\n"),
10752              stub_entry->root.string);
10753           htab->stub_error = TRUE;
10754           return FALSE;
10755         }
10756
10757       if (info->emitrelocations)
10758         {
10759           r = get_relocs (stub_entry->group->stub_sec, 1);
10760           if (r == NULL)
10761             return FALSE;
10762           r->r_offset = loc - stub_entry->group->stub_sec->contents;
10763           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10764           r->r_addend = dest;
10765           if (stub_entry->h != NULL)
10766             {
10767               struct elf_link_hash_entry **hashes;
10768               unsigned long symndx;
10769               struct ppc_link_hash_entry *h;
10770
10771               hashes = elf_sym_hashes (htab->params->stub_bfd);
10772               if (hashes == NULL)
10773                 {
10774                   bfd_size_type hsize;
10775
10776                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10777                   hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
10778                   if (hashes == NULL)
10779                     return FALSE;
10780                   elf_sym_hashes (htab->params->stub_bfd) = hashes;
10781                   htab->stub_globals = 1;
10782                 }
10783               symndx = htab->stub_globals++;
10784               h = stub_entry->h;
10785               hashes[symndx] = &h->elf;
10786               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10787               if (h->oh != NULL && h->oh->is_func)
10788                 h = ppc_follow_link (h->oh);
10789               if (h->elf.root.u.def.section != stub_entry->target_section)
10790                 /* H is an opd symbol.  The addend must be zero.  */
10791                 r->r_addend = 0;
10792               else
10793                 {
10794                   off = (h->elf.root.u.def.value
10795                          + h->elf.root.u.def.section->output_offset
10796                          + h->elf.root.u.def.section->output_section->vma);
10797                   r->r_addend -= off;
10798                 }
10799             }
10800         }
10801       break;
10802
10803     case ppc_stub_plt_branch:
10804     case ppc_stub_plt_branch_r2off:
10805       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10806                                          stub_entry->root.string + 9,
10807                                          FALSE, FALSE);
10808       if (br_entry == NULL)
10809         {
10810           info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
10811                                   stub_entry->root.string);
10812           htab->stub_error = TRUE;
10813           return FALSE;
10814         }
10815
10816       dest = (stub_entry->target_value
10817               + stub_entry->target_section->output_offset
10818               + stub_entry->target_section->output_section->vma);
10819       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10820         dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10821
10822       bfd_put_64 (htab->brlt->owner, dest,
10823                   htab->brlt->contents + br_entry->offset);
10824
10825       if (br_entry->iter == htab->stub_iteration)
10826         {
10827           br_entry->iter = 0;
10828
10829           if (htab->relbrlt != NULL)
10830             {
10831               /* Create a reloc for the branch lookup table entry.  */
10832               Elf_Internal_Rela rela;
10833               bfd_byte *rl;
10834
10835               rela.r_offset = (br_entry->offset
10836                                + htab->brlt->output_offset
10837                                + htab->brlt->output_section->vma);
10838               rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10839               rela.r_addend = dest;
10840
10841               rl = htab->relbrlt->contents;
10842               rl += (htab->relbrlt->reloc_count++
10843                      * sizeof (Elf64_External_Rela));
10844               bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
10845             }
10846           else if (info->emitrelocations)
10847             {
10848               r = get_relocs (htab->brlt, 1);
10849               if (r == NULL)
10850                 return FALSE;
10851               /* brlt, being SEC_LINKER_CREATED does not go through the
10852                  normal reloc processing.  Symbols and offsets are not
10853                  translated from input file to output file form, so
10854                  set up the offset per the output file.  */
10855               r->r_offset = (br_entry->offset
10856                              + htab->brlt->output_offset
10857                              + htab->brlt->output_section->vma);
10858               r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10859               r->r_addend = dest;
10860             }
10861         }
10862
10863       dest = (br_entry->offset
10864               + htab->brlt->output_offset
10865               + htab->brlt->output_section->vma);
10866
10867       off = (dest
10868              - elf_gp (htab->brlt->output_section->owner)
10869              - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
10870
10871       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10872         {
10873           info->callbacks->einfo
10874             (_("%P: linkage table error against `%T'\n"),
10875              stub_entry->root.string);
10876           bfd_set_error (bfd_error_bad_value);
10877           htab->stub_error = TRUE;
10878           return FALSE;
10879         }
10880
10881       if (info->emitrelocations)
10882         {
10883           r = get_relocs (stub_entry->group->stub_sec, 1 + (PPC_HA (off) != 0));
10884           if (r == NULL)
10885             return FALSE;
10886           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
10887           if (bfd_big_endian (info->output_bfd))
10888             r[0].r_offset += 2;
10889           if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
10890             r[0].r_offset += 4;
10891           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10892           r[0].r_addend = dest;
10893           if (PPC_HA (off) != 0)
10894             {
10895               r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10896               r[1].r_offset = r[0].r_offset + 4;
10897               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10898               r[1].r_addend = r[0].r_addend;
10899             }
10900         }
10901
10902       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10903         {
10904           if (PPC_HA (off) != 0)
10905             {
10906               size = 16;
10907               bfd_put_32 (htab->params->stub_bfd,
10908                           ADDIS_R12_R2 | PPC_HA (off), loc);
10909               loc += 4;
10910               bfd_put_32 (htab->params->stub_bfd,
10911                           LD_R12_0R12 | PPC_LO (off), loc);
10912             }
10913           else
10914             {
10915               size = 12;
10916               bfd_put_32 (htab->params->stub_bfd,
10917                           LD_R12_0R2 | PPC_LO (off), loc);
10918             }
10919         }
10920       else
10921         {
10922           bfd_vma r2off = get_r2off (info, stub_entry);
10923
10924           if (r2off == (bfd_vma) -1)
10925             {
10926               htab->stub_error = TRUE;
10927               return FALSE;
10928             }
10929
10930           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10931           loc += 4;
10932           size = 16;
10933           if (PPC_HA (off) != 0)
10934             {
10935               size += 4;
10936               bfd_put_32 (htab->params->stub_bfd,
10937                           ADDIS_R12_R2 | PPC_HA (off), loc);
10938               loc += 4;
10939               bfd_put_32 (htab->params->stub_bfd,
10940                           LD_R12_0R12 | PPC_LO (off), loc);
10941             }
10942           else
10943             bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
10944
10945           if (PPC_HA (r2off) != 0)
10946             {
10947               size += 4;
10948               loc += 4;
10949               bfd_put_32 (htab->params->stub_bfd,
10950                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
10951             }
10952           if (PPC_LO (r2off) != 0)
10953             {
10954               size += 4;
10955               loc += 4;
10956               bfd_put_32 (htab->params->stub_bfd,
10957                           ADDI_R2_R2 | PPC_LO (r2off), loc);
10958             }
10959         }
10960       loc += 4;
10961       bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, loc);
10962       loc += 4;
10963       bfd_put_32 (htab->params->stub_bfd, BCTR, loc);
10964       break;
10965
10966     case ppc_stub_plt_call:
10967     case ppc_stub_plt_call_r2save:
10968       if (stub_entry->h != NULL
10969           && stub_entry->h->is_func_descriptor
10970           && stub_entry->h->oh != NULL)
10971         {
10972           struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
10973
10974           /* If the old-ABI "dot-symbol" is undefined make it weak so
10975              we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.  */
10976           if (fh->elf.root.type == bfd_link_hash_undefined)
10977             fh->elf.root.type = bfd_link_hash_undefweak;
10978           /* Stop undo_symbol_twiddle changing it back to undefined.  */
10979           fh->was_undefined = 0;
10980         }
10981
10982       /* Now build the stub.  */
10983       dest = stub_entry->plt_ent->plt.offset & ~1;
10984       if (dest >= (bfd_vma) -2)
10985         abort ();
10986
10987       plt = htab->elf.splt;
10988       if (!htab->elf.dynamic_sections_created
10989           || stub_entry->h == NULL
10990           || stub_entry->h->elf.dynindx == -1)
10991         plt = htab->elf.iplt;
10992
10993       dest += plt->output_offset + plt->output_section->vma;
10994
10995       if (stub_entry->h == NULL
10996           && (stub_entry->plt_ent->plt.offset & 1) == 0)
10997         {
10998           Elf_Internal_Rela rela;
10999           bfd_byte *rl;
11000
11001           rela.r_offset = dest;
11002           if (htab->opd_abi)
11003             rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
11004           else
11005             rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
11006           rela.r_addend = (stub_entry->target_value
11007                            + stub_entry->target_section->output_offset
11008                            + stub_entry->target_section->output_section->vma);
11009
11010           rl = (htab->elf.irelplt->contents
11011                 + (htab->elf.irelplt->reloc_count++
11012                    * sizeof (Elf64_External_Rela)));
11013           bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
11014           stub_entry->plt_ent->plt.offset |= 1;
11015         }
11016
11017       off = (dest
11018              - elf_gp (plt->output_section->owner)
11019              - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11020
11021       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11022         {
11023           info->callbacks->einfo
11024             (_("%P: linkage table error against `%T'\n"),
11025              stub_entry->h != NULL
11026              ? stub_entry->h->elf.root.root.string
11027              : "<local sym>");
11028           bfd_set_error (bfd_error_bad_value);
11029           htab->stub_error = TRUE;
11030           return FALSE;
11031         }
11032
11033       if (htab->params->plt_stub_align != 0)
11034         {
11035           unsigned pad = plt_stub_pad (htab, stub_entry, off);
11036
11037           stub_entry->group->stub_sec->size += pad;
11038           stub_entry->stub_offset = stub_entry->group->stub_sec->size;
11039           loc += pad;
11040         }
11041
11042       r = NULL;
11043       if (info->emitrelocations)
11044         {
11045           r = get_relocs (stub_entry->group->stub_sec,
11046                           ((PPC_HA (off) != 0)
11047                            + (htab->opd_abi
11048                               ? 2 + (htab->params->plt_static_chain
11049                                      && PPC_HA (off + 16) == PPC_HA (off))
11050                               : 1)));
11051           if (r == NULL)
11052             return FALSE;
11053           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11054           if (bfd_big_endian (info->output_bfd))
11055             r[0].r_offset += 2;
11056           r[0].r_addend = dest;
11057         }
11058       if (stub_entry->h != NULL
11059           && (stub_entry->h == htab->tls_get_addr_fd
11060               || stub_entry->h == htab->tls_get_addr)
11061           && htab->params->tls_get_addr_opt)
11062         p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
11063       else
11064         p = build_plt_stub (htab, stub_entry, loc, off, r);
11065       size = p - loc;
11066       break;
11067
11068     case ppc_stub_save_res:
11069       return TRUE;
11070
11071     default:
11072       BFD_FAIL ();
11073       return FALSE;
11074     }
11075
11076   stub_entry->group->stub_sec->size += size;
11077
11078   if (htab->params->emit_stub_syms)
11079     {
11080       struct elf_link_hash_entry *h;
11081       size_t len1, len2;
11082       char *name;
11083       const char *const stub_str[] = { "long_branch",
11084                                        "long_branch_r2off",
11085                                        "plt_branch",
11086                                        "plt_branch_r2off",
11087                                        "plt_call",
11088                                        "plt_call" };
11089
11090       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
11091       len2 = strlen (stub_entry->root.string);
11092       name = bfd_malloc (len1 + len2 + 2);
11093       if (name == NULL)
11094         return FALSE;
11095       memcpy (name, stub_entry->root.string, 9);
11096       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
11097       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
11098       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
11099       if (h == NULL)
11100         return FALSE;
11101       if (h->root.type == bfd_link_hash_new)
11102         {
11103           h->root.type = bfd_link_hash_defined;
11104           h->root.u.def.section = stub_entry->group->stub_sec;
11105           h->root.u.def.value = stub_entry->stub_offset;
11106           h->ref_regular = 1;
11107           h->def_regular = 1;
11108           h->ref_regular_nonweak = 1;
11109           h->forced_local = 1;
11110           h->non_elf = 0;
11111           h->root.linker_def = 1;
11112         }
11113     }
11114
11115   return TRUE;
11116 }
11117
11118 /* As above, but don't actually build the stub.  Just bump offset so
11119    we know stub section sizes, and select plt_branch stubs where
11120    long_branch stubs won't do.  */
11121
11122 static bfd_boolean
11123 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11124 {
11125   struct ppc_stub_hash_entry *stub_entry;
11126   struct bfd_link_info *info;
11127   struct ppc_link_hash_table *htab;
11128   bfd_vma off;
11129   int size;
11130
11131   /* Massage our args to the form they really have.  */
11132   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11133   info = in_arg;
11134
11135   htab = ppc_hash_table (info);
11136   if (htab == NULL)
11137     return FALSE;
11138
11139   if (stub_entry->h != NULL
11140       && stub_entry->h->save_res
11141       && stub_entry->h->elf.root.type == bfd_link_hash_defined
11142       && stub_entry->h->elf.root.u.def.section == htab->sfpr)
11143     {
11144       /* Don't make stubs to out-of-line register save/restore
11145          functions.  Instead, emit copies of the functions.  */
11146       stub_entry->group->needs_save_res = 1;
11147       stub_entry->stub_type = ppc_stub_save_res;
11148       return TRUE;
11149     }
11150
11151   if (stub_entry->stub_type == ppc_stub_plt_call
11152       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11153     {
11154       asection *plt;
11155       off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
11156       if (off >= (bfd_vma) -2)
11157         abort ();
11158       plt = htab->elf.splt;
11159       if (!htab->elf.dynamic_sections_created
11160           || stub_entry->h == NULL
11161           || stub_entry->h->elf.dynindx == -1)
11162         plt = htab->elf.iplt;
11163       off += (plt->output_offset
11164               + plt->output_section->vma
11165               - elf_gp (plt->output_section->owner)
11166               - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11167
11168       size = plt_stub_size (htab, stub_entry, off);
11169       if (htab->params->plt_stub_align)
11170         size += plt_stub_pad (htab, stub_entry, off);
11171       if (info->emitrelocations)
11172         {
11173           stub_entry->group->stub_sec->reloc_count
11174             += ((PPC_HA (off) != 0)
11175                 + (htab->opd_abi
11176                    ? 2 + (htab->params->plt_static_chain
11177                           && PPC_HA (off + 16) == PPC_HA (off))
11178                    : 1));
11179           stub_entry->group->stub_sec->flags |= SEC_RELOC;
11180         }
11181     }
11182   else
11183     {
11184       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
11185          variants.  */
11186       bfd_vma r2off = 0;
11187       bfd_vma local_off = 0;
11188
11189       off = (stub_entry->target_value
11190              + stub_entry->target_section->output_offset
11191              + stub_entry->target_section->output_section->vma);
11192       off -= (stub_entry->group->stub_sec->size
11193               + stub_entry->group->stub_sec->output_offset
11194               + stub_entry->group->stub_sec->output_section->vma);
11195
11196       /* Reset the stub type from the plt variant in case we now
11197          can reach with a shorter stub.  */
11198       if (stub_entry->stub_type >= ppc_stub_plt_branch)
11199         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
11200
11201       size = 4;
11202       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11203         {
11204           r2off = get_r2off (info, stub_entry);
11205           if (r2off == (bfd_vma) -1)
11206             {
11207               htab->stub_error = TRUE;
11208               return FALSE;
11209             }
11210           size = 8;
11211           if (PPC_HA (r2off) != 0)
11212             size += 4;
11213           if (PPC_LO (r2off) != 0)
11214             size += 4;
11215           off -= size - 4;
11216         }
11217
11218       local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11219
11220       /* If the branch offset if too big, use a ppc_stub_plt_branch.
11221          Do the same for -R objects without function descriptors.  */
11222       if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
11223           || (stub_entry->stub_type == ppc_stub_long_branch_r2off
11224               && r2off == 0
11225               && htab->sec_info[stub_entry->target_section->id].toc_off == 0))
11226         {
11227           struct ppc_branch_hash_entry *br_entry;
11228
11229           br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11230                                              stub_entry->root.string + 9,
11231                                              TRUE, FALSE);
11232           if (br_entry == NULL)
11233             {
11234               info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
11235                                       stub_entry->root.string);
11236               htab->stub_error = TRUE;
11237               return FALSE;
11238             }
11239
11240           if (br_entry->iter != htab->stub_iteration)
11241             {
11242               br_entry->iter = htab->stub_iteration;
11243               br_entry->offset = htab->brlt->size;
11244               htab->brlt->size += 8;
11245
11246               if (htab->relbrlt != NULL)
11247                 htab->relbrlt->size += sizeof (Elf64_External_Rela);
11248               else if (info->emitrelocations)
11249                 {
11250                   htab->brlt->reloc_count += 1;
11251                   htab->brlt->flags |= SEC_RELOC;
11252                 }
11253             }
11254
11255           stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
11256           off = (br_entry->offset
11257                  + htab->brlt->output_offset
11258                  + htab->brlt->output_section->vma
11259                  - elf_gp (htab->brlt->output_section->owner)
11260                  - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11261
11262           if (info->emitrelocations)
11263             {
11264               stub_entry->group->stub_sec->reloc_count
11265                 += 1 + (PPC_HA (off) != 0);
11266               stub_entry->group->stub_sec->flags |= SEC_RELOC;
11267             }
11268
11269           if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11270             {
11271               size = 12;
11272               if (PPC_HA (off) != 0)
11273                 size = 16;
11274             }
11275           else
11276             {
11277               size = 16;
11278               if (PPC_HA (off) != 0)
11279                 size += 4;
11280
11281               if (PPC_HA (r2off) != 0)
11282                 size += 4;
11283               if (PPC_LO (r2off) != 0)
11284                 size += 4;
11285             }
11286         }
11287       else if (info->emitrelocations)
11288         {
11289           stub_entry->group->stub_sec->reloc_count += 1;
11290           stub_entry->group->stub_sec->flags |= SEC_RELOC;
11291         }
11292     }
11293
11294   stub_entry->group->stub_sec->size += size;
11295   return TRUE;
11296 }
11297
11298 /* Set up various things so that we can make a list of input sections
11299    for each output section included in the link.  Returns -1 on error,
11300    0 when no stubs will be needed, and 1 on success.  */
11301
11302 int
11303 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
11304 {
11305   unsigned int id;
11306   bfd_size_type amt;
11307   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11308
11309   if (htab == NULL)
11310     return -1;
11311
11312   htab->sec_info_arr_size = bfd_get_next_section_id ();
11313   amt = sizeof (*htab->sec_info) * (htab->sec_info_arr_size);
11314   htab->sec_info = bfd_zmalloc (amt);
11315   if (htab->sec_info == NULL)
11316     return -1;
11317
11318   /* Set toc_off for com, und, abs and ind sections.  */
11319   for (id = 0; id < 3; id++)
11320     htab->sec_info[id].toc_off = TOC_BASE_OFF;
11321
11322   return 1;
11323 }
11324
11325 /* Set up for first pass at multitoc partitioning.  */
11326
11327 void
11328 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11329 {
11330   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11331
11332   htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11333   htab->toc_bfd = NULL;
11334   htab->toc_first_sec = NULL;
11335 }
11336
11337 /* The linker repeatedly calls this function for each TOC input section
11338    and linker generated GOT section.  Group input bfds such that the toc
11339    within a group is less than 64k in size.  */
11340
11341 bfd_boolean
11342 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11343 {
11344   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11345   bfd_vma addr, off, limit;
11346
11347   if (htab == NULL)
11348     return FALSE;
11349
11350   if (!htab->second_toc_pass)
11351     {
11352       /* Keep track of the first .toc or .got section for this input bfd.  */
11353       bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11354
11355       if (new_bfd)
11356         {
11357           htab->toc_bfd = isec->owner;
11358           htab->toc_first_sec = isec;
11359         }
11360
11361       addr = isec->output_offset + isec->output_section->vma;
11362       off = addr - htab->toc_curr;
11363       limit = 0x80008000;
11364       if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11365         limit = 0x10000;
11366       if (off + isec->size > limit)
11367         {
11368           addr = (htab->toc_first_sec->output_offset
11369                   + htab->toc_first_sec->output_section->vma);
11370           htab->toc_curr = addr;
11371           htab->toc_curr &= -TOC_BASE_ALIGN;
11372         }
11373
11374       /* toc_curr is the base address of this toc group.  Set elf_gp
11375          for the input section to be the offset relative to the
11376          output toc base plus 0x8000.  Making the input elf_gp an
11377          offset allows us to move the toc as a whole without
11378          recalculating input elf_gp.  */
11379       off = htab->toc_curr - elf_gp (isec->output_section->owner);
11380       off += TOC_BASE_OFF;
11381
11382       /* Die if someone uses a linker script that doesn't keep input
11383          file .toc and .got together.  */
11384       if (new_bfd
11385           && elf_gp (isec->owner) != 0
11386           && elf_gp (isec->owner) != off)
11387         return FALSE;
11388
11389       elf_gp (isec->owner) = off;
11390       return TRUE;
11391     }
11392
11393   /* During the second pass toc_first_sec points to the start of
11394      a toc group, and toc_curr is used to track the old elf_gp.
11395      We use toc_bfd to ensure we only look at each bfd once.  */
11396   if (htab->toc_bfd == isec->owner)
11397     return TRUE;
11398   htab->toc_bfd = isec->owner;
11399
11400   if (htab->toc_first_sec == NULL
11401       || htab->toc_curr != elf_gp (isec->owner))
11402     {
11403       htab->toc_curr = elf_gp (isec->owner);
11404       htab->toc_first_sec = isec;
11405     }
11406   addr = (htab->toc_first_sec->output_offset
11407           + htab->toc_first_sec->output_section->vma);
11408   off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
11409   elf_gp (isec->owner) = off;
11410
11411   return TRUE;
11412 }
11413
11414 /* Called via elf_link_hash_traverse to merge GOT entries for global
11415    symbol H.  */
11416
11417 static bfd_boolean
11418 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11419 {
11420   if (h->root.type == bfd_link_hash_indirect)
11421     return TRUE;
11422
11423   merge_got_entries (&h->got.glist);
11424
11425   return TRUE;
11426 }
11427
11428 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11429    symbol H.  */
11430
11431 static bfd_boolean
11432 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11433 {
11434   struct got_entry *gent;
11435
11436   if (h->root.type == bfd_link_hash_indirect)
11437     return TRUE;
11438
11439   for (gent = h->got.glist; gent != NULL; gent = gent->next)
11440     if (!gent->is_indirect)
11441       allocate_got (h, (struct bfd_link_info *) inf, gent);
11442   return TRUE;
11443 }
11444
11445 /* Called on the first multitoc pass after the last call to
11446    ppc64_elf_next_toc_section.  This function removes duplicate GOT
11447    entries.  */
11448
11449 bfd_boolean
11450 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11451 {
11452   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11453   struct bfd *ibfd, *ibfd2;
11454   bfd_boolean done_something;
11455
11456   htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11457
11458   if (!htab->do_multi_toc)
11459     return FALSE;
11460
11461   /* Merge global sym got entries within a toc group.  */
11462   elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11463
11464   /* And tlsld_got.  */
11465   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11466     {
11467       struct got_entry *ent, *ent2;
11468
11469       if (!is_ppc64_elf (ibfd))
11470         continue;
11471
11472       ent = ppc64_tlsld_got (ibfd);
11473       if (!ent->is_indirect
11474           && ent->got.offset != (bfd_vma) -1)
11475         {
11476           for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
11477             {
11478               if (!is_ppc64_elf (ibfd2))
11479                 continue;
11480
11481               ent2 = ppc64_tlsld_got (ibfd2);
11482               if (!ent2->is_indirect
11483                   && ent2->got.offset != (bfd_vma) -1
11484                   && elf_gp (ibfd2) == elf_gp (ibfd))
11485                 {
11486                   ent2->is_indirect = TRUE;
11487                   ent2->got.ent = ent;
11488                 }
11489             }
11490         }
11491     }
11492
11493   /* Zap sizes of got sections.  */
11494   htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11495   htab->elf.irelplt->size -= htab->got_reli_size;
11496   htab->got_reli_size = 0;
11497
11498   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11499     {
11500       asection *got, *relgot;
11501
11502       if (!is_ppc64_elf (ibfd))
11503         continue;
11504
11505       got = ppc64_elf_tdata (ibfd)->got;
11506       if (got != NULL)
11507         {
11508           got->rawsize = got->size;
11509           got->size = 0;
11510           relgot = ppc64_elf_tdata (ibfd)->relgot;
11511           relgot->rawsize = relgot->size;
11512           relgot->size = 0;
11513         }
11514     }
11515
11516   /* Now reallocate the got, local syms first.  We don't need to
11517      allocate section contents again since we never increase size.  */
11518   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11519     {
11520       struct got_entry **lgot_ents;
11521       struct got_entry **end_lgot_ents;
11522       struct plt_entry **local_plt;
11523       struct plt_entry **end_local_plt;
11524       unsigned char *lgot_masks;
11525       bfd_size_type locsymcount;
11526       Elf_Internal_Shdr *symtab_hdr;
11527       asection *s;
11528
11529       if (!is_ppc64_elf (ibfd))
11530         continue;
11531
11532       lgot_ents = elf_local_got_ents (ibfd);
11533       if (!lgot_ents)
11534         continue;
11535
11536       symtab_hdr = &elf_symtab_hdr (ibfd);
11537       locsymcount = symtab_hdr->sh_info;
11538       end_lgot_ents = lgot_ents + locsymcount;
11539       local_plt = (struct plt_entry **) end_lgot_ents;
11540       end_local_plt = local_plt + locsymcount;
11541       lgot_masks = (unsigned char *) end_local_plt;
11542       s = ppc64_elf_tdata (ibfd)->got;
11543       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11544         {
11545           struct got_entry *ent;
11546
11547           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11548             {
11549               unsigned int ent_size = 8;
11550               unsigned int rel_size = sizeof (Elf64_External_Rela);
11551
11552               ent->got.offset = s->size;
11553               if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11554                 {
11555                   ent_size *= 2;
11556                   rel_size *= 2;
11557                 }
11558               s->size += ent_size;
11559               if ((*lgot_masks & PLT_IFUNC) != 0)
11560                 {
11561                   htab->elf.irelplt->size += rel_size;
11562                   htab->got_reli_size += rel_size;
11563                 }
11564               else if (bfd_link_pic (info))
11565                 {
11566                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11567                   srel->size += rel_size;
11568                 }
11569             }
11570         }
11571     }
11572
11573   elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11574
11575   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11576     {
11577       struct got_entry *ent;
11578
11579       if (!is_ppc64_elf (ibfd))
11580         continue;
11581
11582       ent = ppc64_tlsld_got (ibfd);
11583       if (!ent->is_indirect
11584           && ent->got.offset != (bfd_vma) -1)
11585         {
11586           asection *s = ppc64_elf_tdata (ibfd)->got;
11587           ent->got.offset = s->size;
11588           s->size += 16;
11589           if (bfd_link_pic (info))
11590             {
11591               asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11592               srel->size += sizeof (Elf64_External_Rela);
11593             }
11594         }
11595     }
11596
11597   done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11598   if (!done_something)
11599     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11600       {
11601         asection *got;
11602
11603         if (!is_ppc64_elf (ibfd))
11604           continue;
11605
11606         got = ppc64_elf_tdata (ibfd)->got;
11607         if (got != NULL)
11608           {
11609             done_something = got->rawsize != got->size;
11610             if (done_something)
11611               break;
11612           }
11613       }
11614
11615   if (done_something)
11616     (*htab->params->layout_sections_again) ();
11617
11618   /* Set up for second pass over toc sections to recalculate elf_gp
11619      on input sections.  */
11620   htab->toc_bfd = NULL;
11621   htab->toc_first_sec = NULL;
11622   htab->second_toc_pass = TRUE;
11623   return done_something;
11624 }
11625
11626 /* Called after second pass of multitoc partitioning.  */
11627
11628 void
11629 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11630 {
11631   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11632
11633   /* After the second pass, toc_curr tracks the TOC offset used
11634      for code sections below in ppc64_elf_next_input_section.  */
11635   htab->toc_curr = TOC_BASE_OFF;
11636 }
11637
11638 /* No toc references were found in ISEC.  If the code in ISEC makes no
11639    calls, then there's no need to use toc adjusting stubs when branching
11640    into ISEC.  Actually, indirect calls from ISEC are OK as they will
11641    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
11642    needed, and 2 if a cyclical call-graph was found but no other reason
11643    for a stub was detected.  If called from the top level, a return of
11644    2 means the same as a return of 0.  */
11645
11646 static int
11647 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11648 {
11649   int ret;
11650
11651   /* Mark this section as checked.  */
11652   isec->call_check_done = 1;
11653
11654   /* We know none of our code bearing sections will need toc stubs.  */
11655   if ((isec->flags & SEC_LINKER_CREATED) != 0)
11656     return 0;
11657
11658   if (isec->size == 0)
11659     return 0;
11660
11661   if (isec->output_section == NULL)
11662     return 0;
11663
11664   ret = 0;
11665   if (isec->reloc_count != 0)
11666     {
11667       Elf_Internal_Rela *relstart, *rel;
11668       Elf_Internal_Sym *local_syms;
11669       struct ppc_link_hash_table *htab;
11670
11671       relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11672                                             info->keep_memory);
11673       if (relstart == NULL)
11674         return -1;
11675
11676       /* Look for branches to outside of this section.  */
11677       local_syms = NULL;
11678       htab = ppc_hash_table (info);
11679       if (htab == NULL)
11680         return -1;
11681
11682       for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11683         {
11684           enum elf_ppc64_reloc_type r_type;
11685           unsigned long r_symndx;
11686           struct elf_link_hash_entry *h;
11687           struct ppc_link_hash_entry *eh;
11688           Elf_Internal_Sym *sym;
11689           asection *sym_sec;
11690           struct _opd_sec_data *opd;
11691           bfd_vma sym_value;
11692           bfd_vma dest;
11693
11694           r_type = ELF64_R_TYPE (rel->r_info);
11695           if (r_type != R_PPC64_REL24
11696               && r_type != R_PPC64_REL14
11697               && r_type != R_PPC64_REL14_BRTAKEN
11698               && r_type != R_PPC64_REL14_BRNTAKEN)
11699             continue;
11700
11701           r_symndx = ELF64_R_SYM (rel->r_info);
11702           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11703                           isec->owner))
11704             {
11705               ret = -1;
11706               break;
11707             }
11708
11709           /* Calls to dynamic lib functions go through a plt call stub
11710              that uses r2.  */
11711           eh = (struct ppc_link_hash_entry *) h;
11712           if (eh != NULL
11713               && (eh->elf.plt.plist != NULL
11714                   || (eh->oh != NULL
11715                       && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11716             {
11717               ret = 1;
11718               break;
11719             }
11720
11721           if (sym_sec == NULL)
11722             /* Ignore other undefined symbols.  */
11723             continue;
11724
11725           /* Assume branches to other sections not included in the
11726              link need stubs too, to cover -R and absolute syms.  */
11727           if (sym_sec->output_section == NULL)
11728             {
11729               ret = 1;
11730               break;
11731             }
11732
11733           if (h == NULL)
11734             sym_value = sym->st_value;
11735           else
11736             {
11737               if (h->root.type != bfd_link_hash_defined
11738                   && h->root.type != bfd_link_hash_defweak)
11739                 abort ();
11740               sym_value = h->root.u.def.value;
11741             }
11742           sym_value += rel->r_addend;
11743
11744           /* If this branch reloc uses an opd sym, find the code section.  */
11745           opd = get_opd_info (sym_sec);
11746           if (opd != NULL)
11747             {
11748               if (h == NULL && opd->adjust != NULL)
11749                 {
11750                   long adjust;
11751
11752                   adjust = opd->adjust[OPD_NDX (sym_value)];
11753                   if (adjust == -1)
11754                     /* Assume deleted functions won't ever be called.  */
11755                     continue;
11756                   sym_value += adjust;
11757                 }
11758
11759               dest = opd_entry_value (sym_sec, sym_value,
11760                                       &sym_sec, NULL, FALSE);
11761               if (dest == (bfd_vma) -1)
11762                 continue;
11763             }
11764           else
11765             dest = (sym_value
11766                     + sym_sec->output_offset
11767                     + sym_sec->output_section->vma);
11768
11769           /* Ignore branch to self.  */
11770           if (sym_sec == isec)
11771             continue;
11772
11773           /* If the called function uses the toc, we need a stub.  */
11774           if (sym_sec->has_toc_reloc
11775               || sym_sec->makes_toc_func_call)
11776             {
11777               ret = 1;
11778               break;
11779             }
11780
11781           /* Assume any branch that needs a long branch stub might in fact
11782              need a plt_branch stub.  A plt_branch stub uses r2.  */
11783           else if (dest - (isec->output_offset
11784                            + isec->output_section->vma
11785                            + rel->r_offset) + (1 << 25)
11786                    >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
11787                                                              ? h->other
11788                                                              : sym->st_other))
11789             {
11790               ret = 1;
11791               break;
11792             }
11793
11794           /* If calling back to a section in the process of being
11795              tested, we can't say for sure that no toc adjusting stubs
11796              are needed, so don't return zero.  */
11797           else if (sym_sec->call_check_in_progress)
11798             ret = 2;
11799
11800           /* Branches to another section that itself doesn't have any TOC
11801              references are OK.  Recursively call ourselves to check.  */
11802           else if (!sym_sec->call_check_done)
11803             {
11804               int recur;
11805
11806               /* Mark current section as indeterminate, so that other
11807                  sections that call back to current won't be marked as
11808                  known.  */
11809               isec->call_check_in_progress = 1;
11810               recur = toc_adjusting_stub_needed (info, sym_sec);
11811               isec->call_check_in_progress = 0;
11812
11813               if (recur != 0)
11814                 {
11815                   ret = recur;
11816                   if (recur != 2)
11817                     break;
11818                 }
11819             }
11820         }
11821
11822       if (local_syms != NULL
11823           && (elf_symtab_hdr (isec->owner).contents
11824               != (unsigned char *) local_syms))
11825         free (local_syms);
11826       if (elf_section_data (isec)->relocs != relstart)
11827         free (relstart);
11828     }
11829
11830   if ((ret & 1) == 0
11831       && isec->map_head.s != NULL
11832       && (strcmp (isec->output_section->name, ".init") == 0
11833           || strcmp (isec->output_section->name, ".fini") == 0))
11834     {
11835       if (isec->map_head.s->has_toc_reloc
11836           || isec->map_head.s->makes_toc_func_call)
11837         ret = 1;
11838       else if (!isec->map_head.s->call_check_done)
11839         {
11840           int recur;
11841           isec->call_check_in_progress = 1;
11842           recur = toc_adjusting_stub_needed (info, isec->map_head.s);
11843           isec->call_check_in_progress = 0;
11844           if (recur != 0)
11845             ret = recur;
11846         }
11847     }
11848
11849   if (ret == 1)
11850     isec->makes_toc_func_call = 1;
11851
11852   return ret;
11853 }
11854
11855 /* The linker repeatedly calls this function for each input section,
11856    in the order that input sections are linked into output sections.
11857    Build lists of input sections to determine groupings between which
11858    we may insert linker stubs.  */
11859
11860 bfd_boolean
11861 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
11862 {
11863   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11864
11865   if (htab == NULL)
11866     return FALSE;
11867
11868   if ((isec->output_section->flags & SEC_CODE) != 0
11869       && isec->output_section->id < htab->sec_info_arr_size)
11870     {
11871       /* This happens to make the list in reverse order,
11872          which is what we want.  */
11873       htab->sec_info[isec->id].u.list
11874         = htab->sec_info[isec->output_section->id].u.list;
11875       htab->sec_info[isec->output_section->id].u.list = isec;
11876     }
11877
11878   if (htab->multi_toc_needed)
11879     {
11880       /* Analyse sections that aren't already flagged as needing a
11881          valid toc pointer.  Exclude .fixup for the linux kernel.
11882          .fixup contains branches, but only back to the function that
11883          hit an exception.  */
11884       if (!(isec->has_toc_reloc
11885             || (isec->flags & SEC_CODE) == 0
11886             || strcmp (isec->name, ".fixup") == 0
11887             || isec->call_check_done))
11888         {
11889           if (toc_adjusting_stub_needed (info, isec) < 0)
11890             return FALSE;
11891         }
11892       /* Make all sections use the TOC assigned for this object file.
11893          This will be wrong for pasted sections;  We fix that in
11894          check_pasted_section().  */
11895       if (elf_gp (isec->owner) != 0)
11896         htab->toc_curr = elf_gp (isec->owner);
11897     }
11898
11899   htab->sec_info[isec->id].toc_off = htab->toc_curr;
11900   return TRUE;
11901 }
11902
11903 /* Check that all .init and .fini sections use the same toc, if they
11904    have toc relocs.  */
11905
11906 static bfd_boolean
11907 check_pasted_section (struct bfd_link_info *info, const char *name)
11908 {
11909   asection *o = bfd_get_section_by_name (info->output_bfd, name);
11910
11911   if (o != NULL)
11912     {
11913       struct ppc_link_hash_table *htab = ppc_hash_table (info);
11914       bfd_vma toc_off = 0;
11915       asection *i;
11916
11917       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11918         if (i->has_toc_reloc)
11919           {
11920             if (toc_off == 0)
11921               toc_off = htab->sec_info[i->id].toc_off;
11922             else if (toc_off != htab->sec_info[i->id].toc_off)
11923               return FALSE;
11924           }
11925
11926       if (toc_off == 0)
11927         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11928           if (i->makes_toc_func_call)
11929             {
11930               toc_off = htab->sec_info[i->id].toc_off;
11931               break;
11932             }
11933
11934       /* Make sure the whole pasted function uses the same toc offset.  */
11935       if (toc_off != 0)
11936         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11937           htab->sec_info[i->id].toc_off = toc_off;
11938     }
11939   return TRUE;
11940 }
11941
11942 bfd_boolean
11943 ppc64_elf_check_init_fini (struct bfd_link_info *info)
11944 {
11945   return (check_pasted_section (info, ".init")
11946           & check_pasted_section (info, ".fini"));
11947 }
11948
11949 /* See whether we can group stub sections together.  Grouping stub
11950    sections may result in fewer stubs.  More importantly, we need to
11951    put all .init* and .fini* stubs at the beginning of the .init or
11952    .fini output sections respectively, because glibc splits the
11953    _init and _fini functions into multiple parts.  Putting a stub in
11954    the middle of a function is not a good idea.  */
11955
11956 static bfd_boolean
11957 group_sections (struct bfd_link_info *info,
11958                 bfd_size_type stub_group_size,
11959                 bfd_boolean stubs_always_before_branch)
11960 {
11961   struct ppc_link_hash_table *htab;
11962   asection *osec;
11963   bfd_size_type stub14_group_size;
11964   bfd_boolean suppress_size_errors;
11965
11966   htab = ppc_hash_table (info);
11967   if (htab == NULL)
11968     return FALSE;
11969
11970   suppress_size_errors = FALSE;
11971   stub14_group_size = stub_group_size >> 10;
11972   if (stub_group_size == 1)
11973     {
11974       /* Default values.  */
11975       if (stubs_always_before_branch)
11976         {
11977           stub_group_size = 0x1e00000;
11978           stub14_group_size = 0x7800;
11979         }
11980       else
11981         {
11982           stub_group_size = 0x1c00000;
11983           stub14_group_size = 0x7000;
11984         }
11985       suppress_size_errors = TRUE;
11986     }
11987
11988   for (osec = info->output_bfd->sections; osec != NULL; osec = osec->next)
11989     {
11990       asection *tail;
11991
11992       if (osec->id >= htab->sec_info_arr_size)
11993         continue;
11994
11995       tail = htab->sec_info[osec->id].u.list;
11996       while (tail != NULL)
11997         {
11998           asection *curr;
11999           asection *prev;
12000           bfd_size_type total;
12001           bfd_boolean big_sec;
12002           bfd_vma curr_toc;
12003           struct map_stub *group;
12004
12005           curr = tail;
12006           total = tail->size;
12007           big_sec = total > (ppc64_elf_section_data (tail) != NULL
12008                              && ppc64_elf_section_data (tail)->has_14bit_branch
12009                              ? stub14_group_size : stub_group_size);
12010           if (big_sec && !suppress_size_errors)
12011             (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
12012                                      tail->owner, tail);
12013           curr_toc = htab->sec_info[tail->id].toc_off;
12014
12015           while ((prev = htab->sec_info[curr->id].u.list) != NULL
12016                  && ((total += curr->output_offset - prev->output_offset)
12017                      < (ppc64_elf_section_data (prev) != NULL
12018                         && ppc64_elf_section_data (prev)->has_14bit_branch
12019                         ? stub14_group_size : stub_group_size))
12020                  && htab->sec_info[prev->id].toc_off == curr_toc)
12021             curr = prev;
12022
12023           /* OK, the size from the start of CURR to the end is less
12024              than stub_group_size and thus can be handled by one stub
12025              section.  (or the tail section is itself larger than
12026              stub_group_size, in which case we may be toast.)  We
12027              should really be keeping track of the total size of stubs
12028              added here, as stubs contribute to the final output
12029              section size.  That's a little tricky, and this way will
12030              only break if stubs added make the total size more than
12031              2^25, ie. for the default stub_group_size, if stubs total
12032              more than 2097152 bytes, or nearly 75000 plt call stubs.  */
12033           group = bfd_alloc (curr->owner, sizeof (*group));
12034           if (group == NULL)
12035             return FALSE;
12036           group->link_sec = curr;
12037           group->stub_sec = NULL;
12038           group->needs_save_res = 0;
12039           group->next = htab->group;
12040           htab->group = group;
12041           do
12042             {
12043               prev = htab->sec_info[tail->id].u.list;
12044               /* Set up this stub group.  */
12045               htab->sec_info[tail->id].u.group = group;
12046             }
12047           while (tail != curr && (tail = prev) != NULL);
12048
12049           /* But wait, there's more!  Input sections up to stub_group_size
12050              bytes before the stub section can be handled by it too.
12051              Don't do this if we have a really large section after the
12052              stubs, as adding more stubs increases the chance that
12053              branches may not reach into the stub section.  */
12054           if (!stubs_always_before_branch && !big_sec)
12055             {
12056               total = 0;
12057               while (prev != NULL
12058                      && ((total += tail->output_offset - prev->output_offset)
12059                          < (ppc64_elf_section_data (prev) != NULL
12060                             && ppc64_elf_section_data (prev)->has_14bit_branch
12061                             ? stub14_group_size : stub_group_size))
12062                      && htab->sec_info[prev->id].toc_off == curr_toc)
12063                 {
12064                   tail = prev;
12065                   prev = htab->sec_info[tail->id].u.list;
12066                   htab->sec_info[tail->id].u.group = group;
12067                 }
12068             }
12069           tail = prev;
12070         }
12071     }
12072   return TRUE;
12073 }
12074
12075 static const unsigned char glink_eh_frame_cie[] =
12076 {
12077   0, 0, 0, 16,                          /* length.  */
12078   0, 0, 0, 0,                           /* id.  */
12079   1,                                    /* CIE version.  */
12080   'z', 'R', 0,                          /* Augmentation string.  */
12081   4,                                    /* Code alignment.  */
12082   0x78,                                 /* Data alignment.  */
12083   65,                                   /* RA reg.  */
12084   1,                                    /* Augmentation size.  */
12085   DW_EH_PE_pcrel | DW_EH_PE_sdata4,     /* FDE encoding.  */
12086   DW_CFA_def_cfa, 1, 0,                 /* def_cfa: r1 offset 0.  */
12087   0, 0, 0, 0
12088 };
12089
12090 /* Stripping output sections is normally done before dynamic section
12091    symbols have been allocated.  This function is called later, and
12092    handles cases like htab->brlt which is mapped to its own output
12093    section.  */
12094
12095 static void
12096 maybe_strip_output (struct bfd_link_info *info, asection *isec)
12097 {
12098   if (isec->size == 0
12099       && isec->output_section->size == 0
12100       && !(isec->output_section->flags & SEC_KEEP)
12101       && !bfd_section_removed_from_list (info->output_bfd,
12102                                          isec->output_section)
12103       && elf_section_data (isec->output_section)->dynindx == 0)
12104     {
12105       isec->output_section->flags |= SEC_EXCLUDE;
12106       bfd_section_list_remove (info->output_bfd, isec->output_section);
12107       info->output_bfd->section_count--;
12108     }
12109 }
12110
12111 /* Determine and set the size of the stub section for a final link.
12112
12113    The basic idea here is to examine all the relocations looking for
12114    PC-relative calls to a target that is unreachable with a "bl"
12115    instruction.  */
12116
12117 bfd_boolean
12118 ppc64_elf_size_stubs (struct bfd_link_info *info)
12119 {
12120   bfd_size_type stub_group_size;
12121   bfd_boolean stubs_always_before_branch;
12122   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12123
12124   if (htab == NULL)
12125     return FALSE;
12126
12127   if (htab->params->plt_thread_safe == -1 && !bfd_link_executable (info))
12128     htab->params->plt_thread_safe = 1;
12129   if (!htab->opd_abi)
12130     htab->params->plt_thread_safe = 0;
12131   else if (htab->params->plt_thread_safe == -1)
12132     {
12133       static const char *const thread_starter[] =
12134         {
12135           "pthread_create",
12136           /* libstdc++ */
12137           "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
12138           /* librt */
12139           "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
12140           "mq_notify", "create_timer",
12141           /* libanl */
12142           "getaddrinfo_a",
12143           /* libgomp */
12144           "GOMP_parallel",
12145           "GOMP_parallel_start",
12146           "GOMP_parallel_loop_static",
12147           "GOMP_parallel_loop_static_start",
12148           "GOMP_parallel_loop_dynamic",
12149           "GOMP_parallel_loop_dynamic_start",
12150           "GOMP_parallel_loop_guided",
12151           "GOMP_parallel_loop_guided_start",
12152           "GOMP_parallel_loop_runtime",
12153           "GOMP_parallel_loop_runtime_start",
12154           "GOMP_parallel_sections",
12155           "GOMP_parallel_sections_start",
12156           /* libgo */
12157           "__go_go",
12158         };
12159       unsigned i;
12160
12161       for (i = 0; i < ARRAY_SIZE (thread_starter); i++)
12162         {
12163           struct elf_link_hash_entry *h;
12164           h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
12165                                     FALSE, FALSE, TRUE);
12166           htab->params->plt_thread_safe = h != NULL && h->ref_regular;
12167           if (htab->params->plt_thread_safe)
12168             break;
12169         }
12170     }
12171   stubs_always_before_branch = htab->params->group_size < 0;
12172   if (htab->params->group_size < 0)
12173     stub_group_size = -htab->params->group_size;
12174   else
12175     stub_group_size = htab->params->group_size;
12176
12177   if (!group_sections (info, stub_group_size, stubs_always_before_branch))
12178     return FALSE;
12179
12180   while (1)
12181     {
12182       bfd *input_bfd;
12183       unsigned int bfd_indx;
12184       struct map_stub *group;
12185       asection *stub_sec;
12186
12187       htab->stub_iteration += 1;
12188
12189       for (input_bfd = info->input_bfds, bfd_indx = 0;
12190            input_bfd != NULL;
12191            input_bfd = input_bfd->link.next, bfd_indx++)
12192         {
12193           Elf_Internal_Shdr *symtab_hdr;
12194           asection *section;
12195           Elf_Internal_Sym *local_syms = NULL;
12196
12197           if (!is_ppc64_elf (input_bfd))
12198             continue;
12199
12200           /* We'll need the symbol table in a second.  */
12201           symtab_hdr = &elf_symtab_hdr (input_bfd);
12202           if (symtab_hdr->sh_info == 0)
12203             continue;
12204
12205           /* Walk over each section attached to the input bfd.  */
12206           for (section = input_bfd->sections;
12207                section != NULL;
12208                section = section->next)
12209             {
12210               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
12211
12212               /* If there aren't any relocs, then there's nothing more
12213                  to do.  */
12214               if ((section->flags & SEC_RELOC) == 0
12215                   || (section->flags & SEC_ALLOC) == 0
12216                   || (section->flags & SEC_LOAD) == 0
12217                   || (section->flags & SEC_CODE) == 0
12218                   || section->reloc_count == 0)
12219                 continue;
12220
12221               /* If this section is a link-once section that will be
12222                  discarded, then don't create any stubs.  */
12223               if (section->output_section == NULL
12224                   || section->output_section->owner != info->output_bfd)
12225                 continue;
12226
12227               /* Get the relocs.  */
12228               internal_relocs
12229                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
12230                                              info->keep_memory);
12231               if (internal_relocs == NULL)
12232                 goto error_ret_free_local;
12233
12234               /* Now examine each relocation.  */
12235               irela = internal_relocs;
12236               irelaend = irela + section->reloc_count;
12237               for (; irela < irelaend; irela++)
12238                 {
12239                   enum elf_ppc64_reloc_type r_type;
12240                   unsigned int r_indx;
12241                   enum ppc_stub_type stub_type;
12242                   struct ppc_stub_hash_entry *stub_entry;
12243                   asection *sym_sec, *code_sec;
12244                   bfd_vma sym_value, code_value;
12245                   bfd_vma destination;
12246                   unsigned long local_off;
12247                   bfd_boolean ok_dest;
12248                   struct ppc_link_hash_entry *hash;
12249                   struct ppc_link_hash_entry *fdh;
12250                   struct elf_link_hash_entry *h;
12251                   Elf_Internal_Sym *sym;
12252                   char *stub_name;
12253                   const asection *id_sec;
12254                   struct _opd_sec_data *opd;
12255                   struct plt_entry *plt_ent;
12256
12257                   r_type = ELF64_R_TYPE (irela->r_info);
12258                   r_indx = ELF64_R_SYM (irela->r_info);
12259
12260                   if (r_type >= R_PPC64_max)
12261                     {
12262                       bfd_set_error (bfd_error_bad_value);
12263                       goto error_ret_free_internal;
12264                     }
12265
12266                   /* Only look for stubs on branch instructions.  */
12267                   if (r_type != R_PPC64_REL24
12268                       && r_type != R_PPC64_REL14
12269                       && r_type != R_PPC64_REL14_BRTAKEN
12270                       && r_type != R_PPC64_REL14_BRNTAKEN)
12271                     continue;
12272
12273                   /* Now determine the call target, its name, value,
12274                      section.  */
12275                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12276                                   r_indx, input_bfd))
12277                     goto error_ret_free_internal;
12278                   hash = (struct ppc_link_hash_entry *) h;
12279
12280                   ok_dest = FALSE;
12281                   fdh = NULL;
12282                   sym_value = 0;
12283                   if (hash == NULL)
12284                     {
12285                       sym_value = sym->st_value;
12286                       if (sym_sec != NULL
12287                           && sym_sec->output_section != NULL)
12288                         ok_dest = TRUE;
12289                     }
12290                   else if (hash->elf.root.type == bfd_link_hash_defined
12291                            || hash->elf.root.type == bfd_link_hash_defweak)
12292                     {
12293                       sym_value = hash->elf.root.u.def.value;
12294                       if (sym_sec->output_section != NULL)
12295                         ok_dest = TRUE;
12296                     }
12297                   else if (hash->elf.root.type == bfd_link_hash_undefweak
12298                            || hash->elf.root.type == bfd_link_hash_undefined)
12299                     {
12300                       /* Recognise an old ABI func code entry sym, and
12301                          use the func descriptor sym instead if it is
12302                          defined.  */
12303                       if (hash->elf.root.root.string[0] == '.'
12304                           && (fdh = lookup_fdh (hash, htab)) != NULL)
12305                         {
12306                           if (fdh->elf.root.type == bfd_link_hash_defined
12307                               || fdh->elf.root.type == bfd_link_hash_defweak)
12308                             {
12309                               sym_sec = fdh->elf.root.u.def.section;
12310                               sym_value = fdh->elf.root.u.def.value;
12311                               if (sym_sec->output_section != NULL)
12312                                 ok_dest = TRUE;
12313                             }
12314                           else
12315                             fdh = NULL;
12316                         }
12317                     }
12318                   else
12319                     {
12320                       bfd_set_error (bfd_error_bad_value);
12321                       goto error_ret_free_internal;
12322                     }
12323
12324                   destination = 0;
12325                   local_off = 0;
12326                   if (ok_dest)
12327                     {
12328                       sym_value += irela->r_addend;
12329                       destination = (sym_value
12330                                      + sym_sec->output_offset
12331                                      + sym_sec->output_section->vma);
12332                       local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12333                                                             ? hash->elf.other
12334                                                             : sym->st_other);
12335                     }
12336
12337                   code_sec = sym_sec;
12338                   code_value = sym_value;
12339                   opd = get_opd_info (sym_sec);
12340                   if (opd != NULL)
12341                     {
12342                       bfd_vma dest;
12343
12344                       if (hash == NULL && opd->adjust != NULL)
12345                         {
12346                           long adjust = opd->adjust[OPD_NDX (sym_value)];
12347                           if (adjust == -1)
12348                             continue;
12349                           code_value += adjust;
12350                           sym_value += adjust;
12351                         }
12352                       dest = opd_entry_value (sym_sec, sym_value,
12353                                               &code_sec, &code_value, FALSE);
12354                       if (dest != (bfd_vma) -1)
12355                         {
12356                           destination = dest;
12357                           if (fdh != NULL)
12358                             {
12359                               /* Fixup old ABI sym to point at code
12360                                  entry.  */
12361                               hash->elf.root.type = bfd_link_hash_defweak;
12362                               hash->elf.root.u.def.section = code_sec;
12363                               hash->elf.root.u.def.value = code_value;
12364                             }
12365                         }
12366                     }
12367
12368                   /* Determine what (if any) linker stub is needed.  */
12369                   plt_ent = NULL;
12370                   stub_type = ppc_type_of_stub (section, irela, &hash,
12371                                                 &plt_ent, destination,
12372                                                 local_off);
12373
12374                   if (stub_type != ppc_stub_plt_call)
12375                     {
12376                       /* Check whether we need a TOC adjusting stub.
12377                          Since the linker pastes together pieces from
12378                          different object files when creating the
12379                          _init and _fini functions, it may be that a
12380                          call to what looks like a local sym is in
12381                          fact a call needing a TOC adjustment.  */
12382                       if (code_sec != NULL
12383                           && code_sec->output_section != NULL
12384                           && (htab->sec_info[code_sec->id].toc_off
12385                               != htab->sec_info[section->id].toc_off)
12386                           && (code_sec->has_toc_reloc
12387                               || code_sec->makes_toc_func_call))
12388                         stub_type = ppc_stub_long_branch_r2off;
12389                     }
12390
12391                   if (stub_type == ppc_stub_none)
12392                     continue;
12393
12394                   /* __tls_get_addr calls might be eliminated.  */
12395                   if (stub_type != ppc_stub_plt_call
12396                       && hash != NULL
12397                       && (hash == htab->tls_get_addr
12398                           || hash == htab->tls_get_addr_fd)
12399                       && section->has_tls_reloc
12400                       && irela != internal_relocs)
12401                     {
12402                       /* Get tls info.  */
12403                       unsigned char *tls_mask;
12404
12405                       if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12406                                          irela - 1, input_bfd))
12407                         goto error_ret_free_internal;
12408                       if (*tls_mask != 0)
12409                         continue;
12410                     }
12411
12412                   if (stub_type == ppc_stub_plt_call
12413                       && irela + 1 < irelaend
12414                       && irela[1].r_offset == irela->r_offset + 4
12415                       && ELF64_R_TYPE (irela[1].r_info) == R_PPC64_TOCSAVE)
12416                     {
12417                       if (!tocsave_find (htab, INSERT,
12418                                          &local_syms, irela + 1, input_bfd))
12419                         goto error_ret_free_internal;
12420                     }
12421                   else if (stub_type == ppc_stub_plt_call)
12422                     stub_type = ppc_stub_plt_call_r2save;
12423
12424                   /* Support for grouping stub sections.  */
12425                   id_sec = htab->sec_info[section->id].u.group->link_sec;
12426
12427                   /* Get the name of this stub.  */
12428                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12429                   if (!stub_name)
12430                     goto error_ret_free_internal;
12431
12432                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12433                                                      stub_name, FALSE, FALSE);
12434                   if (stub_entry != NULL)
12435                     {
12436                       /* The proper stub has already been created.  */
12437                       free (stub_name);
12438                       if (stub_type == ppc_stub_plt_call_r2save)
12439                         stub_entry->stub_type = stub_type;
12440                       continue;
12441                     }
12442
12443                   stub_entry = ppc_add_stub (stub_name, section, info);
12444                   if (stub_entry == NULL)
12445                     {
12446                       free (stub_name);
12447                     error_ret_free_internal:
12448                       if (elf_section_data (section)->relocs == NULL)
12449                         free (internal_relocs);
12450                     error_ret_free_local:
12451                       if (local_syms != NULL
12452                           && (symtab_hdr->contents
12453                               != (unsigned char *) local_syms))
12454                         free (local_syms);
12455                       return FALSE;
12456                     }
12457
12458                   stub_entry->stub_type = stub_type;
12459                   if (stub_type != ppc_stub_plt_call
12460                       && stub_type != ppc_stub_plt_call_r2save)
12461                     {
12462                       stub_entry->target_value = code_value;
12463                       stub_entry->target_section = code_sec;
12464                     }
12465                   else
12466                     {
12467                       stub_entry->target_value = sym_value;
12468                       stub_entry->target_section = sym_sec;
12469                     }
12470                   stub_entry->h = hash;
12471                   stub_entry->plt_ent = plt_ent;
12472                   stub_entry->other = hash ? hash->elf.other : sym->st_other;
12473
12474                   if (stub_entry->h != NULL)
12475                     htab->stub_globals += 1;
12476                 }
12477
12478               /* We're done with the internal relocs, free them.  */
12479               if (elf_section_data (section)->relocs != internal_relocs)
12480                 free (internal_relocs);
12481             }
12482
12483           if (local_syms != NULL
12484               && symtab_hdr->contents != (unsigned char *) local_syms)
12485             {
12486               if (!info->keep_memory)
12487                 free (local_syms);
12488               else
12489                 symtab_hdr->contents = (unsigned char *) local_syms;
12490             }
12491         }
12492
12493       /* We may have added some stubs.  Find out the new size of the
12494          stub sections.  */
12495       for (stub_sec = htab->params->stub_bfd->sections;
12496            stub_sec != NULL;
12497            stub_sec = stub_sec->next)
12498         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12499           {
12500             stub_sec->rawsize = stub_sec->size;
12501             stub_sec->size = 0;
12502             stub_sec->reloc_count = 0;
12503             stub_sec->flags &= ~SEC_RELOC;
12504           }
12505
12506       htab->brlt->size = 0;
12507       htab->brlt->reloc_count = 0;
12508       htab->brlt->flags &= ~SEC_RELOC;
12509       if (htab->relbrlt != NULL)
12510         htab->relbrlt->size = 0;
12511
12512       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12513
12514       for (group = htab->group; group != NULL; group = group->next)
12515         if (group->needs_save_res)
12516           group->stub_sec->size += htab->sfpr->size;
12517
12518       if (info->emitrelocations
12519           && htab->glink != NULL && htab->glink->size != 0)
12520         {
12521           htab->glink->reloc_count = 1;
12522           htab->glink->flags |= SEC_RELOC;
12523         }
12524
12525       if (htab->glink_eh_frame != NULL
12526           && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12527           && htab->glink_eh_frame->output_section->size != 0)
12528         {
12529           size_t size = 0, align;
12530
12531           for (stub_sec = htab->params->stub_bfd->sections;
12532                stub_sec != NULL;
12533                stub_sec = stub_sec->next)
12534             if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12535               size += 24;
12536           if (htab->glink != NULL && htab->glink->size != 0)
12537             size += 24;
12538           if (size != 0)
12539             size += sizeof (glink_eh_frame_cie);
12540           align = 1;
12541           align <<= htab->glink_eh_frame->output_section->alignment_power;
12542           align -= 1;
12543           size = (size + align) & ~align;
12544           htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12545           htab->glink_eh_frame->size = size;
12546         }
12547
12548       if (htab->params->plt_stub_align != 0)
12549         for (stub_sec = htab->params->stub_bfd->sections;
12550              stub_sec != NULL;
12551              stub_sec = stub_sec->next)
12552           if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12553             stub_sec->size = ((stub_sec->size
12554                                + (1 << htab->params->plt_stub_align) - 1)
12555                               & -(1 << htab->params->plt_stub_align));
12556
12557       for (stub_sec = htab->params->stub_bfd->sections;
12558            stub_sec != NULL;
12559            stub_sec = stub_sec->next)
12560         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12561             && stub_sec->rawsize != stub_sec->size)
12562           break;
12563
12564       /* Exit from this loop when no stubs have been added, and no stubs
12565          have changed size.  */
12566       if (stub_sec == NULL
12567           && (htab->glink_eh_frame == NULL
12568               || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12569         break;
12570
12571       /* Ask the linker to do its stuff.  */
12572       (*htab->params->layout_sections_again) ();
12573     }
12574
12575   if (htab->glink_eh_frame != NULL
12576       && htab->glink_eh_frame->size != 0)
12577     {
12578       bfd_vma val;
12579       bfd_byte *p, *last_fde;
12580       size_t last_fde_len, size, align, pad;
12581       asection *stub_sec;
12582
12583       p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12584       if (p == NULL)
12585         return FALSE;
12586       htab->glink_eh_frame->contents = p;
12587       last_fde = p;
12588
12589       memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12590       /* CIE length (rewrite in case little-endian).  */
12591       last_fde_len = sizeof (glink_eh_frame_cie) - 4;
12592       bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12593       p += sizeof (glink_eh_frame_cie);
12594
12595       for (stub_sec = htab->params->stub_bfd->sections;
12596            stub_sec != NULL;
12597            stub_sec = stub_sec->next)
12598         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12599           {
12600             last_fde = p;
12601             last_fde_len = 20;
12602             /* FDE length.  */
12603             bfd_put_32 (htab->elf.dynobj, 20, p);
12604             p += 4;
12605             /* CIE pointer.  */
12606             val = p - htab->glink_eh_frame->contents;
12607             bfd_put_32 (htab->elf.dynobj, val, p);
12608             p += 4;
12609             /* Offset to stub section, written later.  */
12610             p += 4;
12611             /* stub section size.  */
12612             bfd_put_32 (htab->elf.dynobj, stub_sec->size, p);
12613             p += 4;
12614             /* Augmentation.  */
12615             p += 1;
12616             /* Pad.  */
12617             p += 7;
12618           }
12619       if (htab->glink != NULL && htab->glink->size != 0)
12620         {
12621           last_fde = p;
12622           last_fde_len = 20;
12623           /* FDE length.  */
12624           bfd_put_32 (htab->elf.dynobj, 20, p);
12625           p += 4;
12626           /* CIE pointer.  */
12627           val = p - htab->glink_eh_frame->contents;
12628           bfd_put_32 (htab->elf.dynobj, val, p);
12629           p += 4;
12630           /* Offset to .glink, written later.  */
12631           p += 4;
12632           /* .glink size.  */
12633           bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12634           p += 4;
12635           /* Augmentation.  */
12636           p += 1;
12637
12638           *p++ = DW_CFA_advance_loc + 1;
12639           *p++ = DW_CFA_register;
12640           *p++ = 65;
12641           *p++ = htab->opd_abi ? 12 : 0;
12642           *p++ = DW_CFA_advance_loc + 4;
12643           *p++ = DW_CFA_restore_extended;
12644           *p++ = 65;
12645         }
12646       /* Subsume any padding into the last FDE if user .eh_frame
12647          sections are aligned more than glink_eh_frame.  Otherwise any
12648          zero padding will be seen as a terminator.  */
12649       size = p - htab->glink_eh_frame->contents;
12650       align = 1;
12651       align <<= htab->glink_eh_frame->output_section->alignment_power;
12652       align -= 1;
12653       pad = ((size + align) & ~align) - size;
12654       htab->glink_eh_frame->size = size + pad;
12655       bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12656     }
12657
12658   maybe_strip_output (info, htab->brlt);
12659   if (htab->glink_eh_frame != NULL)
12660     maybe_strip_output (info, htab->glink_eh_frame);
12661
12662   return TRUE;
12663 }
12664
12665 /* Called after we have determined section placement.  If sections
12666    move, we'll be called again.  Provide a value for TOCstart.  */
12667
12668 bfd_vma
12669 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12670 {
12671   asection *s;
12672   bfd_vma TOCstart, adjust;
12673
12674   if (info != NULL)
12675     {
12676       struct elf_link_hash_entry *h;
12677       struct elf_link_hash_table *htab = elf_hash_table (info);
12678
12679       if (is_elf_hash_table (htab)
12680           && htab->hgot != NULL)
12681         h = htab->hgot;
12682       else
12683         {
12684           h = elf_link_hash_lookup (htab, ".TOC.", FALSE, FALSE, TRUE);
12685           if (is_elf_hash_table (htab))
12686             htab->hgot = h;
12687         }
12688       if (h != NULL
12689           && h->root.type == bfd_link_hash_defined
12690           && !h->root.linker_def
12691           && (!is_elf_hash_table (htab)
12692               || h->def_regular))
12693         {
12694           TOCstart = (h->root.u.def.value - TOC_BASE_OFF
12695                       + h->root.u.def.section->output_offset
12696                       + h->root.u.def.section->output_section->vma);
12697           _bfd_set_gp_value (obfd, TOCstart);
12698           return TOCstart;
12699         }
12700     }
12701
12702   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12703      order.  The TOC starts where the first of these sections starts.  */
12704   s = bfd_get_section_by_name (obfd, ".got");
12705   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12706     s = bfd_get_section_by_name (obfd, ".toc");
12707   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12708     s = bfd_get_section_by_name (obfd, ".tocbss");
12709   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12710     s = bfd_get_section_by_name (obfd, ".plt");
12711   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12712     {
12713       /* This may happen for
12714          o  references to TOC base (SYM@toc / TOC[tc0]) without a
12715          .toc directive
12716          o  bad linker script
12717          o --gc-sections and empty TOC sections
12718
12719          FIXME: Warn user?  */
12720
12721       /* Look for a likely section.  We probably won't even be
12722          using TOCstart.  */
12723       for (s = obfd->sections; s != NULL; s = s->next)
12724         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
12725                          | SEC_EXCLUDE))
12726             == (SEC_ALLOC | SEC_SMALL_DATA))
12727           break;
12728       if (s == NULL)
12729         for (s = obfd->sections; s != NULL; s = s->next)
12730           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
12731               == (SEC_ALLOC | SEC_SMALL_DATA))
12732             break;
12733       if (s == NULL)
12734         for (s = obfd->sections; s != NULL; s = s->next)
12735           if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
12736               == SEC_ALLOC)
12737             break;
12738       if (s == NULL)
12739         for (s = obfd->sections; s != NULL; s = s->next)
12740           if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
12741             break;
12742     }
12743
12744   TOCstart = 0;
12745   if (s != NULL)
12746     TOCstart = s->output_section->vma + s->output_offset;
12747
12748   /* Force alignment.  */
12749   adjust = TOCstart & (TOC_BASE_ALIGN - 1);
12750   TOCstart -= adjust;
12751   _bfd_set_gp_value (obfd, TOCstart);
12752
12753   if (info != NULL && s != NULL)
12754     {
12755       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12756
12757       if (htab != NULL)
12758         {
12759           if (htab->elf.hgot != NULL)
12760             {
12761               htab->elf.hgot->root.u.def.value = TOC_BASE_OFF - adjust;
12762               htab->elf.hgot->root.u.def.section = s;
12763             }
12764         }
12765       else
12766         {
12767           struct bfd_link_hash_entry *bh = NULL;
12768           _bfd_generic_link_add_one_symbol (info, obfd, ".TOC.", BSF_GLOBAL,
12769                                             s, TOC_BASE_OFF - adjust,
12770                                             NULL, FALSE, FALSE, &bh);
12771         }
12772     }
12773   return TOCstart;
12774 }
12775
12776 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
12777    write out any global entry stubs.  */
12778
12779 static bfd_boolean
12780 build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
12781 {
12782   struct bfd_link_info *info;
12783   struct ppc_link_hash_table *htab;
12784   struct plt_entry *pent;
12785   asection *s;
12786
12787   if (h->root.type == bfd_link_hash_indirect)
12788     return TRUE;
12789
12790   if (!h->pointer_equality_needed)
12791     return TRUE;
12792
12793   if (h->def_regular)
12794     return TRUE;
12795
12796   info = inf;
12797   htab = ppc_hash_table (info);
12798   if (htab == NULL)
12799     return FALSE;
12800
12801   s = htab->glink;
12802   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
12803     if (pent->plt.offset != (bfd_vma) -1
12804         && pent->addend == 0)
12805       {
12806         bfd_byte *p;
12807         asection *plt;
12808         bfd_vma off;
12809
12810         p = s->contents + h->root.u.def.value;
12811         plt = htab->elf.splt;
12812         if (!htab->elf.dynamic_sections_created
12813             || h->dynindx == -1)
12814           plt = htab->elf.iplt;
12815         off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
12816         off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
12817
12818         if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
12819           {
12820             info->callbacks->einfo
12821               (_("%P: linkage table error against `%T'\n"),
12822                h->root.root.string);
12823             bfd_set_error (bfd_error_bad_value);
12824             htab->stub_error = TRUE;
12825           }
12826
12827         htab->stub_count[ppc_stub_global_entry - 1] += 1;
12828         if (htab->params->emit_stub_syms)
12829           {
12830             size_t len = strlen (h->root.root.string);
12831             char *name = bfd_malloc (sizeof "12345678.global_entry." + len);
12832
12833             if (name == NULL)
12834               return FALSE;
12835
12836             sprintf (name, "%08x.global_entry.%s", s->id, h->root.root.string);
12837             h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
12838             if (h == NULL)
12839               return FALSE;
12840             if (h->root.type == bfd_link_hash_new)
12841               {
12842                 h->root.type = bfd_link_hash_defined;
12843                 h->root.u.def.section = s;
12844                 h->root.u.def.value = p - s->contents;
12845                 h->ref_regular = 1;
12846                 h->def_regular = 1;
12847                 h->ref_regular_nonweak = 1;
12848                 h->forced_local = 1;
12849                 h->non_elf = 0;
12850                 h->root.linker_def = 1;
12851               }
12852           }
12853
12854         if (PPC_HA (off) != 0)
12855           {
12856             bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
12857             p += 4;
12858           }
12859         bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
12860         p += 4;
12861         bfd_put_32 (s->owner, MTCTR_R12, p);
12862         p += 4;
12863         bfd_put_32 (s->owner, BCTR, p);
12864         break;
12865       }
12866   return TRUE;
12867 }
12868
12869 /* Build all the stubs associated with the current output file.
12870    The stubs are kept in a hash table attached to the main linker
12871    hash table.  This function is called via gldelf64ppc_finish.  */
12872
12873 bfd_boolean
12874 ppc64_elf_build_stubs (struct bfd_link_info *info,
12875                        char **stats)
12876 {
12877   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12878   struct map_stub *group;
12879   asection *stub_sec;
12880   bfd_byte *p;
12881   int stub_sec_count = 0;
12882
12883   if (htab == NULL)
12884     return FALSE;
12885
12886   /* Allocate memory to hold the linker stubs.  */
12887   for (stub_sec = htab->params->stub_bfd->sections;
12888        stub_sec != NULL;
12889        stub_sec = stub_sec->next)
12890     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12891         && stub_sec->size != 0)
12892       {
12893         stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
12894         if (stub_sec->contents == NULL)
12895           return FALSE;
12896         /* We want to check that built size is the same as calculated
12897            size.  rawsize is a convenient location to use.  */
12898         stub_sec->rawsize = stub_sec->size;
12899         stub_sec->size = 0;
12900       }
12901
12902   if (htab->glink != NULL && htab->glink->size != 0)
12903     {
12904       unsigned int indx;
12905       bfd_vma plt0;
12906
12907       /* Build the .glink plt call stub.  */
12908       if (htab->params->emit_stub_syms)
12909         {
12910           struct elf_link_hash_entry *h;
12911           h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
12912                                     TRUE, FALSE, FALSE);
12913           if (h == NULL)
12914             return FALSE;
12915           if (h->root.type == bfd_link_hash_new)
12916             {
12917               h->root.type = bfd_link_hash_defined;
12918               h->root.u.def.section = htab->glink;
12919               h->root.u.def.value = 8;
12920               h->ref_regular = 1;
12921               h->def_regular = 1;
12922               h->ref_regular_nonweak = 1;
12923               h->forced_local = 1;
12924               h->non_elf = 0;
12925               h->root.linker_def = 1;
12926             }
12927         }
12928       plt0 = (htab->elf.splt->output_section->vma
12929               + htab->elf.splt->output_offset
12930               - 16);
12931       if (info->emitrelocations)
12932         {
12933           Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
12934           if (r == NULL)
12935             return FALSE;
12936           r->r_offset = (htab->glink->output_offset
12937                          + htab->glink->output_section->vma);
12938           r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
12939           r->r_addend = plt0;
12940         }
12941       p = htab->glink->contents;
12942       plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
12943       bfd_put_64 (htab->glink->owner, plt0, p);
12944       p += 8;
12945       if (htab->opd_abi)
12946         {
12947           bfd_put_32 (htab->glink->owner, MFLR_R12, p);
12948           p += 4;
12949           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12950           p += 4;
12951           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12952           p += 4;
12953           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12954           p += 4;
12955           bfd_put_32 (htab->glink->owner, MTLR_R12, p);
12956           p += 4;
12957           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12958           p += 4;
12959           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12960           p += 4;
12961           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
12962           p += 4;
12963           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12964           p += 4;
12965           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
12966           p += 4;
12967         }
12968       else
12969         {
12970           bfd_put_32 (htab->glink->owner, MFLR_R0, p);
12971           p += 4;
12972           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12973           p += 4;
12974           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12975           p += 4;
12976           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12977           p += 4;
12978           bfd_put_32 (htab->glink->owner, MTLR_R0, p);
12979           p += 4;
12980           bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
12981           p += 4;
12982           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12983           p += 4;
12984           bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
12985           p += 4;
12986           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12987           p += 4;
12988           bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
12989           p += 4;
12990           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12991           p += 4;
12992           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
12993           p += 4;
12994         }
12995       bfd_put_32 (htab->glink->owner, BCTR, p);
12996       p += 4;
12997       while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
12998         {
12999           bfd_put_32 (htab->glink->owner, NOP, p);
13000           p += 4;
13001         }
13002
13003       /* Build the .glink lazy link call stubs.  */
13004       indx = 0;
13005       while (p < htab->glink->contents + htab->glink->rawsize)
13006         {
13007           if (htab->opd_abi)
13008             {
13009               if (indx < 0x8000)
13010                 {
13011                   bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
13012                   p += 4;
13013                 }
13014               else
13015                 {
13016                   bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
13017                   p += 4;
13018                   bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
13019                               p);
13020                   p += 4;
13021                 }
13022             }
13023           bfd_put_32 (htab->glink->owner,
13024                       B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
13025           indx++;
13026           p += 4;
13027         }
13028
13029       /* Build .glink global entry stubs.  */
13030       if (htab->glink->size > htab->glink->rawsize)
13031         elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
13032     }
13033
13034   if (htab->brlt != NULL && htab->brlt->size != 0)
13035     {
13036       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
13037                                          htab->brlt->size);
13038       if (htab->brlt->contents == NULL)
13039         return FALSE;
13040     }
13041   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
13042     {
13043       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
13044                                             htab->relbrlt->size);
13045       if (htab->relbrlt->contents == NULL)
13046         return FALSE;
13047     }
13048
13049   /* Build the stubs as directed by the stub hash table.  */
13050   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
13051
13052   for (group = htab->group; group != NULL; group = group->next)
13053     if (group->needs_save_res)
13054       {
13055         stub_sec = group->stub_sec;
13056         memcpy (stub_sec->contents + stub_sec->size, htab->sfpr->contents,
13057                 htab->sfpr->size);
13058         if (htab->params->emit_stub_syms)
13059           {
13060             unsigned int i;
13061
13062             for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
13063               if (!sfpr_define (info, &save_res_funcs[i], stub_sec))
13064                 return FALSE;
13065           }
13066         stub_sec->size += htab->sfpr->size;
13067       }
13068
13069   if (htab->relbrlt != NULL)
13070     htab->relbrlt->reloc_count = 0;
13071
13072   if (htab->params->plt_stub_align != 0)
13073     for (stub_sec = htab->params->stub_bfd->sections;
13074          stub_sec != NULL;
13075          stub_sec = stub_sec->next)
13076       if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
13077         stub_sec->size = ((stub_sec->size
13078                            + (1 << htab->params->plt_stub_align) - 1)
13079                           & -(1 << htab->params->plt_stub_align));
13080
13081   for (stub_sec = htab->params->stub_bfd->sections;
13082        stub_sec != NULL;
13083        stub_sec = stub_sec->next)
13084     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
13085       {
13086         stub_sec_count += 1;
13087         if (stub_sec->rawsize != stub_sec->size)
13088           break;
13089       }
13090
13091   /* Note that the glink_eh_frame check here is not only testing that
13092      the generated size matched the calculated size but also that
13093      bfd_elf_discard_info didn't make any changes to the section.  */
13094   if (stub_sec != NULL
13095       || (htab->glink_eh_frame != NULL
13096           && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
13097     {
13098       htab->stub_error = TRUE;
13099       info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
13100     }
13101
13102   if (htab->stub_error)
13103     return FALSE;
13104
13105   if (stats != NULL)
13106     {
13107       *stats = bfd_malloc (500);
13108       if (*stats == NULL)
13109         return FALSE;
13110
13111       sprintf (*stats, _("linker stubs in %u group%s\n"
13112                          "  branch       %lu\n"
13113                          "  toc adjust   %lu\n"
13114                          "  long branch  %lu\n"
13115                          "  long toc adj %lu\n"
13116                          "  plt call     %lu\n"
13117                          "  plt call toc %lu\n"
13118                          "  global entry %lu"),
13119                stub_sec_count,
13120                stub_sec_count == 1 ? "" : "s",
13121                htab->stub_count[ppc_stub_long_branch - 1],
13122                htab->stub_count[ppc_stub_long_branch_r2off - 1],
13123                htab->stub_count[ppc_stub_plt_branch - 1],
13124                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
13125                htab->stub_count[ppc_stub_plt_call - 1],
13126                htab->stub_count[ppc_stub_plt_call_r2save - 1],
13127                htab->stub_count[ppc_stub_global_entry - 1]);
13128     }
13129   return TRUE;
13130 }
13131
13132 /* This function undoes the changes made by add_symbol_adjust.  */
13133
13134 static bfd_boolean
13135 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
13136 {
13137   struct ppc_link_hash_entry *eh;
13138
13139   if (h->root.type == bfd_link_hash_indirect)
13140     return TRUE;
13141
13142   eh = (struct ppc_link_hash_entry *) h;
13143   if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
13144     return TRUE;
13145
13146   eh->elf.root.type = bfd_link_hash_undefined;
13147   return TRUE;
13148 }
13149
13150 void
13151 ppc64_elf_restore_symbols (struct bfd_link_info *info)
13152 {
13153   struct ppc_link_hash_table *htab = ppc_hash_table (info);
13154
13155   if (htab != NULL)
13156     elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
13157 }
13158
13159 /* What to do when ld finds relocations against symbols defined in
13160    discarded sections.  */
13161
13162 static unsigned int
13163 ppc64_elf_action_discarded (asection *sec)
13164 {
13165   if (strcmp (".opd", sec->name) == 0)
13166     return 0;
13167
13168   if (strcmp (".toc", sec->name) == 0)
13169     return 0;
13170
13171   if (strcmp (".toc1", sec->name) == 0)
13172     return 0;
13173
13174   return _bfd_elf_default_action_discarded (sec);
13175 }
13176
13177 /* The RELOCATE_SECTION function is called by the ELF backend linker
13178    to handle the relocations for a section.
13179
13180    The relocs are always passed as Rela structures; if the section
13181    actually uses Rel structures, the r_addend field will always be
13182    zero.
13183
13184    This function is responsible for adjust the section contents as
13185    necessary, and (if using Rela relocs and generating a
13186    relocatable output file) adjusting the reloc addend as
13187    necessary.
13188
13189    This function does not have to worry about setting the reloc
13190    address or the reloc symbol index.
13191
13192    LOCAL_SYMS is a pointer to the swapped in local symbols.
13193
13194    LOCAL_SECTIONS is an array giving the section in the input file
13195    corresponding to the st_shndx field of each local symbol.
13196
13197    The global hash table entry for the global symbols can be found
13198    via elf_sym_hashes (input_bfd).
13199
13200    When generating relocatable output, this function must handle
13201    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
13202    going to be the section symbol corresponding to the output
13203    section, which means that the addend must be adjusted
13204    accordingly.  */
13205
13206 static bfd_boolean
13207 ppc64_elf_relocate_section (bfd *output_bfd,
13208                             struct bfd_link_info *info,
13209                             bfd *input_bfd,
13210                             asection *input_section,
13211                             bfd_byte *contents,
13212                             Elf_Internal_Rela *relocs,
13213                             Elf_Internal_Sym *local_syms,
13214                             asection **local_sections)
13215 {
13216   struct ppc_link_hash_table *htab;
13217   Elf_Internal_Shdr *symtab_hdr;
13218   struct elf_link_hash_entry **sym_hashes;
13219   Elf_Internal_Rela *rel;
13220   Elf_Internal_Rela *wrel;
13221   Elf_Internal_Rela *relend;
13222   Elf_Internal_Rela outrel;
13223   bfd_byte *loc;
13224   struct got_entry **local_got_ents;
13225   bfd_vma TOCstart;
13226   bfd_boolean ret = TRUE;
13227   bfd_boolean is_opd;
13228   /* Assume 'at' branch hints.  */
13229   bfd_boolean is_isa_v2 = TRUE;
13230   bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
13231
13232   /* Initialize howto table if needed.  */
13233   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
13234     ppc_howto_init ();
13235
13236   htab = ppc_hash_table (info);
13237   if (htab == NULL)
13238     return FALSE;
13239
13240   /* Don't relocate stub sections.  */
13241   if (input_section->owner == htab->params->stub_bfd)
13242     return TRUE;
13243
13244   BFD_ASSERT (is_ppc64_elf (input_bfd));
13245
13246   local_got_ents = elf_local_got_ents (input_bfd);
13247   TOCstart = elf_gp (output_bfd);
13248   symtab_hdr = &elf_symtab_hdr (input_bfd);
13249   sym_hashes = elf_sym_hashes (input_bfd);
13250   is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
13251
13252   rel = wrel = relocs;
13253   relend = relocs + input_section->reloc_count;
13254   for (; rel < relend; wrel++, rel++)
13255     {
13256       enum elf_ppc64_reloc_type r_type;
13257       bfd_vma addend;
13258       bfd_reloc_status_type r;
13259       Elf_Internal_Sym *sym;
13260       asection *sec;
13261       struct elf_link_hash_entry *h_elf;
13262       struct ppc_link_hash_entry *h;
13263       struct ppc_link_hash_entry *fdh;
13264       const char *sym_name;
13265       unsigned long r_symndx, toc_symndx;
13266       bfd_vma toc_addend;
13267       unsigned char tls_mask, tls_gd, tls_type;
13268       unsigned char sym_type;
13269       bfd_vma relocation;
13270       bfd_boolean unresolved_reloc;
13271       bfd_boolean warned;
13272       enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
13273       unsigned int insn;
13274       unsigned int mask;
13275       struct ppc_stub_hash_entry *stub_entry;
13276       bfd_vma max_br_offset;
13277       bfd_vma from;
13278       Elf_Internal_Rela orig_rel;
13279       reloc_howto_type *howto;
13280       struct reloc_howto_struct alt_howto;
13281
13282     again:
13283       orig_rel = *rel;
13284
13285       r_type = ELF64_R_TYPE (rel->r_info);
13286       r_symndx = ELF64_R_SYM (rel->r_info);
13287
13288       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
13289          symbol of the previous ADDR64 reloc.  The symbol gives us the
13290          proper TOC base to use.  */
13291       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
13292           && wrel != relocs
13293           && ELF64_R_TYPE (wrel[-1].r_info) == R_PPC64_ADDR64
13294           && is_opd)
13295         r_symndx = ELF64_R_SYM (wrel[-1].r_info);
13296
13297       sym = NULL;
13298       sec = NULL;
13299       h_elf = NULL;
13300       sym_name = NULL;
13301       unresolved_reloc = FALSE;
13302       warned = FALSE;
13303
13304       if (r_symndx < symtab_hdr->sh_info)
13305         {
13306           /* It's a local symbol.  */
13307           struct _opd_sec_data *opd;
13308
13309           sym = local_syms + r_symndx;
13310           sec = local_sections[r_symndx];
13311           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
13312           sym_type = ELF64_ST_TYPE (sym->st_info);
13313           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
13314           opd = get_opd_info (sec);
13315           if (opd != NULL && opd->adjust != NULL)
13316             {
13317               long adjust = opd->adjust[OPD_NDX (sym->st_value
13318                                                  + rel->r_addend)];
13319               if (adjust == -1)
13320                 relocation = 0;
13321               else
13322                 {
13323                   /* If this is a relocation against the opd section sym
13324                      and we have edited .opd, adjust the reloc addend so
13325                      that ld -r and ld --emit-relocs output is correct.
13326                      If it is a reloc against some other .opd symbol,
13327                      then the symbol value will be adjusted later.  */
13328                   if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
13329                     rel->r_addend += adjust;
13330                   else
13331                     relocation += adjust;
13332                 }
13333             }
13334         }
13335       else
13336         {
13337           bfd_boolean ignored;
13338
13339           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
13340                                    r_symndx, symtab_hdr, sym_hashes,
13341                                    h_elf, sec, relocation,
13342                                    unresolved_reloc, warned, ignored);
13343           sym_name = h_elf->root.root.string;
13344           sym_type = h_elf->type;
13345           if (sec != NULL
13346               && sec->owner == output_bfd
13347               && strcmp (sec->name, ".opd") == 0)
13348             {
13349               /* This is a symbol defined in a linker script.  All
13350                  such are defined in output sections, even those
13351                  defined by simple assignment from a symbol defined in
13352                  an input section.  Transfer the symbol to an
13353                  appropriate input .opd section, so that a branch to
13354                  this symbol will be mapped to the location specified
13355                  by the opd entry.  */
13356               struct bfd_link_order *lo;
13357               for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
13358                 if (lo->type == bfd_indirect_link_order)
13359                   {
13360                     asection *isec = lo->u.indirect.section;
13361                     if (h_elf->root.u.def.value >= isec->output_offset
13362                         && h_elf->root.u.def.value < (isec->output_offset
13363                                                       + isec->size))
13364                       {
13365                         h_elf->root.u.def.value -= isec->output_offset;
13366                         h_elf->root.u.def.section = isec;
13367                         sec = isec;
13368                         break;
13369                       }
13370                   }
13371             }
13372         }
13373       h = (struct ppc_link_hash_entry *) h_elf;
13374
13375       if (sec != NULL && discarded_section (sec))
13376         {
13377           _bfd_clear_contents (ppc64_elf_howto_table[r_type],
13378                                input_bfd, input_section,
13379                                contents + rel->r_offset);
13380           wrel->r_offset = rel->r_offset;
13381           wrel->r_info = 0;
13382           wrel->r_addend = 0;
13383
13384           /* For ld -r, remove relocations in debug sections against
13385              sections defined in discarded sections.  Not done for
13386              non-debug to preserve relocs in .eh_frame which the
13387              eh_frame editing code expects to be present.  */
13388           if (bfd_link_relocatable (info)
13389               && (input_section->flags & SEC_DEBUGGING))
13390             wrel--;
13391
13392           continue;
13393         }
13394
13395       if (bfd_link_relocatable (info))
13396         goto copy_reloc;
13397
13398       if (h != NULL && &h->elf == htab->elf.hgot)
13399         {
13400           relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
13401           sec = bfd_abs_section_ptr;
13402           unresolved_reloc = FALSE;
13403         }
13404
13405       /* TLS optimizations.  Replace instruction sequences and relocs
13406          based on information we collected in tls_optimize.  We edit
13407          RELOCS so that --emit-relocs will output something sensible
13408          for the final instruction stream.  */
13409       tls_mask = 0;
13410       tls_gd = 0;
13411       toc_symndx = 0;
13412       if (h != NULL)
13413         tls_mask = h->tls_mask;
13414       else if (local_got_ents != NULL)
13415         {
13416           struct plt_entry **local_plt = (struct plt_entry **)
13417             (local_got_ents + symtab_hdr->sh_info);
13418           unsigned char *lgot_masks = (unsigned char *)
13419             (local_plt + symtab_hdr->sh_info);
13420           tls_mask = lgot_masks[r_symndx];
13421         }
13422       if (tls_mask == 0
13423           && (r_type == R_PPC64_TLS
13424               || r_type == R_PPC64_TLSGD
13425               || r_type == R_PPC64_TLSLD))
13426         {
13427           /* Check for toc tls entries.  */
13428           unsigned char *toc_tls;
13429
13430           if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13431                              &local_syms, rel, input_bfd))
13432             return FALSE;
13433
13434           if (toc_tls)
13435             tls_mask = *toc_tls;
13436         }
13437
13438       /* Check that tls relocs are used with tls syms, and non-tls
13439          relocs are used with non-tls syms.  */
13440       if (r_symndx != STN_UNDEF
13441           && r_type != R_PPC64_NONE
13442           && (h == NULL
13443               || h->elf.root.type == bfd_link_hash_defined
13444               || h->elf.root.type == bfd_link_hash_defweak)
13445           && (IS_PPC64_TLS_RELOC (r_type)
13446               != (sym_type == STT_TLS
13447                   || (sym_type == STT_SECTION
13448                       && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13449         {
13450           if (tls_mask != 0
13451               && (r_type == R_PPC64_TLS
13452                   || r_type == R_PPC64_TLSGD
13453                   || r_type == R_PPC64_TLSLD))
13454             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
13455             ;
13456           else
13457             info->callbacks->einfo
13458               (!IS_PPC64_TLS_RELOC (r_type)
13459                ? _("%P: %H: %s used with TLS symbol `%T'\n")
13460                : _("%P: %H: %s used with non-TLS symbol `%T'\n"),
13461                input_bfd, input_section, rel->r_offset,
13462                ppc64_elf_howto_table[r_type]->name,
13463                sym_name);
13464         }
13465
13466       /* Ensure reloc mapping code below stays sane.  */
13467       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13468           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13469           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
13470           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13471           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13472           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13473           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
13474           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13475           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13476           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13477         abort ();
13478
13479       switch (r_type)
13480         {
13481         default:
13482           break;
13483
13484         case R_PPC64_LO_DS_OPT:
13485           insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13486           if ((insn & (0x3f << 26)) != 58u << 26)
13487             abort ();
13488           insn += (14u << 26) - (58u << 26);
13489           bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13490           r_type = R_PPC64_TOC16_LO;
13491           rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13492           break;
13493
13494         case R_PPC64_TOC16:
13495         case R_PPC64_TOC16_LO:
13496         case R_PPC64_TOC16_DS:
13497         case R_PPC64_TOC16_LO_DS:
13498           {
13499             /* Check for toc tls entries.  */
13500             unsigned char *toc_tls;
13501             int retval;
13502
13503             retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13504                                    &local_syms, rel, input_bfd);
13505             if (retval == 0)
13506               return FALSE;
13507
13508             if (toc_tls)
13509               {
13510                 tls_mask = *toc_tls;
13511                 if (r_type == R_PPC64_TOC16_DS
13512                     || r_type == R_PPC64_TOC16_LO_DS)
13513                   {
13514                     if (tls_mask != 0
13515                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13516                       goto toctprel;
13517                   }
13518                 else
13519                   {
13520                     /* If we found a GD reloc pair, then we might be
13521                        doing a GD->IE transition.  */
13522                     if (retval == 2)
13523                       {
13524                         tls_gd = TLS_TPRELGD;
13525                         if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13526                           goto tls_ldgd_opt;
13527                       }
13528                     else if (retval == 3)
13529                       {
13530                         if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13531                           goto tls_ldgd_opt;
13532                       }
13533                   }
13534               }
13535           }
13536           break;
13537
13538         case R_PPC64_GOT_TPREL16_HI:
13539         case R_PPC64_GOT_TPREL16_HA:
13540           if (tls_mask != 0
13541               && (tls_mask & TLS_TPREL) == 0)
13542             {
13543               rel->r_offset -= d_offset;
13544               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13545               r_type = R_PPC64_NONE;
13546               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13547             }
13548           break;
13549
13550         case R_PPC64_GOT_TPREL16_DS:
13551         case R_PPC64_GOT_TPREL16_LO_DS:
13552           if (tls_mask != 0
13553               && (tls_mask & TLS_TPREL) == 0)
13554             {
13555             toctprel:
13556               insn = bfd_get_32 (output_bfd,
13557                                  contents + rel->r_offset - d_offset);
13558               insn &= 31 << 21;
13559               insn |= 0x3c0d0000;       /* addis 0,13,0 */
13560               bfd_put_32 (output_bfd, insn,
13561                           contents + rel->r_offset - d_offset);
13562               r_type = R_PPC64_TPREL16_HA;
13563               if (toc_symndx != 0)
13564                 {
13565                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13566                   rel->r_addend = toc_addend;
13567                   /* We changed the symbol.  Start over in order to
13568                      get h, sym, sec etc. right.  */
13569                   goto again;
13570                 }
13571               else
13572                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13573             }
13574           break;
13575
13576         case R_PPC64_TLS:
13577           if (tls_mask != 0
13578               && (tls_mask & TLS_TPREL) == 0)
13579             {
13580               insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
13581               insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13582               if (insn == 0)
13583                 abort ();
13584               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13585               /* Was PPC64_TLS which sits on insn boundary, now
13586                  PPC64_TPREL16_LO which is at low-order half-word.  */
13587               rel->r_offset += d_offset;
13588               r_type = R_PPC64_TPREL16_LO;
13589               if (toc_symndx != 0)
13590                 {
13591                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13592                   rel->r_addend = toc_addend;
13593                   /* We changed the symbol.  Start over in order to
13594                      get h, sym, sec etc. right.  */
13595                   goto again;
13596                 }
13597               else
13598                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13599             }
13600           break;
13601
13602         case R_PPC64_GOT_TLSGD16_HI:
13603         case R_PPC64_GOT_TLSGD16_HA:
13604           tls_gd = TLS_TPRELGD;
13605           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13606             goto tls_gdld_hi;
13607           break;
13608
13609         case R_PPC64_GOT_TLSLD16_HI:
13610         case R_PPC64_GOT_TLSLD16_HA:
13611           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13612             {
13613             tls_gdld_hi:
13614               if ((tls_mask & tls_gd) != 0)
13615                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13616                           + R_PPC64_GOT_TPREL16_DS);
13617               else
13618                 {
13619                   rel->r_offset -= d_offset;
13620                   bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13621                   r_type = R_PPC64_NONE;
13622                 }
13623               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13624             }
13625           break;
13626
13627         case R_PPC64_GOT_TLSGD16:
13628         case R_PPC64_GOT_TLSGD16_LO:
13629           tls_gd = TLS_TPRELGD;
13630           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13631             goto tls_ldgd_opt;
13632           break;
13633
13634         case R_PPC64_GOT_TLSLD16:
13635         case R_PPC64_GOT_TLSLD16_LO:
13636           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13637             {
13638               unsigned int insn1, insn2, insn3;
13639               bfd_vma offset;
13640
13641             tls_ldgd_opt:
13642               offset = (bfd_vma) -1;
13643               /* If not using the newer R_PPC64_TLSGD/LD to mark
13644                  __tls_get_addr calls, we must trust that the call
13645                  stays with its arg setup insns, ie. that the next
13646                  reloc is the __tls_get_addr call associated with
13647                  the current reloc.  Edit both insns.  */
13648               if (input_section->has_tls_get_addr_call
13649                   && rel + 1 < relend
13650                   && branch_reloc_hash_match (input_bfd, rel + 1,
13651                                               htab->tls_get_addr,
13652                                               htab->tls_get_addr_fd))
13653                 offset = rel[1].r_offset;
13654               /* We read the low GOT_TLS (or TOC16) insn because we
13655                  need to keep the destination reg.  It may be
13656                  something other than the usual r3, and moved to r3
13657                  before the call by intervening code.  */
13658               insn1 = bfd_get_32 (output_bfd,
13659                                   contents + rel->r_offset - d_offset);
13660               if ((tls_mask & tls_gd) != 0)
13661                 {
13662                   /* IE */
13663                   insn1 &= (0x1f << 21) | (0x1f << 16);
13664                   insn1 |= 58 << 26;    /* ld */
13665                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13666                   if (offset != (bfd_vma) -1)
13667                     rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13668                   if ((tls_mask & TLS_EXPLICIT) == 0)
13669                     r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13670                               + R_PPC64_GOT_TPREL16_DS);
13671                   else
13672                     r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13673                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13674                 }
13675               else
13676                 {
13677                   /* LE */
13678                   insn1 &= 0x1f << 21;
13679                   insn1 |= 0x3c0d0000;  /* addis r,13,0 */
13680                   insn2 = 0x38630000;   /* addi 3,3,0 */
13681                   if (tls_gd == 0)
13682                     {
13683                       /* Was an LD reloc.  */
13684                       if (toc_symndx)
13685                         sec = local_sections[toc_symndx];
13686                       for (r_symndx = 0;
13687                            r_symndx < symtab_hdr->sh_info;
13688                            r_symndx++)
13689                         if (local_sections[r_symndx] == sec)
13690                           break;
13691                       if (r_symndx >= symtab_hdr->sh_info)
13692                         r_symndx = STN_UNDEF;
13693                       rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13694                       if (r_symndx != STN_UNDEF)
13695                         rel->r_addend -= (local_syms[r_symndx].st_value
13696                                           + sec->output_offset
13697                                           + sec->output_section->vma);
13698                     }
13699                   else if (toc_symndx != 0)
13700                     {
13701                       r_symndx = toc_symndx;
13702                       rel->r_addend = toc_addend;
13703                     }
13704                   r_type = R_PPC64_TPREL16_HA;
13705                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13706                   if (offset != (bfd_vma) -1)
13707                     {
13708                       rel[1].r_info = ELF64_R_INFO (r_symndx,
13709                                                     R_PPC64_TPREL16_LO);
13710                       rel[1].r_offset = offset + d_offset;
13711                       rel[1].r_addend = rel->r_addend;
13712                     }
13713                 }
13714               bfd_put_32 (output_bfd, insn1,
13715                           contents + rel->r_offset - d_offset);
13716               if (offset != (bfd_vma) -1)
13717                 {
13718                   insn3 = bfd_get_32 (output_bfd,
13719                                       contents + offset + 4);
13720                   if (insn3 == NOP
13721                       || insn3 == CROR_151515 || insn3 == CROR_313131)
13722                     {
13723                       rel[1].r_offset += 4;
13724                       bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13725                       insn2 = NOP;
13726                     }
13727                   bfd_put_32 (output_bfd, insn2, contents + offset);
13728                 }
13729               if ((tls_mask & tls_gd) == 0
13730                   && (tls_gd == 0 || toc_symndx != 0))
13731                 {
13732                   /* We changed the symbol.  Start over in order
13733                      to get h, sym, sec etc. right.  */
13734                   goto again;
13735                 }
13736             }
13737           break;
13738
13739         case R_PPC64_TLSGD:
13740           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13741             {
13742               unsigned int insn2, insn3;
13743               bfd_vma offset = rel->r_offset;
13744
13745               if ((tls_mask & TLS_TPRELGD) != 0)
13746                 {
13747                   /* IE */
13748                   r_type = R_PPC64_NONE;
13749                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13750                 }
13751               else
13752                 {
13753                   /* LE */
13754                   if (toc_symndx != 0)
13755                     {
13756                       r_symndx = toc_symndx;
13757                       rel->r_addend = toc_addend;
13758                     }
13759                   r_type = R_PPC64_TPREL16_LO;
13760                   rel->r_offset = offset + d_offset;
13761                   insn2 = 0x38630000;   /* addi 3,3,0 */
13762                 }
13763               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13764               /* Zap the reloc on the _tls_get_addr call too.  */
13765               BFD_ASSERT (offset == rel[1].r_offset);
13766               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13767               insn3 = bfd_get_32 (output_bfd,
13768                                   contents + offset + 4);
13769               if (insn3 == NOP
13770                   || insn3 == CROR_151515 || insn3 == CROR_313131)
13771                 {
13772                   rel->r_offset += 4;
13773                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13774                   insn2 = NOP;
13775                 }
13776               bfd_put_32 (output_bfd, insn2, contents + offset);
13777               if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
13778                 goto again;
13779             }
13780           break;
13781
13782         case R_PPC64_TLSLD:
13783           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13784             {
13785               unsigned int insn2, insn3;
13786               bfd_vma offset = rel->r_offset;
13787
13788               if (toc_symndx)
13789                 sec = local_sections[toc_symndx];
13790               for (r_symndx = 0;
13791                    r_symndx < symtab_hdr->sh_info;
13792                    r_symndx++)
13793                 if (local_sections[r_symndx] == sec)
13794                   break;
13795               if (r_symndx >= symtab_hdr->sh_info)
13796                 r_symndx = STN_UNDEF;
13797               rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13798               if (r_symndx != STN_UNDEF)
13799                 rel->r_addend -= (local_syms[r_symndx].st_value
13800                                   + sec->output_offset
13801                                   + sec->output_section->vma);
13802
13803               r_type = R_PPC64_TPREL16_LO;
13804               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13805               rel->r_offset = offset + d_offset;
13806               /* Zap the reloc on the _tls_get_addr call too.  */
13807               BFD_ASSERT (offset == rel[1].r_offset);
13808               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13809               insn2 = 0x38630000;       /* addi 3,3,0 */
13810               insn3 = bfd_get_32 (output_bfd,
13811                                   contents + offset + 4);
13812               if (insn3 == NOP
13813                   || insn3 == CROR_151515 || insn3 == CROR_313131)
13814                 {
13815                   rel->r_offset += 4;
13816                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13817                   insn2 = NOP;
13818                 }
13819               bfd_put_32 (output_bfd, insn2, contents + offset);
13820               goto again;
13821             }
13822           break;
13823
13824         case R_PPC64_DTPMOD64:
13825           if (rel + 1 < relend
13826               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
13827               && rel[1].r_offset == rel->r_offset + 8)
13828             {
13829               if ((tls_mask & TLS_GD) == 0)
13830                 {
13831                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
13832                   if ((tls_mask & TLS_TPRELGD) != 0)
13833                     r_type = R_PPC64_TPREL64;
13834                   else
13835                     {
13836                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13837                       r_type = R_PPC64_NONE;
13838                     }
13839                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13840                 }
13841             }
13842           else
13843             {
13844               if ((tls_mask & TLS_LD) == 0)
13845                 {
13846                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13847                   r_type = R_PPC64_NONE;
13848                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13849                 }
13850             }
13851           break;
13852
13853         case R_PPC64_TPREL64:
13854           if ((tls_mask & TLS_TPREL) == 0)
13855             {
13856               r_type = R_PPC64_NONE;
13857               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13858             }
13859           break;
13860
13861         case R_PPC64_ENTRY:
13862           relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
13863           if (!bfd_link_pic (info)
13864               && !info->traditional_format
13865               && relocation + 0x80008000 <= 0xffffffff)
13866             {
13867               unsigned int insn1, insn2;
13868
13869               insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
13870               insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
13871               if ((insn1 & ~0xfffc) == LD_R2_0R12
13872                   && insn2 == ADD_R2_R2_R12)
13873                 {
13874                   bfd_put_32 (output_bfd,
13875                               LIS_R2 + PPC_HA (relocation),
13876                               contents + rel->r_offset);
13877                   bfd_put_32 (output_bfd,
13878                               ADDI_R2_R2 + PPC_LO (relocation),
13879                               contents + rel->r_offset + 4);
13880                 }
13881             }
13882           else
13883             {
13884               relocation -= (rel->r_offset
13885                              + input_section->output_offset
13886                              + input_section->output_section->vma);
13887               if (relocation + 0x80008000 <= 0xffffffff)
13888                 {
13889                   unsigned int insn1, insn2;
13890
13891                   insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
13892                   insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
13893                   if ((insn1 & ~0xfffc) == LD_R2_0R12
13894                       && insn2 == ADD_R2_R2_R12)
13895                     {
13896                       bfd_put_32 (output_bfd,
13897                                   ADDIS_R2_R12 + PPC_HA (relocation),
13898                                   contents + rel->r_offset);
13899                       bfd_put_32 (output_bfd,
13900                                   ADDI_R2_R2 + PPC_LO (relocation),
13901                                   contents + rel->r_offset + 4);
13902                     }
13903                 }
13904             }
13905           break;
13906
13907         case R_PPC64_REL16_HA:
13908           /* If we are generating a non-PIC executable, edit
13909              .  0:      addis 2,12,.TOC.-0b@ha
13910              .          addi 2,2,.TOC.-0b@l
13911              used by ELFv2 global entry points to set up r2, to
13912              .          lis 2,.TOC.@ha
13913              .          addi 2,2,.TOC.@l
13914              if .TOC. is in range.  */
13915           if (!bfd_link_pic (info)
13916               && !info->traditional_format
13917               && !htab->opd_abi
13918               && h != NULL && &h->elf == htab->elf.hgot
13919               && rel + 1 < relend
13920               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
13921               && rel[1].r_offset == rel->r_offset + 4
13922               && rel[1].r_addend == rel->r_addend + 4
13923               && relocation + 0x80008000 <= 0xffffffff)
13924             {
13925               unsigned int insn1, insn2;
13926               bfd_vma offset = rel->r_offset - d_offset;
13927               insn1 = bfd_get_32 (output_bfd, contents + offset);
13928               insn2 = bfd_get_32 (output_bfd, contents + offset + 4);
13929               if ((insn1 & 0xffff0000) == ADDIS_R2_R12
13930                   && (insn2 & 0xffff0000) == ADDI_R2_R2)
13931                 {
13932                   r_type = R_PPC64_ADDR16_HA;
13933                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13934                   rel->r_addend -= d_offset;
13935                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
13936                   rel[1].r_addend -= d_offset + 4;
13937                   bfd_put_32 (output_bfd, LIS_R2, contents + offset);
13938                 }
13939             }
13940           break;
13941         }
13942
13943       /* Handle other relocations that tweak non-addend part of insn.  */
13944       insn = 0;
13945       max_br_offset = 1 << 25;
13946       addend = rel->r_addend;
13947       reloc_dest = DEST_NORMAL;
13948       switch (r_type)
13949         {
13950         default:
13951           break;
13952
13953         case R_PPC64_TOCSAVE:
13954           if (relocation + addend == (rel->r_offset
13955                                       + input_section->output_offset
13956                                       + input_section->output_section->vma)
13957               && tocsave_find (htab, NO_INSERT,
13958                                &local_syms, rel, input_bfd))
13959             {
13960               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
13961               if (insn == NOP
13962                   || insn == CROR_151515 || insn == CROR_313131)
13963                 bfd_put_32 (input_bfd,
13964                             STD_R2_0R1 + STK_TOC (htab),
13965                             contents + rel->r_offset);
13966             }
13967           break;
13968
13969           /* Branch taken prediction relocations.  */
13970         case R_PPC64_ADDR14_BRTAKEN:
13971         case R_PPC64_REL14_BRTAKEN:
13972           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
13973           /* Fall thru.  */
13974
13975           /* Branch not taken prediction relocations.  */
13976         case R_PPC64_ADDR14_BRNTAKEN:
13977         case R_PPC64_REL14_BRNTAKEN:
13978           insn |= bfd_get_32 (output_bfd,
13979                               contents + rel->r_offset) & ~(0x01 << 21);
13980           /* Fall thru.  */
13981
13982         case R_PPC64_REL14:
13983           max_br_offset = 1 << 15;
13984           /* Fall thru.  */
13985
13986         case R_PPC64_REL24:
13987           /* Calls to functions with a different TOC, such as calls to
13988              shared objects, need to alter the TOC pointer.  This is
13989              done using a linkage stub.  A REL24 branching to these
13990              linkage stubs needs to be followed by a nop, as the nop
13991              will be replaced with an instruction to restore the TOC
13992              base pointer.  */
13993           fdh = h;
13994           if (h != NULL
13995               && h->oh != NULL
13996               && h->oh->is_func_descriptor)
13997             fdh = ppc_follow_link (h->oh);
13998           stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
13999                                            htab);
14000           if (stub_entry != NULL
14001               && (stub_entry->stub_type == ppc_stub_plt_call
14002                   || stub_entry->stub_type == ppc_stub_plt_call_r2save
14003                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
14004                   || stub_entry->stub_type == ppc_stub_long_branch_r2off))
14005             {
14006               bfd_boolean can_plt_call = FALSE;
14007
14008               /* All of these stubs will modify r2, so there must be a
14009                  branch and link followed by a nop.  The nop is
14010                  replaced by an insn to restore r2.  */
14011               if (rel->r_offset + 8 <= input_section->size)
14012                 {
14013                   unsigned long br;
14014
14015                   br = bfd_get_32 (input_bfd,
14016                                    contents + rel->r_offset);
14017                   if ((br & 1) != 0)
14018                     {
14019                       unsigned long nop;
14020
14021                       nop = bfd_get_32 (input_bfd,
14022                                         contents + rel->r_offset + 4);
14023                       if (nop == NOP
14024                           || nop == CROR_151515 || nop == CROR_313131)
14025                         {
14026                           if (h != NULL
14027                               && (h == htab->tls_get_addr_fd
14028                                   || h == htab->tls_get_addr)
14029                               && htab->params->tls_get_addr_opt)
14030                             {
14031                               /* Special stub used, leave nop alone.  */
14032                             }
14033                           else
14034                             bfd_put_32 (input_bfd,
14035                                         LD_R2_0R1 + STK_TOC (htab),
14036                                         contents + rel->r_offset + 4);
14037                           can_plt_call = TRUE;
14038                         }
14039                     }
14040                 }
14041
14042               if (!can_plt_call && h != NULL)
14043                 {
14044                   const char *name = h->elf.root.root.string;
14045
14046                   if (*name == '.')
14047                     ++name;
14048
14049                   if (strncmp (name, "__libc_start_main", 17) == 0
14050                       && (name[17] == 0 || name[17] == '@'))
14051                     {
14052                       /* Allow crt1 branch to go via a toc adjusting
14053                          stub.  Other calls that never return could do
14054                          the same, if we could detect such.  */
14055                       can_plt_call = TRUE;
14056                     }
14057                 }
14058
14059               if (!can_plt_call)
14060                 {
14061                   /* g++ as of 20130507 emits self-calls without a
14062                      following nop.  This is arguably wrong since we
14063                      have conflicting information.  On the one hand a
14064                      global symbol and on the other a local call
14065                      sequence, but don't error for this special case.
14066                      It isn't possible to cheaply verify we have
14067                      exactly such a call.  Allow all calls to the same
14068                      section.  */
14069                   asection *code_sec = sec;
14070
14071                   if (get_opd_info (sec) != NULL)
14072                     {
14073                       bfd_vma off = (relocation + addend
14074                                      - sec->output_section->vma
14075                                      - sec->output_offset);
14076
14077                       opd_entry_value (sec, off, &code_sec, NULL, FALSE);
14078                     }
14079                   if (code_sec == input_section)
14080                     can_plt_call = TRUE;
14081                 }
14082
14083               if (!can_plt_call)
14084                 {
14085                   if (stub_entry->stub_type == ppc_stub_plt_call
14086                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14087                     info->callbacks->einfo
14088                       (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
14089                          "recompile with -fPIC\n"),
14090                        input_bfd, input_section, rel->r_offset, sym_name);
14091                   else
14092                     info->callbacks->einfo
14093                       (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
14094                          "(-mcmodel=small toc adjust stub)\n"),
14095                        input_bfd, input_section, rel->r_offset, sym_name);
14096
14097                   bfd_set_error (bfd_error_bad_value);
14098                   ret = FALSE;
14099                 }
14100
14101               if (can_plt_call
14102                   && (stub_entry->stub_type == ppc_stub_plt_call
14103                       || stub_entry->stub_type == ppc_stub_plt_call_r2save))
14104                 unresolved_reloc = FALSE;
14105             }
14106
14107           if ((stub_entry == NULL
14108                || stub_entry->stub_type == ppc_stub_long_branch
14109                || stub_entry->stub_type == ppc_stub_plt_branch)
14110               && get_opd_info (sec) != NULL)
14111             {
14112               /* The branch destination is the value of the opd entry. */
14113               bfd_vma off = (relocation + addend
14114                              - sec->output_section->vma
14115                              - sec->output_offset);
14116               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
14117               if (dest != (bfd_vma) -1)
14118                 {
14119                   relocation = dest;
14120                   addend = 0;
14121                   reloc_dest = DEST_OPD;
14122                 }
14123             }
14124
14125           /* If the branch is out of reach we ought to have a long
14126              branch stub.  */
14127           from = (rel->r_offset
14128                   + input_section->output_offset
14129                   + input_section->output_section->vma);
14130
14131           relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
14132                                                   ? fdh->elf.other
14133                                                   : sym->st_other);
14134
14135           if (stub_entry != NULL
14136               && (stub_entry->stub_type == ppc_stub_long_branch
14137                   || stub_entry->stub_type == ppc_stub_plt_branch)
14138               && (r_type == R_PPC64_ADDR14_BRTAKEN
14139                   || r_type == R_PPC64_ADDR14_BRNTAKEN
14140                   || (relocation + addend - from + max_br_offset
14141                       < 2 * max_br_offset)))
14142             /* Don't use the stub if this branch is in range.  */
14143             stub_entry = NULL;
14144
14145           if (stub_entry != NULL)
14146             {
14147               /* Munge up the value and addend so that we call the stub
14148                  rather than the procedure directly.  */
14149               asection *stub_sec = stub_entry->group->stub_sec;
14150
14151               if (stub_entry->stub_type == ppc_stub_save_res)
14152                 relocation += (stub_sec->output_offset
14153                                + stub_sec->output_section->vma
14154                                + stub_sec->size - htab->sfpr->size
14155                                - htab->sfpr->output_offset
14156                                - htab->sfpr->output_section->vma);
14157               else
14158                 relocation = (stub_entry->stub_offset
14159                               + stub_sec->output_offset
14160                               + stub_sec->output_section->vma);
14161               addend = 0;
14162               reloc_dest = DEST_STUB;
14163
14164               if ((stub_entry->stub_type == ppc_stub_plt_call
14165                    || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14166                   && (ALWAYS_EMIT_R2SAVE
14167                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14168                   && rel + 1 < relend
14169                   && rel[1].r_offset == rel->r_offset + 4
14170                   && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
14171                 relocation += 4;
14172             }
14173
14174           if (insn != 0)
14175             {
14176               if (is_isa_v2)
14177                 {
14178                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
14179                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
14180                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
14181                   if ((insn & (0x14 << 21)) == (0x04 << 21))
14182                     insn |= 0x02 << 21;
14183                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
14184                     insn |= 0x08 << 21;
14185                   else
14186                     break;
14187                 }
14188               else
14189                 {
14190                   /* Invert 'y' bit if not the default.  */
14191                   if ((bfd_signed_vma) (relocation + addend - from) < 0)
14192                     insn ^= 0x01 << 21;
14193                 }
14194
14195               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
14196             }
14197
14198           /* NOP out calls to undefined weak functions.
14199              We can thus call a weak function without first
14200              checking whether the function is defined.  */
14201           else if (h != NULL
14202                    && h->elf.root.type == bfd_link_hash_undefweak
14203                    && h->elf.dynindx == -1
14204                    && r_type == R_PPC64_REL24
14205                    && relocation == 0
14206                    && addend == 0)
14207             {
14208               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
14209               goto copy_reloc;
14210             }
14211           break;
14212         }
14213
14214       /* Set `addend'.  */
14215       tls_type = 0;
14216       switch (r_type)
14217         {
14218         default:
14219           info->callbacks->einfo
14220             (_("%P: %B: unknown relocation type %d for `%T'\n"),
14221              input_bfd, (int) r_type, sym_name);
14222
14223           bfd_set_error (bfd_error_bad_value);
14224           ret = FALSE;
14225           goto copy_reloc;
14226
14227         case R_PPC64_NONE:
14228         case R_PPC64_TLS:
14229         case R_PPC64_TLSGD:
14230         case R_PPC64_TLSLD:
14231         case R_PPC64_TOCSAVE:
14232         case R_PPC64_GNU_VTINHERIT:
14233         case R_PPC64_GNU_VTENTRY:
14234         case R_PPC64_ENTRY:
14235           goto copy_reloc;
14236
14237           /* GOT16 relocations.  Like an ADDR16 using the symbol's
14238              address in the GOT as relocation value instead of the
14239              symbol's value itself.  Also, create a GOT entry for the
14240              symbol and put the symbol value there.  */
14241         case R_PPC64_GOT_TLSGD16:
14242         case R_PPC64_GOT_TLSGD16_LO:
14243         case R_PPC64_GOT_TLSGD16_HI:
14244         case R_PPC64_GOT_TLSGD16_HA:
14245           tls_type = TLS_TLS | TLS_GD;
14246           goto dogot;
14247
14248         case R_PPC64_GOT_TLSLD16:
14249         case R_PPC64_GOT_TLSLD16_LO:
14250         case R_PPC64_GOT_TLSLD16_HI:
14251         case R_PPC64_GOT_TLSLD16_HA:
14252           tls_type = TLS_TLS | TLS_LD;
14253           goto dogot;
14254
14255         case R_PPC64_GOT_TPREL16_DS:
14256         case R_PPC64_GOT_TPREL16_LO_DS:
14257         case R_PPC64_GOT_TPREL16_HI:
14258         case R_PPC64_GOT_TPREL16_HA:
14259           tls_type = TLS_TLS | TLS_TPREL;
14260           goto dogot;
14261
14262         case R_PPC64_GOT_DTPREL16_DS:
14263         case R_PPC64_GOT_DTPREL16_LO_DS:
14264         case R_PPC64_GOT_DTPREL16_HI:
14265         case R_PPC64_GOT_DTPREL16_HA:
14266           tls_type = TLS_TLS | TLS_DTPREL;
14267           goto dogot;
14268
14269         case R_PPC64_GOT16:
14270         case R_PPC64_GOT16_LO:
14271         case R_PPC64_GOT16_HI:
14272         case R_PPC64_GOT16_HA:
14273         case R_PPC64_GOT16_DS:
14274         case R_PPC64_GOT16_LO_DS:
14275         dogot:
14276           {
14277             /* Relocation is to the entry for this symbol in the global
14278                offset table.  */
14279             asection *got;
14280             bfd_vma *offp;
14281             bfd_vma off;
14282             unsigned long indx = 0;
14283             struct got_entry *ent;
14284
14285             if (tls_type == (TLS_TLS | TLS_LD)
14286                 && (h == NULL
14287                     || !h->elf.def_dynamic))
14288               ent = ppc64_tlsld_got (input_bfd);
14289             else
14290               {
14291
14292                 if (h != NULL)
14293                   {
14294                     bfd_boolean dyn = htab->elf.dynamic_sections_created;
14295                     if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info),
14296                                                           &h->elf)
14297                         || (bfd_link_pic (info)
14298                             && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
14299                       /* This is actually a static link, or it is a
14300                          -Bsymbolic link and the symbol is defined
14301                          locally, or the symbol was forced to be local
14302                          because of a version file.  */
14303                       ;
14304                     else
14305                       {
14306                         BFD_ASSERT (h->elf.dynindx != -1);
14307                         indx = h->elf.dynindx;
14308                         unresolved_reloc = FALSE;
14309                       }
14310                     ent = h->elf.got.glist;
14311                   }
14312                 else
14313                   {
14314                     if (local_got_ents == NULL)
14315                       abort ();
14316                     ent = local_got_ents[r_symndx];
14317                   }
14318
14319                 for (; ent != NULL; ent = ent->next)
14320                   if (ent->addend == orig_rel.r_addend
14321                       && ent->owner == input_bfd
14322                       && ent->tls_type == tls_type)
14323                     break;
14324               }
14325
14326             if (ent == NULL)
14327               abort ();
14328             if (ent->is_indirect)
14329               ent = ent->got.ent;
14330             offp = &ent->got.offset;
14331             got = ppc64_elf_tdata (ent->owner)->got;
14332             if (got == NULL)
14333               abort ();
14334
14335             /* The offset must always be a multiple of 8.  We use the
14336                least significant bit to record whether we have already
14337                processed this entry.  */
14338             off = *offp;
14339             if ((off & 1) != 0)
14340               off &= ~1;
14341             else
14342               {
14343                 /* Generate relocs for the dynamic linker, except in
14344                    the case of TLSLD where we'll use one entry per
14345                    module.  */
14346                 asection *relgot;
14347                 bfd_boolean ifunc;
14348
14349                 *offp = off | 1;
14350                 relgot = NULL;
14351                 ifunc = (h != NULL
14352                          ? h->elf.type == STT_GNU_IFUNC
14353                          : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
14354                 if (ifunc)
14355                   relgot = htab->elf.irelplt;
14356                 else if ((bfd_link_pic (info) || indx != 0)
14357                          && (h == NULL
14358                              || (tls_type == (TLS_TLS | TLS_LD)
14359                                  && !h->elf.def_dynamic)
14360                              || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14361                              || h->elf.root.type != bfd_link_hash_undefweak))
14362                   relgot = ppc64_elf_tdata (ent->owner)->relgot;
14363                 if (relgot != NULL)
14364                   {
14365                     outrel.r_offset = (got->output_section->vma
14366                                        + got->output_offset
14367                                        + off);
14368                     outrel.r_addend = addend;
14369                     if (tls_type & (TLS_LD | TLS_GD))
14370                       {
14371                         outrel.r_addend = 0;
14372                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
14373                         if (tls_type == (TLS_TLS | TLS_GD))
14374                           {
14375                             loc = relgot->contents;
14376                             loc += (relgot->reloc_count++
14377                                     * sizeof (Elf64_External_Rela));
14378                             bfd_elf64_swap_reloca_out (output_bfd,
14379                                                        &outrel, loc);
14380                             outrel.r_offset += 8;
14381                             outrel.r_addend = addend;
14382                             outrel.r_info
14383                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14384                           }
14385                       }
14386                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
14387                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14388                     else if (tls_type == (TLS_TLS | TLS_TPREL))
14389                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
14390                     else if (indx != 0)
14391                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
14392                     else
14393                       {
14394                         if (ifunc)
14395                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14396                         else
14397                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14398
14399                         /* Write the .got section contents for the sake
14400                            of prelink.  */
14401                         loc = got->contents + off;
14402                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
14403                                     loc);
14404                       }
14405
14406                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
14407                       {
14408                         outrel.r_addend += relocation;
14409                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
14410                           {
14411                             if (htab->elf.tls_sec == NULL)
14412                               outrel.r_addend = 0;
14413                             else
14414                               outrel.r_addend -= htab->elf.tls_sec->vma;
14415                           }
14416                       }
14417                     loc = relgot->contents;
14418                     loc += (relgot->reloc_count++
14419                             * sizeof (Elf64_External_Rela));
14420                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14421                   }
14422
14423                 /* Init the .got section contents here if we're not
14424                    emitting a reloc.  */
14425                 else
14426                   {
14427                     relocation += addend;
14428                     if (tls_type == (TLS_TLS | TLS_LD))
14429                       relocation = 1;
14430                     else if (tls_type != 0)
14431                       {
14432                         if (htab->elf.tls_sec == NULL)
14433                           relocation = 0;
14434                         else
14435                           {
14436                             relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
14437                             if (tls_type == (TLS_TLS | TLS_TPREL))
14438                               relocation += DTP_OFFSET - TP_OFFSET;
14439                           }
14440
14441                         if (tls_type == (TLS_TLS | TLS_GD))
14442                           {
14443                             bfd_put_64 (output_bfd, relocation,
14444                                         got->contents + off + 8);
14445                             relocation = 1;
14446                           }
14447                       }
14448
14449                     bfd_put_64 (output_bfd, relocation,
14450                                 got->contents + off);
14451                   }
14452               }
14453
14454             if (off >= (bfd_vma) -2)
14455               abort ();
14456
14457             relocation = got->output_section->vma + got->output_offset + off;
14458             addend = -(TOCstart + htab->sec_info[input_section->id].toc_off);
14459           }
14460           break;
14461
14462         case R_PPC64_PLT16_HA:
14463         case R_PPC64_PLT16_HI:
14464         case R_PPC64_PLT16_LO:
14465         case R_PPC64_PLT32:
14466         case R_PPC64_PLT64:
14467           /* Relocation is to the entry for this symbol in the
14468              procedure linkage table.  */
14469           {
14470             struct plt_entry **plt_list = NULL;
14471             if (h != NULL)
14472               plt_list = &h->elf.plt.plist;
14473             else if (local_got_ents != NULL)
14474               {
14475                 struct plt_entry **local_plt = (struct plt_entry **)
14476                   (local_got_ents + symtab_hdr->sh_info);
14477                 unsigned char *local_got_tls_masks = (unsigned char *)
14478                   (local_plt + symtab_hdr->sh_info);
14479                 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
14480                   plt_list = local_plt + r_symndx;
14481               }
14482             if (plt_list)
14483               {
14484                 struct plt_entry *ent;
14485
14486                 for (ent = *plt_list; ent != NULL; ent = ent->next)
14487                   if (ent->plt.offset != (bfd_vma) -1
14488                       && ent->addend == orig_rel.r_addend)
14489                     {
14490                       asection *plt;
14491
14492                       plt = htab->elf.splt;
14493                       if (!htab->elf.dynamic_sections_created
14494                           || h == NULL
14495                           || h->elf.dynindx == -1)
14496                         plt = htab->elf.iplt;
14497                       relocation = (plt->output_section->vma
14498                                     + plt->output_offset
14499                                     + ent->plt.offset);
14500                       addend = 0;
14501                       unresolved_reloc = FALSE;
14502                       break;
14503                     }
14504               }
14505           }
14506           break;
14507
14508         case R_PPC64_TOC:
14509           /* Relocation value is TOC base.  */
14510           relocation = TOCstart;
14511           if (r_symndx == STN_UNDEF)
14512             relocation += htab->sec_info[input_section->id].toc_off;
14513           else if (unresolved_reloc)
14514             ;
14515           else if (sec != NULL && sec->id < htab->sec_info_arr_size)
14516             relocation += htab->sec_info[sec->id].toc_off;
14517           else
14518             unresolved_reloc = TRUE;
14519           goto dodyn;
14520
14521           /* TOC16 relocs.  We want the offset relative to the TOC base,
14522              which is the address of the start of the TOC plus 0x8000.
14523              The TOC consists of sections .got, .toc, .tocbss, and .plt,
14524              in this order.  */
14525         case R_PPC64_TOC16:
14526         case R_PPC64_TOC16_LO:
14527         case R_PPC64_TOC16_HI:
14528         case R_PPC64_TOC16_DS:
14529         case R_PPC64_TOC16_LO_DS:
14530         case R_PPC64_TOC16_HA:
14531           addend -= TOCstart + htab->sec_info[input_section->id].toc_off;
14532           break;
14533
14534           /* Relocate against the beginning of the section.  */
14535         case R_PPC64_SECTOFF:
14536         case R_PPC64_SECTOFF_LO:
14537         case R_PPC64_SECTOFF_HI:
14538         case R_PPC64_SECTOFF_DS:
14539         case R_PPC64_SECTOFF_LO_DS:
14540         case R_PPC64_SECTOFF_HA:
14541           if (sec != NULL)
14542             addend -= sec->output_section->vma;
14543           break;
14544
14545         case R_PPC64_REL16:
14546         case R_PPC64_REL16_LO:
14547         case R_PPC64_REL16_HI:
14548         case R_PPC64_REL16_HA:
14549         case R_PPC64_REL16DX_HA:
14550           break;
14551
14552         case R_PPC64_REL14:
14553         case R_PPC64_REL14_BRNTAKEN:
14554         case R_PPC64_REL14_BRTAKEN:
14555         case R_PPC64_REL24:
14556           break;
14557
14558         case R_PPC64_TPREL16:
14559         case R_PPC64_TPREL16_LO:
14560         case R_PPC64_TPREL16_HI:
14561         case R_PPC64_TPREL16_HA:
14562         case R_PPC64_TPREL16_DS:
14563         case R_PPC64_TPREL16_LO_DS:
14564         case R_PPC64_TPREL16_HIGH:
14565         case R_PPC64_TPREL16_HIGHA:
14566         case R_PPC64_TPREL16_HIGHER:
14567         case R_PPC64_TPREL16_HIGHERA:
14568         case R_PPC64_TPREL16_HIGHEST:
14569         case R_PPC64_TPREL16_HIGHESTA:
14570           if (h != NULL
14571               && h->elf.root.type == bfd_link_hash_undefweak
14572               && h->elf.dynindx == -1)
14573             {
14574               /* Make this relocation against an undefined weak symbol
14575                  resolve to zero.  This is really just a tweak, since
14576                  code using weak externs ought to check that they are
14577                  defined before using them.  */
14578               bfd_byte *p = contents + rel->r_offset - d_offset;
14579
14580               insn = bfd_get_32 (output_bfd, p);
14581               insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14582               if (insn != 0)
14583                 bfd_put_32 (output_bfd, insn, p);
14584               break;
14585             }
14586           if (htab->elf.tls_sec != NULL)
14587             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14588           if (bfd_link_pic (info))
14589             /* The TPREL16 relocs shouldn't really be used in shared
14590                libs as they will result in DT_TEXTREL being set, but
14591                support them anyway.  */
14592             goto dodyn;
14593           break;
14594
14595         case R_PPC64_DTPREL16:
14596         case R_PPC64_DTPREL16_LO:
14597         case R_PPC64_DTPREL16_HI:
14598         case R_PPC64_DTPREL16_HA:
14599         case R_PPC64_DTPREL16_DS:
14600         case R_PPC64_DTPREL16_LO_DS:
14601         case R_PPC64_DTPREL16_HIGH:
14602         case R_PPC64_DTPREL16_HIGHA:
14603         case R_PPC64_DTPREL16_HIGHER:
14604         case R_PPC64_DTPREL16_HIGHERA:
14605         case R_PPC64_DTPREL16_HIGHEST:
14606         case R_PPC64_DTPREL16_HIGHESTA:
14607           if (htab->elf.tls_sec != NULL)
14608             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14609           break;
14610
14611         case R_PPC64_ADDR64_LOCAL:
14612           addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
14613                                               ? h->elf.other
14614                                               : sym->st_other);
14615           break;
14616
14617         case R_PPC64_DTPMOD64:
14618           relocation = 1;
14619           addend = 0;
14620           goto dodyn;
14621
14622         case R_PPC64_TPREL64:
14623           if (htab->elf.tls_sec != NULL)
14624             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14625           goto dodyn;
14626
14627         case R_PPC64_DTPREL64:
14628           if (htab->elf.tls_sec != NULL)
14629             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14630           /* Fall thru */
14631
14632           /* Relocations that may need to be propagated if this is a
14633              dynamic object.  */
14634         case R_PPC64_REL30:
14635         case R_PPC64_REL32:
14636         case R_PPC64_REL64:
14637         case R_PPC64_ADDR14:
14638         case R_PPC64_ADDR14_BRNTAKEN:
14639         case R_PPC64_ADDR14_BRTAKEN:
14640         case R_PPC64_ADDR16:
14641         case R_PPC64_ADDR16_DS:
14642         case R_PPC64_ADDR16_HA:
14643         case R_PPC64_ADDR16_HI:
14644         case R_PPC64_ADDR16_HIGH:
14645         case R_PPC64_ADDR16_HIGHA:
14646         case R_PPC64_ADDR16_HIGHER:
14647         case R_PPC64_ADDR16_HIGHERA:
14648         case R_PPC64_ADDR16_HIGHEST:
14649         case R_PPC64_ADDR16_HIGHESTA:
14650         case R_PPC64_ADDR16_LO:
14651         case R_PPC64_ADDR16_LO_DS:
14652         case R_PPC64_ADDR24:
14653         case R_PPC64_ADDR32:
14654         case R_PPC64_ADDR64:
14655         case R_PPC64_UADDR16:
14656         case R_PPC64_UADDR32:
14657         case R_PPC64_UADDR64:
14658         dodyn:
14659           if ((input_section->flags & SEC_ALLOC) == 0)
14660             break;
14661
14662           if (NO_OPD_RELOCS && is_opd)
14663             break;
14664
14665           if ((bfd_link_pic (info)
14666                && (h == NULL
14667                    || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14668                    || h->elf.root.type != bfd_link_hash_undefweak)
14669                && (must_be_dyn_reloc (info, r_type)
14670                    || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
14671               || (ELIMINATE_COPY_RELOCS
14672                   && !bfd_link_pic (info)
14673                   && h != NULL
14674                   && h->elf.dynindx != -1
14675                   && !h->elf.non_got_ref
14676                   && !h->elf.def_regular)
14677               || (!bfd_link_pic (info)
14678                   && (h != NULL
14679                       ? h->elf.type == STT_GNU_IFUNC
14680                       : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)))
14681             {
14682               bfd_boolean skip, relocate;
14683               asection *sreloc;
14684               bfd_vma out_off;
14685
14686               /* When generating a dynamic object, these relocations
14687                  are copied into the output file to be resolved at run
14688                  time.  */
14689
14690               skip = FALSE;
14691               relocate = FALSE;
14692
14693               out_off = _bfd_elf_section_offset (output_bfd, info,
14694                                                  input_section, rel->r_offset);
14695               if (out_off == (bfd_vma) -1)
14696                 skip = TRUE;
14697               else if (out_off == (bfd_vma) -2)
14698                 skip = TRUE, relocate = TRUE;
14699               out_off += (input_section->output_section->vma
14700                           + input_section->output_offset);
14701               outrel.r_offset = out_off;
14702               outrel.r_addend = rel->r_addend;
14703
14704               /* Optimize unaligned reloc use.  */
14705               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14706                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14707                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14708               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14709                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
14710                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
14711               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
14712                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
14713                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
14714
14715               if (skip)
14716                 memset (&outrel, 0, sizeof outrel);
14717               else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14718                        && !is_opd
14719                        && r_type != R_PPC64_TOC)
14720                 {
14721                   BFD_ASSERT (h->elf.dynindx != -1);
14722                   outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
14723                 }
14724               else
14725                 {
14726                   /* This symbol is local, or marked to become local,
14727                      or this is an opd section reloc which must point
14728                      at a local function.  */
14729                   outrel.r_addend += relocation;
14730                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
14731                     {
14732                       if (is_opd && h != NULL)
14733                         {
14734                           /* Lie about opd entries.  This case occurs
14735                              when building shared libraries and we
14736                              reference a function in another shared
14737                              lib.  The same thing happens for a weak
14738                              definition in an application that's
14739                              overridden by a strong definition in a
14740                              shared lib.  (I believe this is a generic
14741                              bug in binutils handling of weak syms.)
14742                              In these cases we won't use the opd
14743                              entry in this lib.  */
14744                           unresolved_reloc = FALSE;
14745                         }
14746                       if (!is_opd
14747                           && r_type == R_PPC64_ADDR64
14748                           && (h != NULL
14749                               ? h->elf.type == STT_GNU_IFUNC
14750                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14751                         outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14752                       else
14753                         {
14754                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14755
14756                           /* We need to relocate .opd contents for ld.so.
14757                              Prelink also wants simple and consistent rules
14758                              for relocs.  This make all RELATIVE relocs have
14759                              *r_offset equal to r_addend.  */
14760                           relocate = TRUE;
14761                         }
14762                     }
14763                   else
14764                     {
14765                       long indx = 0;
14766
14767                       if (h != NULL
14768                           ? h->elf.type == STT_GNU_IFUNC
14769                           : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14770                         {
14771                           info->callbacks->einfo
14772                             (_("%P: %H: %s for indirect "
14773                                "function `%T' unsupported\n"),
14774                              input_bfd, input_section, rel->r_offset,
14775                              ppc64_elf_howto_table[r_type]->name,
14776                              sym_name);
14777                           ret = FALSE;
14778                         }
14779                       else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
14780                         ;
14781                       else if (sec == NULL || sec->owner == NULL)
14782                         {
14783                           bfd_set_error (bfd_error_bad_value);
14784                           return FALSE;
14785                         }
14786                       else
14787                         {
14788                           asection *osec;
14789
14790                           osec = sec->output_section;
14791                           indx = elf_section_data (osec)->dynindx;
14792
14793                           if (indx == 0)
14794                             {
14795                               if ((osec->flags & SEC_READONLY) == 0
14796                                   && htab->elf.data_index_section != NULL)
14797                                 osec = htab->elf.data_index_section;
14798                               else
14799                                 osec = htab->elf.text_index_section;
14800                               indx = elf_section_data (osec)->dynindx;
14801                             }
14802                           BFD_ASSERT (indx != 0);
14803
14804                           /* We are turning this relocation into one
14805                              against a section symbol, so subtract out
14806                              the output section's address but not the
14807                              offset of the input section in the output
14808                              section.  */
14809                           outrel.r_addend -= osec->vma;
14810                         }
14811
14812                       outrel.r_info = ELF64_R_INFO (indx, r_type);
14813                     }
14814                 }
14815
14816               sreloc = elf_section_data (input_section)->sreloc;
14817               if (h != NULL
14818                   ? h->elf.type == STT_GNU_IFUNC
14819                   : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14820                 sreloc = htab->elf.irelplt;
14821               if (sreloc == NULL)
14822                 abort ();
14823
14824               if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
14825                   >= sreloc->size)
14826                 abort ();
14827               loc = sreloc->contents;
14828               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
14829               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14830
14831               /* If this reloc is against an external symbol, it will
14832                  be computed at runtime, so there's no need to do
14833                  anything now.  However, for the sake of prelink ensure
14834                  that the section contents are a known value.  */
14835               if (! relocate)
14836                 {
14837                   unresolved_reloc = FALSE;
14838                   /* The value chosen here is quite arbitrary as ld.so
14839                      ignores section contents except for the special
14840                      case of .opd where the contents might be accessed
14841                      before relocation.  Choose zero, as that won't
14842                      cause reloc overflow.  */
14843                   relocation = 0;
14844                   addend = 0;
14845                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
14846                      to improve backward compatibility with older
14847                      versions of ld.  */
14848                   if (r_type == R_PPC64_ADDR64)
14849                     addend = outrel.r_addend;
14850                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
14851                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
14852                     addend = (input_section->output_section->vma
14853                               + input_section->output_offset
14854                               + rel->r_offset);
14855                 }
14856             }
14857           break;
14858
14859         case R_PPC64_COPY:
14860         case R_PPC64_GLOB_DAT:
14861         case R_PPC64_JMP_SLOT:
14862         case R_PPC64_JMP_IREL:
14863         case R_PPC64_RELATIVE:
14864           /* We shouldn't ever see these dynamic relocs in relocatable
14865              files.  */
14866           /* Fall through.  */
14867
14868         case R_PPC64_PLTGOT16:
14869         case R_PPC64_PLTGOT16_DS:
14870         case R_PPC64_PLTGOT16_HA:
14871         case R_PPC64_PLTGOT16_HI:
14872         case R_PPC64_PLTGOT16_LO:
14873         case R_PPC64_PLTGOT16_LO_DS:
14874         case R_PPC64_PLTREL32:
14875         case R_PPC64_PLTREL64:
14876           /* These ones haven't been implemented yet.  */
14877
14878           info->callbacks->einfo
14879             (_("%P: %B: %s is not supported for `%T'\n"),
14880              input_bfd,
14881              ppc64_elf_howto_table[r_type]->name, sym_name);
14882
14883           bfd_set_error (bfd_error_invalid_operation);
14884           ret = FALSE;
14885           goto copy_reloc;
14886         }
14887
14888       /* Multi-instruction sequences that access the TOC can be
14889          optimized, eg. addis ra,r2,0; addi rb,ra,x;
14890          to             nop;           addi rb,r2,x;  */
14891       switch (r_type)
14892         {
14893         default:
14894           break;
14895
14896         case R_PPC64_GOT_TLSLD16_HI:
14897         case R_PPC64_GOT_TLSGD16_HI:
14898         case R_PPC64_GOT_TPREL16_HI:
14899         case R_PPC64_GOT_DTPREL16_HI:
14900         case R_PPC64_GOT16_HI:
14901         case R_PPC64_TOC16_HI:
14902           /* These relocs would only be useful if building up an
14903              offset to later add to r2, perhaps in an indexed
14904              addressing mode instruction.  Don't try to optimize.
14905              Unfortunately, the possibility of someone building up an
14906              offset like this or even with the HA relocs, means that
14907              we need to check the high insn when optimizing the low
14908              insn.  */
14909           break;
14910
14911         case R_PPC64_GOT_TLSLD16_HA:
14912         case R_PPC64_GOT_TLSGD16_HA:
14913         case R_PPC64_GOT_TPREL16_HA:
14914         case R_PPC64_GOT_DTPREL16_HA:
14915         case R_PPC64_GOT16_HA:
14916         case R_PPC64_TOC16_HA:
14917           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14918               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14919             {
14920               bfd_byte *p = contents + (rel->r_offset & ~3);
14921               bfd_put_32 (input_bfd, NOP, p);
14922             }
14923           break;
14924
14925         case R_PPC64_GOT_TLSLD16_LO:
14926         case R_PPC64_GOT_TLSGD16_LO:
14927         case R_PPC64_GOT_TPREL16_LO_DS:
14928         case R_PPC64_GOT_DTPREL16_LO_DS:
14929         case R_PPC64_GOT16_LO:
14930         case R_PPC64_GOT16_LO_DS:
14931         case R_PPC64_TOC16_LO:
14932         case R_PPC64_TOC16_LO_DS:
14933           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14934               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14935             {
14936               bfd_byte *p = contents + (rel->r_offset & ~3);
14937               insn = bfd_get_32 (input_bfd, p);
14938               if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
14939                 {
14940                   /* Transform addic to addi when we change reg.  */
14941                   insn &= ~((0x3f << 26) | (0x1f << 16));
14942                   insn |= (14u << 26) | (2 << 16);
14943                 }
14944               else
14945                 {
14946                   insn &= ~(0x1f << 16);
14947                   insn |= 2 << 16;
14948                 }
14949               bfd_put_32 (input_bfd, insn, p);
14950             }
14951           break;
14952         }
14953
14954       /* Do any further special processing.  */
14955       howto = ppc64_elf_howto_table[(int) r_type];
14956       switch (r_type)
14957         {
14958         default:
14959           break;
14960
14961         case R_PPC64_REL16_HA:
14962         case R_PPC64_REL16DX_HA:
14963         case R_PPC64_ADDR16_HA:
14964         case R_PPC64_ADDR16_HIGHA:
14965         case R_PPC64_ADDR16_HIGHERA:
14966         case R_PPC64_ADDR16_HIGHESTA:
14967         case R_PPC64_TOC16_HA:
14968         case R_PPC64_SECTOFF_HA:
14969         case R_PPC64_TPREL16_HA:
14970         case R_PPC64_TPREL16_HIGHA:
14971         case R_PPC64_TPREL16_HIGHERA:
14972         case R_PPC64_TPREL16_HIGHESTA:
14973         case R_PPC64_DTPREL16_HA:
14974         case R_PPC64_DTPREL16_HIGHA:
14975         case R_PPC64_DTPREL16_HIGHERA:
14976         case R_PPC64_DTPREL16_HIGHESTA:
14977           /* It's just possible that this symbol is a weak symbol
14978              that's not actually defined anywhere. In that case,
14979              'sec' would be NULL, and we should leave the symbol
14980              alone (it will be set to zero elsewhere in the link).  */
14981           if (sec == NULL)
14982             break;
14983           /* Fall thru */
14984
14985         case R_PPC64_GOT16_HA:
14986         case R_PPC64_PLTGOT16_HA:
14987         case R_PPC64_PLT16_HA:
14988         case R_PPC64_GOT_TLSGD16_HA:
14989         case R_PPC64_GOT_TLSLD16_HA:
14990         case R_PPC64_GOT_TPREL16_HA:
14991         case R_PPC64_GOT_DTPREL16_HA:
14992           /* Add 0x10000 if sign bit in 0:15 is set.
14993              Bits 0:15 are not used.  */
14994           addend += 0x8000;
14995           break;
14996
14997         case R_PPC64_ADDR16_DS:
14998         case R_PPC64_ADDR16_LO_DS:
14999         case R_PPC64_GOT16_DS:
15000         case R_PPC64_GOT16_LO_DS:
15001         case R_PPC64_PLT16_LO_DS:
15002         case R_PPC64_SECTOFF_DS:
15003         case R_PPC64_SECTOFF_LO_DS:
15004         case R_PPC64_TOC16_DS:
15005         case R_PPC64_TOC16_LO_DS:
15006         case R_PPC64_PLTGOT16_DS:
15007         case R_PPC64_PLTGOT16_LO_DS:
15008         case R_PPC64_GOT_TPREL16_DS:
15009         case R_PPC64_GOT_TPREL16_LO_DS:
15010         case R_PPC64_GOT_DTPREL16_DS:
15011         case R_PPC64_GOT_DTPREL16_LO_DS:
15012         case R_PPC64_TPREL16_DS:
15013         case R_PPC64_TPREL16_LO_DS:
15014         case R_PPC64_DTPREL16_DS:
15015         case R_PPC64_DTPREL16_LO_DS:
15016           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15017           mask = 3;
15018           /* If this reloc is against an lq, lxv, or stxv insn, then
15019              the value must be a multiple of 16.  This is somewhat of
15020              a hack, but the "correct" way to do this by defining _DQ
15021              forms of all the _DS relocs bloats all reloc switches in
15022              this file.  It doesn't make much sense to use these
15023              relocs in data, so testing the insn should be safe.  */
15024           if ((insn & (0x3f << 26)) == (56u << 26)
15025               || ((insn & (0x3f << 26)) == (61u << 26) && (insn & 3) == 1))
15026             mask = 15;
15027           relocation += addend;
15028           addend = insn & (mask ^ 3);
15029           if ((relocation & mask) != 0)
15030             {
15031               relocation ^= relocation & mask;
15032               info->callbacks->einfo
15033                 (_("%P: %H: error: %s not a multiple of %u\n"),
15034                  input_bfd, input_section, rel->r_offset,
15035                  howto->name,
15036                  mask + 1);
15037               bfd_set_error (bfd_error_bad_value);
15038               ret = FALSE;
15039               goto copy_reloc;
15040             }
15041           break;
15042         }
15043
15044       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
15045          because such sections are not SEC_ALLOC and thus ld.so will
15046          not process them.  */
15047       if (unresolved_reloc
15048           && !((input_section->flags & SEC_DEBUGGING) != 0
15049                && h->elf.def_dynamic)
15050           && _bfd_elf_section_offset (output_bfd, info, input_section,
15051                                       rel->r_offset) != (bfd_vma) -1)
15052         {
15053           info->callbacks->einfo
15054             (_("%P: %H: unresolvable %s against `%T'\n"),
15055              input_bfd, input_section, rel->r_offset,
15056              howto->name,
15057              h->elf.root.root.string);
15058           ret = FALSE;
15059         }
15060
15061       /* 16-bit fields in insns mostly have signed values, but a
15062          few insns have 16-bit unsigned values.  Really, we should
15063          have different reloc types.  */
15064       if (howto->complain_on_overflow != complain_overflow_dont
15065           && howto->dst_mask == 0xffff
15066           && (input_section->flags & SEC_CODE) != 0)
15067         {
15068           enum complain_overflow complain = complain_overflow_signed;
15069
15070           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15071           if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
15072             complain = complain_overflow_bitfield;
15073           else if (howto->rightshift == 0
15074                    ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
15075                       || (insn & (0x3f << 26)) == 24u << 26 /* ori */
15076                       || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
15077                    : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
15078                       || (insn & (0x3f << 26)) == 25u << 26 /* oris */
15079                       || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
15080             complain = complain_overflow_unsigned;
15081           if (howto->complain_on_overflow != complain)
15082             {
15083               alt_howto = *howto;
15084               alt_howto.complain_on_overflow = complain;
15085               howto = &alt_howto;
15086             }
15087         }
15088
15089       if (r_type == R_PPC64_REL16DX_HA)
15090         {
15091           /* Split field reloc isn't handled by _bfd_final_link_relocate.  */
15092           if (rel->r_offset + 4 > input_section->size)
15093             r = bfd_reloc_outofrange;
15094           else
15095             {
15096               relocation += addend;
15097               relocation -= (rel->r_offset
15098                              + input_section->output_offset
15099                              + input_section->output_section->vma);
15100               relocation = (bfd_signed_vma) relocation >> 16;
15101               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
15102               insn &= ~0x1fffc1;
15103               insn |= (relocation & 0xffc1) | ((relocation & 0x3e) << 15);
15104               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
15105               r = bfd_reloc_ok;
15106               if (relocation + 0x8000 > 0xffff)
15107                 r = bfd_reloc_overflow;
15108             }
15109         }
15110       else
15111         r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
15112                                       rel->r_offset, relocation, addend);
15113
15114       if (r != bfd_reloc_ok)
15115         {
15116           char *more_info = NULL;
15117           const char *reloc_name = howto->name;
15118
15119           if (reloc_dest != DEST_NORMAL)
15120             {
15121               more_info = bfd_malloc (strlen (reloc_name) + 8);
15122               if (more_info != NULL)
15123                 {
15124                   strcpy (more_info, reloc_name);
15125                   strcat (more_info, (reloc_dest == DEST_OPD
15126                                       ? " (OPD)" : " (stub)"));
15127                   reloc_name = more_info;
15128                 }
15129             }
15130
15131           if (r == bfd_reloc_overflow)
15132             {
15133               /* On code like "if (foo) foo();" don't report overflow
15134                  on a branch to zero when foo is undefined.  */
15135               if (!warned
15136                   && (reloc_dest == DEST_STUB
15137                       || !(h != NULL
15138                            && (h->elf.root.type == bfd_link_hash_undefweak
15139                                || h->elf.root.type == bfd_link_hash_undefined)
15140                            && is_branch_reloc (r_type))))
15141                 {
15142                   if (!((*info->callbacks->reloc_overflow)
15143                         (info, &h->elf.root, sym_name,
15144                          reloc_name, orig_rel.r_addend,
15145                          input_bfd, input_section, rel->r_offset)))
15146                     return FALSE;
15147                 }
15148             }
15149           else
15150             {
15151               info->callbacks->einfo
15152                 (_("%P: %H: %s against `%T': error %d\n"),
15153                  input_bfd, input_section, rel->r_offset,
15154                  reloc_name, sym_name, (int) r);
15155               ret = FALSE;
15156             }
15157           if (more_info != NULL)
15158             free (more_info);
15159         }
15160     copy_reloc:
15161       if (wrel != rel)
15162         *wrel = *rel;
15163     }
15164
15165   if (wrel != rel)
15166     {
15167       Elf_Internal_Shdr *rel_hdr;
15168       size_t deleted = rel - wrel;
15169
15170       rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
15171       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15172       if (rel_hdr->sh_size == 0)
15173         {
15174           /* It is too late to remove an empty reloc section.  Leave
15175              one NONE reloc.
15176              ??? What is wrong with an empty section???  */
15177           rel_hdr->sh_size = rel_hdr->sh_entsize;
15178           deleted -= 1;
15179         }
15180       rel_hdr = _bfd_elf_single_rel_hdr (input_section);
15181       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15182       input_section->reloc_count -= deleted;
15183     }
15184
15185   /* If we're emitting relocations, then shortly after this function
15186      returns, reloc offsets and addends for this section will be
15187      adjusted.  Worse, reloc symbol indices will be for the output
15188      file rather than the input.  Save a copy of the relocs for
15189      opd_entry_value.  */
15190   if (is_opd && (info->emitrelocations || bfd_link_relocatable (info)))
15191     {
15192       bfd_size_type amt;
15193       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
15194       rel = bfd_alloc (input_bfd, amt);
15195       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
15196       ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
15197       if (rel == NULL)
15198         return FALSE;
15199       memcpy (rel, relocs, amt);
15200     }
15201   return ret;
15202 }
15203
15204 /* Adjust the value of any local symbols in opd sections.  */
15205
15206 static int
15207 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
15208                               const char *name ATTRIBUTE_UNUSED,
15209                               Elf_Internal_Sym *elfsym,
15210                               asection *input_sec,
15211                               struct elf_link_hash_entry *h)
15212 {
15213   struct _opd_sec_data *opd;
15214   long adjust;
15215   bfd_vma value;
15216
15217   if (h != NULL)
15218     return 1;
15219
15220   opd = get_opd_info (input_sec);
15221   if (opd == NULL || opd->adjust == NULL)
15222     return 1;
15223
15224   value = elfsym->st_value - input_sec->output_offset;
15225   if (!bfd_link_relocatable (info))
15226     value -= input_sec->output_section->vma;
15227
15228   adjust = opd->adjust[OPD_NDX (value)];
15229   if (adjust == -1)
15230     return 2;
15231
15232   elfsym->st_value += adjust;
15233   return 1;
15234 }
15235
15236 /* Finish up dynamic symbol handling.  We set the contents of various
15237    dynamic sections here.  */
15238
15239 static bfd_boolean
15240 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
15241                                  struct bfd_link_info *info,
15242                                  struct elf_link_hash_entry *h,
15243                                  Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
15244 {
15245   struct ppc_link_hash_table *htab;
15246   struct plt_entry *ent;
15247   Elf_Internal_Rela rela;
15248   bfd_byte *loc;
15249
15250   htab = ppc_hash_table (info);
15251   if (htab == NULL)
15252     return FALSE;
15253
15254   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
15255     if (ent->plt.offset != (bfd_vma) -1)
15256       {
15257         /* This symbol has an entry in the procedure linkage
15258            table.  Set it up.  */
15259         if (!htab->elf.dynamic_sections_created
15260             || h->dynindx == -1)
15261           {
15262             BFD_ASSERT (h->type == STT_GNU_IFUNC
15263                         && h->def_regular
15264                         && (h->root.type == bfd_link_hash_defined
15265                             || h->root.type == bfd_link_hash_defweak));
15266             rela.r_offset = (htab->elf.iplt->output_section->vma
15267                              + htab->elf.iplt->output_offset
15268                              + ent->plt.offset);
15269             if (htab->opd_abi)
15270               rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
15271             else
15272               rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15273             rela.r_addend = (h->root.u.def.value
15274                              + h->root.u.def.section->output_offset
15275                              + h->root.u.def.section->output_section->vma
15276                              + ent->addend);
15277             loc = (htab->elf.irelplt->contents
15278                    + (htab->elf.irelplt->reloc_count++
15279                       * sizeof (Elf64_External_Rela)));
15280           }
15281         else
15282           {
15283             rela.r_offset = (htab->elf.splt->output_section->vma
15284                              + htab->elf.splt->output_offset
15285                              + ent->plt.offset);
15286             rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
15287             rela.r_addend = ent->addend;
15288             loc = (htab->elf.srelplt->contents
15289                    + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
15290                       / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
15291           }
15292         bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15293
15294         if (!htab->opd_abi)
15295           {
15296             if (!h->def_regular)
15297               {
15298                 /* Mark the symbol as undefined, rather than as
15299                    defined in glink.  Leave the value if there were
15300                    any relocations where pointer equality matters
15301                    (this is a clue for the dynamic linker, to make
15302                    function pointer comparisons work between an
15303                    application and shared library), otherwise set it
15304                    to zero.  */
15305                 sym->st_shndx = SHN_UNDEF;
15306                 if (!h->pointer_equality_needed)
15307                   sym->st_value = 0;
15308                 else if (!h->ref_regular_nonweak)
15309                   {
15310                     /* This breaks function pointer comparisons, but
15311                        that is better than breaking tests for a NULL
15312                        function pointer.  */
15313                     sym->st_value = 0;
15314                   }
15315               }
15316           }
15317       }
15318
15319   if (h->needs_copy)
15320     {
15321       /* This symbol needs a copy reloc.  Set it up.  */
15322
15323       if (h->dynindx == -1
15324           || (h->root.type != bfd_link_hash_defined
15325               && h->root.type != bfd_link_hash_defweak)
15326           || htab->relbss == NULL)
15327         abort ();
15328
15329       rela.r_offset = (h->root.u.def.value
15330                        + h->root.u.def.section->output_section->vma
15331                        + h->root.u.def.section->output_offset);
15332       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
15333       rela.r_addend = 0;
15334       loc = htab->relbss->contents;
15335       loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
15336       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15337     }
15338
15339   return TRUE;
15340 }
15341
15342 /* Used to decide how to sort relocs in an optimal manner for the
15343    dynamic linker, before writing them out.  */
15344
15345 static enum elf_reloc_type_class
15346 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
15347                             const asection *rel_sec,
15348                             const Elf_Internal_Rela *rela)
15349 {
15350   enum elf_ppc64_reloc_type r_type;
15351   struct ppc_link_hash_table *htab = ppc_hash_table (info);
15352
15353   if (rel_sec == htab->elf.irelplt)
15354     return reloc_class_ifunc;
15355
15356   r_type = ELF64_R_TYPE (rela->r_info);
15357   switch (r_type)
15358     {
15359     case R_PPC64_RELATIVE:
15360       return reloc_class_relative;
15361     case R_PPC64_JMP_SLOT:
15362       return reloc_class_plt;
15363     case R_PPC64_COPY:
15364       return reloc_class_copy;
15365     default:
15366       return reloc_class_normal;
15367     }
15368 }
15369
15370 /* Finish up the dynamic sections.  */
15371
15372 static bfd_boolean
15373 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
15374                                    struct bfd_link_info *info)
15375 {
15376   struct ppc_link_hash_table *htab;
15377   bfd *dynobj;
15378   asection *sdyn;
15379
15380   htab = ppc_hash_table (info);
15381   if (htab == NULL)
15382     return FALSE;
15383
15384   dynobj = htab->elf.dynobj;
15385   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
15386
15387   if (htab->elf.dynamic_sections_created)
15388     {
15389       Elf64_External_Dyn *dyncon, *dynconend;
15390
15391       if (sdyn == NULL || htab->elf.sgot == NULL)
15392         abort ();
15393
15394       dyncon = (Elf64_External_Dyn *) sdyn->contents;
15395       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
15396       for (; dyncon < dynconend; dyncon++)
15397         {
15398           Elf_Internal_Dyn dyn;
15399           asection *s;
15400
15401           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
15402
15403           switch (dyn.d_tag)
15404             {
15405             default:
15406               continue;
15407
15408             case DT_PPC64_GLINK:
15409               s = htab->glink;
15410               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15411               /* We stupidly defined DT_PPC64_GLINK to be the start
15412                  of glink rather than the first entry point, which is
15413                  what ld.so needs, and now have a bigger stub to
15414                  support automatic multiple TOCs.  */
15415               dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
15416               break;
15417
15418             case DT_PPC64_OPD:
15419               s = bfd_get_section_by_name (output_bfd, ".opd");
15420               if (s == NULL)
15421                 continue;
15422               dyn.d_un.d_ptr = s->vma;
15423               break;
15424
15425             case DT_PPC64_OPT:
15426               if (htab->do_multi_toc && htab->multi_toc_needed)
15427                 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
15428               break;
15429
15430             case DT_PPC64_OPDSZ:
15431               s = bfd_get_section_by_name (output_bfd, ".opd");
15432               if (s == NULL)
15433                 continue;
15434               dyn.d_un.d_val = s->size;
15435               break;
15436
15437             case DT_PLTGOT:
15438               s = htab->elf.splt;
15439               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15440               break;
15441
15442             case DT_JMPREL:
15443               s = htab->elf.srelplt;
15444               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15445               break;
15446
15447             case DT_PLTRELSZ:
15448               dyn.d_un.d_val = htab->elf.srelplt->size;
15449               break;
15450
15451             case DT_RELASZ:
15452               /* Don't count procedure linkage table relocs in the
15453                  overall reloc count.  */
15454               s = htab->elf.srelplt;
15455               if (s == NULL)
15456                 continue;
15457               dyn.d_un.d_val -= s->size;
15458               break;
15459
15460             case DT_RELA:
15461               /* We may not be using the standard ELF linker script.
15462                  If .rela.plt is the first .rela section, we adjust
15463                  DT_RELA to not include it.  */
15464               s = htab->elf.srelplt;
15465               if (s == NULL)
15466                 continue;
15467               if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
15468                 continue;
15469               dyn.d_un.d_ptr += s->size;
15470               break;
15471             }
15472
15473           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
15474         }
15475     }
15476
15477   if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0)
15478     {
15479       /* Fill in the first entry in the global offset table.
15480          We use it to hold the link-time TOCbase.  */
15481       bfd_put_64 (output_bfd,
15482                   elf_gp (output_bfd) + TOC_BASE_OFF,
15483                   htab->elf.sgot->contents);
15484
15485       /* Set .got entry size.  */
15486       elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
15487     }
15488
15489   if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
15490     {
15491       /* Set .plt entry size.  */
15492       elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
15493         = PLT_ENTRY_SIZE (htab);
15494     }
15495
15496   /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
15497      brlt ourselves if emitrelocations.  */
15498   if (htab->brlt != NULL
15499       && htab->brlt->reloc_count != 0
15500       && !_bfd_elf_link_output_relocs (output_bfd,
15501                                        htab->brlt,
15502                                        elf_section_data (htab->brlt)->rela.hdr,
15503                                        elf_section_data (htab->brlt)->relocs,
15504                                        NULL))
15505     return FALSE;
15506
15507   if (htab->glink != NULL
15508       && htab->glink->reloc_count != 0
15509       && !_bfd_elf_link_output_relocs (output_bfd,
15510                                        htab->glink,
15511                                        elf_section_data (htab->glink)->rela.hdr,
15512                                        elf_section_data (htab->glink)->relocs,
15513                                        NULL))
15514     return FALSE;
15515
15516   if (htab->glink_eh_frame != NULL
15517       && htab->glink_eh_frame->size != 0)
15518     {
15519       bfd_vma val;
15520       bfd_byte *p;
15521       asection *stub_sec;
15522
15523       p = htab->glink_eh_frame->contents + sizeof (glink_eh_frame_cie);
15524       for (stub_sec = htab->params->stub_bfd->sections;
15525            stub_sec != NULL;
15526            stub_sec = stub_sec->next)
15527         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
15528           {
15529             /* FDE length.  */
15530             p += 4;
15531             /* CIE pointer.  */
15532             p += 4;
15533             /* Offset to stub section.  */
15534             val = (stub_sec->output_section->vma
15535                    + stub_sec->output_offset);
15536             val -= (htab->glink_eh_frame->output_section->vma
15537                     + htab->glink_eh_frame->output_offset
15538                     + (p - htab->glink_eh_frame->contents));
15539             if (val + 0x80000000 > 0xffffffff)
15540               {
15541                 info->callbacks->einfo
15542                   (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15543                    stub_sec->name);
15544                 return FALSE;
15545               }
15546             bfd_put_32 (dynobj, val, p);
15547             p += 4;
15548             /* stub section size.  */
15549             p += 4;
15550             /* Augmentation.  */
15551             p += 1;
15552             /* Pad.  */
15553             p += 7;
15554           }
15555       if (htab->glink != NULL && htab->glink->size != 0)
15556         {
15557           /* FDE length.  */
15558           p += 4;
15559           /* CIE pointer.  */
15560           p += 4;
15561           /* Offset to .glink.  */
15562           val = (htab->glink->output_section->vma
15563                  + htab->glink->output_offset
15564                  + 8);
15565           val -= (htab->glink_eh_frame->output_section->vma
15566                   + htab->glink_eh_frame->output_offset
15567                   + (p - htab->glink_eh_frame->contents));
15568           if (val + 0x80000000 > 0xffffffff)
15569             {
15570               info->callbacks->einfo
15571                 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15572                  htab->glink->name);
15573               return FALSE;
15574             }
15575           bfd_put_32 (dynobj, val, p);
15576           p += 4;
15577           /* .glink size.  */
15578           p += 4;
15579           /* Augmentation.  */
15580           p += 1;
15581           /* Ops.  */
15582           p += 7;
15583         }
15584
15585       if (htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
15586           && !_bfd_elf_write_section_eh_frame (output_bfd, info,
15587                                                htab->glink_eh_frame,
15588                                                htab->glink_eh_frame->contents))
15589         return FALSE;
15590     }
15591
15592   /* We need to handle writing out multiple GOT sections ourselves,
15593      since we didn't add them to DYNOBJ.  We know dynobj is the first
15594      bfd.  */
15595   while ((dynobj = dynobj->link.next) != NULL)
15596     {
15597       asection *s;
15598
15599       if (!is_ppc64_elf (dynobj))
15600         continue;
15601
15602       s = ppc64_elf_tdata (dynobj)->got;
15603       if (s != NULL
15604           && s->size != 0
15605           && s->output_section != bfd_abs_section_ptr
15606           && !bfd_set_section_contents (output_bfd, s->output_section,
15607                                         s->contents, s->output_offset,
15608                                         s->size))
15609         return FALSE;
15610       s = ppc64_elf_tdata (dynobj)->relgot;
15611       if (s != NULL
15612           && s->size != 0
15613           && s->output_section != bfd_abs_section_ptr
15614           && !bfd_set_section_contents (output_bfd, s->output_section,
15615                                         s->contents, s->output_offset,
15616                                         s->size))
15617         return FALSE;
15618     }
15619
15620   return TRUE;
15621 }
15622
15623 #include "elf64-target.h"
15624
15625 /* FreeBSD support */
15626
15627 #undef  TARGET_LITTLE_SYM
15628 #undef  TARGET_LITTLE_NAME
15629
15630 #undef  TARGET_BIG_SYM
15631 #define TARGET_BIG_SYM  powerpc_elf64_fbsd_vec
15632 #undef  TARGET_BIG_NAME
15633 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15634
15635 #undef  ELF_OSABI
15636 #define ELF_OSABI       ELFOSABI_FREEBSD
15637
15638 #undef  elf64_bed
15639 #define elf64_bed       elf64_powerpc_fbsd_bed
15640
15641 #include "elf64-target.h"
15642