bfd/elf64-ppc.c

   1 /* PowerPC64-specific support for 64-bit ELF.
   2    Copyright (C) 1999-2015 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
 177 #define ADDIS_R12_R2    0x3d820000      /* addis %r12,%r2,xxx@ha     */
 178 #define ADDIS_R12_R12   0x3d8c0000      /* addis %r12,%r12,xxx@ha */
 179 #define LD_R12_0R12     0xe98c0000      /* ld    %r12,xxx@l(%r12) */
 180
 181 /* glink call stub instructions.  We enter with the index in R0.  */
 182 #define GLINK_CALL_STUB_SIZE (16*4)
 183                                         /* 0:                           */
 184                                         /*  .quad plt0-1f               */
 185                                         /* __glink:                     */
 186 #define MFLR_R12        0x7d8802a6      /*  mflr %12                    */
 187 #define BCL_20_31       0x429f0005      /*  bcl 20,31,1f                */
 188                                         /* 1:                           */
 189 #define MFLR_R11        0x7d6802a6      /*  mflr %11                    */
 190                                         /*  ld %2,(0b-1b)(%11)          */
 191 #define MTLR_R12        0x7d8803a6      /*  mtlr %12                    */
 192 #define ADD_R11_R2_R11  0x7d625a14      /*  add %11,%2,%11              */
 193                                         /*  ld %12,0(%11)               */
 194                                         /*  ld %2,8(%11)                */
 195                                         /*  mtctr %12                   */
 196                                         /*  ld %11,16(%11)              */
 197                                         /*  bctr                        */
 198 #define MFLR_R0         0x7c0802a6      /*  mflr %r0                    */
 199 #define MTLR_R0         0x7c0803a6      /*  mtlr %r0                    */
 200 #define SUB_R12_R12_R11 0x7d8b6050      /*  subf %r12,%r11,%r12         */
 201 #define ADDI_R0_R12     0x380c0000      /*  addi %r0,%r12,0             */
 202 #define SRDI_R0_R0_2    0x7800f082      /*  rldicl %r0,%r0,62,2         */
 203
 204 /* Pad with this.  */
 205 #define NOP             0x60000000
 206
 207 /* Some other nops.  */
 208 #define CROR_151515     0x4def7b82
 209 #define CROR_313131     0x4ffffb82
 210
 211 /* .glink entries for the first 32k functions are two instructions.  */
 212 #define LI_R0_0         0x38000000      /* li    %r0,0          */
 213 #define B_DOT           0x48000000      /* b     .              */
 214
 215 /* After that, we need two instructions to load the index, followed by
 216    a branch.  */
 217 #define LIS_R0_0        0x3c000000      /* lis   %r0,0          */
 218 #define ORI_R0_R0_0     0x60000000      /* ori   %r0,%r0,0      */
 219
 220 /* Instructions used by the save and restore reg functions.  */
 221 #define STD_R0_0R1      0xf8010000      /* std   %r0,0(%r1)     */
 222 #define STD_R0_0R12     0xf80c0000      /* std   %r0,0(%r12)    */
 223 #define LD_R0_0R1       0xe8010000      /* ld    %r0,0(%r1)     */
 224 #define LD_R0_0R12      0xe80c0000      /* ld    %r0,0(%r12)    */
 225 #define STFD_FR0_0R1    0xd8010000      /* stfd  %fr0,0(%r1)    */
 226 #define LFD_FR0_0R1     0xc8010000      /* lfd   %fr0,0(%r1)    */
 227 #define LI_R12_0        0x39800000      /* li    %r12,0         */
 228 #define STVX_VR0_R12_R0 0x7c0c01ce      /* stvx  %v0,%r12,%r0   */
 229 #define LVX_VR0_R12_R0  0x7c0c00ce      /* lvx   %v0,%r12,%r0   */
 230 #define MTLR_R0         0x7c0803a6      /* mtlr  %r0            */
 231 #define BLR             0x4e800020      /* blr                  */
 232
 233 /* Since .opd is an array of descriptors and each entry will end up
 234    with identical R_PPC64_RELATIVE relocs, there is really no need to
 235    propagate .opd relocs;  The dynamic linker should be taught to
 236    relocate .opd without reloc entries.  */
 237 #ifndef NO_OPD_RELOCS
 238 #define NO_OPD_RELOCS 0
 239 #endif
 240
 241 #ifndef ARRAY_SIZE
 242 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
 243 #endif
 244
 245 static inline int
 246 abiversion (bfd *abfd)
 247 {
 248   return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
 249 }
 250
 251 static inline void
 252 set_abiversion (bfd *abfd, int ver)
 253 {
 254   elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
 255   elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
 256 }
 257 \f
 258 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
 259
 260 /* Relocation HOWTO's.  */
 261 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
 262
 263 static reloc_howto_type ppc64_elf_howto_raw[] = {
 264   /* This reloc does nothing.  */
 265   HOWTO (R_PPC64_NONE,          /* type */
 266          0,                     /* rightshift */
 267          3,                     /* size (0 = byte, 1 = short, 2 = long) */
 268          0,                     /* bitsize */
 269          FALSE,                 /* pc_relative */
 270          0,                     /* bitpos */
 271          complain_overflow_dont, /* complain_on_overflow */
 272          bfd_elf_generic_reloc, /* special_function */
 273          "R_PPC64_NONE",        /* name */
 274          FALSE,                 /* partial_inplace */
 275          0,                     /* src_mask */
 276          0,                     /* dst_mask */
 277          FALSE),                /* pcrel_offset */
 278
 279   /* A standard 32 bit relocation.  */
 280   HOWTO (R_PPC64_ADDR32,        /* type */
 281          0,                     /* rightshift */
 282          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 283          32,                    /* bitsize */
 284          FALSE,                 /* pc_relative */
 285          0,                     /* bitpos */
 286          complain_overflow_bitfield, /* complain_on_overflow */
 287          bfd_elf_generic_reloc, /* special_function */
 288          "R_PPC64_ADDR32",      /* name */
 289          FALSE,                 /* partial_inplace */
 290          0,                     /* src_mask */
 291          0xffffffff,            /* dst_mask */
 292          FALSE),                /* pcrel_offset */
 293
 294   /* An absolute 26 bit branch; the lower two bits must be zero.
 295      FIXME: we don't check that, we just clear them.  */
 296   HOWTO (R_PPC64_ADDR24,        /* type */
 297          0,                     /* rightshift */
 298          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 299          26,                    /* bitsize */
 300          FALSE,                 /* pc_relative */
 301          0,                     /* bitpos */
 302          complain_overflow_bitfield, /* complain_on_overflow */
 303          bfd_elf_generic_reloc, /* special_function */
 304          "R_PPC64_ADDR24",      /* name */
 305          FALSE,                 /* partial_inplace */
 306          0,                     /* src_mask */
 307          0x03fffffc,            /* dst_mask */
 308          FALSE),                /* pcrel_offset */
 309
 310   /* A standard 16 bit relocation.  */
 311   HOWTO (R_PPC64_ADDR16,        /* type */
 312          0,                     /* rightshift */
 313          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 314          16,                    /* bitsize */
 315          FALSE,                 /* pc_relative */
 316          0,                     /* bitpos */
 317          complain_overflow_bitfield, /* complain_on_overflow */
 318          bfd_elf_generic_reloc, /* special_function */
 319          "R_PPC64_ADDR16",      /* name */
 320          FALSE,                 /* partial_inplace */
 321          0,                     /* src_mask */
 322          0xffff,                /* dst_mask */
 323          FALSE),                /* pcrel_offset */
 324
 325   /* A 16 bit relocation without overflow.  */
 326   HOWTO (R_PPC64_ADDR16_LO,     /* type */
 327          0,                     /* rightshift */
 328          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 329          16,                    /* bitsize */
 330          FALSE,                 /* pc_relative */
 331          0,                     /* bitpos */
 332          complain_overflow_dont,/* complain_on_overflow */
 333          bfd_elf_generic_reloc, /* special_function */
 334          "R_PPC64_ADDR16_LO",   /* name */
 335          FALSE,                 /* partial_inplace */
 336          0,                     /* src_mask */
 337          0xffff,                /* dst_mask */
 338          FALSE),                /* pcrel_offset */
 339
 340   /* Bits 16-31 of an address.  */
 341   HOWTO (R_PPC64_ADDR16_HI,     /* type */
 342          16,                    /* rightshift */
 343          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 344          16,                    /* bitsize */
 345          FALSE,                 /* pc_relative */
 346          0,                     /* bitpos */
 347          complain_overflow_signed, /* complain_on_overflow */
 348          bfd_elf_generic_reloc, /* special_function */
 349          "R_PPC64_ADDR16_HI",   /* name */
 350          FALSE,                 /* partial_inplace */
 351          0,                     /* src_mask */
 352          0xffff,                /* dst_mask */
 353          FALSE),                /* pcrel_offset */
 354
 355   /* Bits 16-31 of an address, plus 1 if the contents of the low 16
 356      bits, treated as a signed number, is negative.  */
 357   HOWTO (R_PPC64_ADDR16_HA,     /* type */
 358          16,                    /* rightshift */
 359          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 360          16,                    /* bitsize */
 361          FALSE,                 /* pc_relative */
 362          0,                     /* bitpos */
 363          complain_overflow_signed, /* complain_on_overflow */
 364          ppc64_elf_ha_reloc,    /* special_function */
 365          "R_PPC64_ADDR16_HA",   /* name */
 366          FALSE,                 /* partial_inplace */
 367          0,                     /* src_mask */
 368          0xffff,                /* dst_mask */
 369          FALSE),                /* pcrel_offset */
 370
 371   /* An absolute 16 bit branch; the lower two bits must be zero.
 372      FIXME: we don't check that, we just clear them.  */
 373   HOWTO (R_PPC64_ADDR14,        /* type */
 374          0,                     /* rightshift */
 375          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 376          16,                    /* bitsize */
 377          FALSE,                 /* pc_relative */
 378          0,                     /* bitpos */
 379          complain_overflow_signed, /* complain_on_overflow */
 380          ppc64_elf_branch_reloc, /* special_function */
 381          "R_PPC64_ADDR14",      /* name */
 382          FALSE,                 /* partial_inplace */
 383          0,                     /* src_mask */
 384          0x0000fffc,            /* dst_mask */
 385          FALSE),                /* pcrel_offset */
 386
 387   /* An absolute 16 bit branch, for which bit 10 should be set to
 388      indicate that the branch is expected to be taken.  The lower two
 389      bits must be zero.  */
 390   HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
 391          0,                     /* rightshift */
 392          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 393          16,                    /* bitsize */
 394          FALSE,                 /* pc_relative */
 395          0,                     /* bitpos */
 396          complain_overflow_signed, /* complain_on_overflow */
 397          ppc64_elf_brtaken_reloc, /* special_function */
 398          "R_PPC64_ADDR14_BRTAKEN",/* name */
 399          FALSE,                 /* partial_inplace */
 400          0,                     /* src_mask */
 401          0x0000fffc,            /* dst_mask */
 402          FALSE),                /* pcrel_offset */
 403
 404   /* An absolute 16 bit branch, for which bit 10 should be set to
 405      indicate that the branch is not expected to be taken.  The lower
 406      two bits must be zero.  */
 407   HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
 408          0,                     /* rightshift */
 409          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 410          16,                    /* bitsize */
 411          FALSE,                 /* pc_relative */
 412          0,                     /* bitpos */
 413          complain_overflow_signed, /* complain_on_overflow */
 414          ppc64_elf_brtaken_reloc, /* special_function */
 415          "R_PPC64_ADDR14_BRNTAKEN",/* name */
 416          FALSE,                 /* partial_inplace */
 417          0,                     /* src_mask */
 418          0x0000fffc,            /* dst_mask */
 419          FALSE),                /* pcrel_offset */
 420
 421   /* A relative 26 bit branch; the lower two bits must be zero.  */
 422   HOWTO (R_PPC64_REL24,         /* type */
 423          0,                     /* rightshift */
 424          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 425          26,                    /* bitsize */
 426          TRUE,                  /* pc_relative */
 427          0,                     /* bitpos */
 428          complain_overflow_signed, /* complain_on_overflow */
 429          ppc64_elf_branch_reloc, /* special_function */
 430          "R_PPC64_REL24",       /* name */
 431          FALSE,                 /* partial_inplace */
 432          0,                     /* src_mask */
 433          0x03fffffc,            /* dst_mask */
 434          TRUE),                 /* pcrel_offset */
 435
 436   /* A relative 16 bit branch; the lower two bits must be zero.  */
 437   HOWTO (R_PPC64_REL14,         /* type */
 438          0,                     /* rightshift */
 439          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 440          16,                    /* bitsize */
 441          TRUE,                  /* pc_relative */
 442          0,                     /* bitpos */
 443          complain_overflow_signed, /* complain_on_overflow */
 444          ppc64_elf_branch_reloc, /* special_function */
 445          "R_PPC64_REL14",       /* name */
 446          FALSE,                 /* partial_inplace */
 447          0,                     /* src_mask */
 448          0x0000fffc,            /* dst_mask */
 449          TRUE),                 /* pcrel_offset */
 450
 451   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 452      the branch is expected to be taken.  The lower two bits must be
 453      zero.  */
 454   HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
 455          0,                     /* rightshift */
 456          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 457          16,                    /* bitsize */
 458          TRUE,                  /* pc_relative */
 459          0,                     /* bitpos */
 460          complain_overflow_signed, /* complain_on_overflow */
 461          ppc64_elf_brtaken_reloc, /* special_function */
 462          "R_PPC64_REL14_BRTAKEN", /* name */
 463          FALSE,                 /* partial_inplace */
 464          0,                     /* src_mask */
 465          0x0000fffc,            /* dst_mask */
 466          TRUE),                 /* pcrel_offset */
 467
 468   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 469      the branch is not expected to be taken.  The lower two bits must
 470      be zero.  */
 471   HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
 472          0,                     /* rightshift */
 473          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 474          16,                    /* bitsize */
 475          TRUE,                  /* pc_relative */
 476          0,                     /* bitpos */
 477          complain_overflow_signed, /* complain_on_overflow */
 478          ppc64_elf_brtaken_reloc, /* special_function */
 479          "R_PPC64_REL14_BRNTAKEN",/* name */
 480          FALSE,                 /* partial_inplace */
 481          0,                     /* src_mask */
 482          0x0000fffc,            /* dst_mask */
 483          TRUE),                 /* pcrel_offset */
 484
 485   /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
 486      symbol.  */
 487   HOWTO (R_PPC64_GOT16,         /* type */
 488          0,                     /* rightshift */
 489          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 490          16,                    /* bitsize */
 491          FALSE,                 /* pc_relative */
 492          0,                     /* bitpos */
 493          complain_overflow_signed, /* complain_on_overflow */
 494          ppc64_elf_unhandled_reloc, /* special_function */
 495          "R_PPC64_GOT16",       /* name */
 496          FALSE,                 /* partial_inplace */
 497          0,                     /* src_mask */
 498          0xffff,                /* dst_mask */
 499          FALSE),                /* pcrel_offset */
 500
 501   /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
 502      the symbol.  */
 503   HOWTO (R_PPC64_GOT16_LO,      /* type */
 504          0,                     /* rightshift */
 505          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 506          16,                    /* bitsize */
 507          FALSE,                 /* pc_relative */
 508          0,                     /* bitpos */
 509          complain_overflow_dont, /* complain_on_overflow */
 510          ppc64_elf_unhandled_reloc, /* special_function */
 511          "R_PPC64_GOT16_LO",    /* name */
 512          FALSE,                 /* partial_inplace */
 513          0,                     /* src_mask */
 514          0xffff,                /* dst_mask */
 515          FALSE),                /* pcrel_offset */
 516
 517   /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
 518      the symbol.  */
 519   HOWTO (R_PPC64_GOT16_HI,      /* type */
 520          16,                    /* rightshift */
 521          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 522          16,                    /* bitsize */
 523          FALSE,                 /* pc_relative */
 524          0,                     /* bitpos */
 525          complain_overflow_signed,/* complain_on_overflow */
 526          ppc64_elf_unhandled_reloc, /* special_function */
 527          "R_PPC64_GOT16_HI",    /* name */
 528          FALSE,                 /* partial_inplace */
 529          0,                     /* src_mask */
 530          0xffff,                /* dst_mask */
 531          FALSE),                /* pcrel_offset */
 532
 533   /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
 534      the symbol.  */
 535   HOWTO (R_PPC64_GOT16_HA,      /* type */
 536          16,                    /* rightshift */
 537          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 538          16,                    /* bitsize */
 539          FALSE,                 /* pc_relative */
 540          0,                     /* bitpos */
 541          complain_overflow_signed,/* complain_on_overflow */
 542          ppc64_elf_unhandled_reloc, /* special_function */
 543          "R_PPC64_GOT16_HA",    /* name */
 544          FALSE,                 /* partial_inplace */
 545          0,                     /* src_mask */
 546          0xffff,                /* dst_mask */
 547          FALSE),                /* pcrel_offset */
 548
 549   /* This is used only by the dynamic linker.  The symbol should exist
 550      both in the object being run and in some shared library.  The
 551      dynamic linker copies the data addressed by the symbol from the
 552      shared library into the object, because the object being
 553      run has to have the data at some particular address.  */
 554   HOWTO (R_PPC64_COPY,          /* type */
 555          0,                     /* rightshift */
 556          0,                     /* this one is variable size */
 557          0,                     /* bitsize */
 558          FALSE,                 /* pc_relative */
 559          0,                     /* bitpos */
 560          complain_overflow_dont, /* complain_on_overflow */
 561          ppc64_elf_unhandled_reloc, /* special_function */
 562          "R_PPC64_COPY",        /* name */
 563          FALSE,                 /* partial_inplace */
 564          0,                     /* src_mask */
 565          0,                     /* dst_mask */
 566          FALSE),                /* pcrel_offset */
 567
 568   /* Like R_PPC64_ADDR64, but used when setting global offset table
 569      entries.  */
 570   HOWTO (R_PPC64_GLOB_DAT,      /* type */
 571          0,                     /* rightshift */
 572          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 573          64,                    /* bitsize */
 574          FALSE,                 /* pc_relative */
 575          0,                     /* bitpos */
 576          complain_overflow_dont, /* complain_on_overflow */
 577          ppc64_elf_unhandled_reloc,  /* special_function */
 578          "R_PPC64_GLOB_DAT",    /* name */
 579          FALSE,                 /* partial_inplace */
 580          0,                     /* src_mask */
 581          ONES (64),             /* dst_mask */
 582          FALSE),                /* pcrel_offset */
 583
 584   /* Created by the link editor.  Marks a procedure linkage table
 585      entry for a symbol.  */
 586   HOWTO (R_PPC64_JMP_SLOT,      /* type */
 587          0,                     /* rightshift */
 588          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 589          0,                     /* bitsize */
 590          FALSE,                 /* pc_relative */
 591          0,                     /* bitpos */
 592          complain_overflow_dont, /* complain_on_overflow */
 593          ppc64_elf_unhandled_reloc, /* special_function */
 594          "R_PPC64_JMP_SLOT",    /* name */
 595          FALSE,                 /* partial_inplace */
 596          0,                     /* src_mask */
 597          0,                     /* dst_mask */
 598          FALSE),                /* pcrel_offset */
 599
 600   /* Used only by the dynamic linker.  When the object is run, this
 601      doubleword64 is set to the load address of the object, plus the
 602      addend.  */
 603   HOWTO (R_PPC64_RELATIVE,      /* type */
 604          0,                     /* rightshift */
 605          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 606          64,                    /* bitsize */
 607          FALSE,                 /* pc_relative */
 608          0,                     /* bitpos */
 609          complain_overflow_dont, /* complain_on_overflow */
 610          bfd_elf_generic_reloc, /* special_function */
 611          "R_PPC64_RELATIVE",    /* name */
 612          FALSE,                 /* partial_inplace */
 613          0,                     /* src_mask */
 614          ONES (64),             /* dst_mask */
 615          FALSE),                /* pcrel_offset */
 616
 617   /* Like R_PPC64_ADDR32, but may be unaligned.  */
 618   HOWTO (R_PPC64_UADDR32,       /* type */
 619          0,                     /* rightshift */
 620          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 621          32,                    /* bitsize */
 622          FALSE,                 /* pc_relative */
 623          0,                     /* bitpos */
 624          complain_overflow_bitfield, /* complain_on_overflow */
 625          bfd_elf_generic_reloc, /* special_function */
 626          "R_PPC64_UADDR32",     /* name */
 627          FALSE,                 /* partial_inplace */
 628          0,                     /* src_mask */
 629          0xffffffff,            /* dst_mask */
 630          FALSE),                /* pcrel_offset */
 631
 632   /* Like R_PPC64_ADDR16, but may be unaligned.  */
 633   HOWTO (R_PPC64_UADDR16,       /* type */
 634          0,                     /* rightshift */
 635          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 636          16,                    /* bitsize */
 637          FALSE,                 /* pc_relative */
 638          0,                     /* bitpos */
 639          complain_overflow_bitfield, /* complain_on_overflow */
 640          bfd_elf_generic_reloc, /* special_function */
 641          "R_PPC64_UADDR16",     /* name */
 642          FALSE,                 /* partial_inplace */
 643          0,                     /* src_mask */
 644          0xffff,                /* dst_mask */
 645          FALSE),                /* pcrel_offset */
 646
 647   /* 32-bit PC relative.  */
 648   HOWTO (R_PPC64_REL32,         /* type */
 649          0,                     /* rightshift */
 650          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 651          32,                    /* bitsize */
 652          TRUE,                  /* pc_relative */
 653          0,                     /* bitpos */
 654          complain_overflow_signed, /* complain_on_overflow */
 655          bfd_elf_generic_reloc, /* special_function */
 656          "R_PPC64_REL32",       /* name */
 657          FALSE,                 /* partial_inplace */
 658          0,                     /* src_mask */
 659          0xffffffff,            /* dst_mask */
 660          TRUE),                 /* pcrel_offset */
 661
 662   /* 32-bit relocation to the symbol's procedure linkage table.  */
 663   HOWTO (R_PPC64_PLT32,         /* type */
 664          0,                     /* rightshift */
 665          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 666          32,                    /* bitsize */
 667          FALSE,                 /* pc_relative */
 668          0,                     /* bitpos */
 669          complain_overflow_bitfield, /* complain_on_overflow */
 670          ppc64_elf_unhandled_reloc, /* special_function */
 671          "R_PPC64_PLT32",       /* name */
 672          FALSE,                 /* partial_inplace */
 673          0,                     /* src_mask */
 674          0xffffffff,            /* dst_mask */
 675          FALSE),                /* pcrel_offset */
 676
 677   /* 32-bit PC relative relocation to the symbol's procedure linkage table.
 678      FIXME: R_PPC64_PLTREL32 not supported.  */
 679   HOWTO (R_PPC64_PLTREL32,      /* type */
 680          0,                     /* rightshift */
 681          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 682          32,                    /* bitsize */
 683          TRUE,                  /* pc_relative */
 684          0,                     /* bitpos */
 685          complain_overflow_signed, /* complain_on_overflow */
 686          bfd_elf_generic_reloc, /* special_function */
 687          "R_PPC64_PLTREL32",    /* name */
 688          FALSE,                 /* partial_inplace */
 689          0,                     /* src_mask */
 690          0xffffffff,            /* dst_mask */
 691          TRUE),                 /* pcrel_offset */
 692
 693   /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
 694      the symbol.  */
 695   HOWTO (R_PPC64_PLT16_LO,      /* type */
 696          0,                     /* rightshift */
 697          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 698          16,                    /* bitsize */
 699          FALSE,                 /* pc_relative */
 700          0,                     /* bitpos */
 701          complain_overflow_dont, /* complain_on_overflow */
 702          ppc64_elf_unhandled_reloc, /* special_function */
 703          "R_PPC64_PLT16_LO",    /* name */
 704          FALSE,                 /* partial_inplace */
 705          0,                     /* src_mask */
 706          0xffff,                /* dst_mask */
 707          FALSE),                /* pcrel_offset */
 708
 709   /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
 710      the symbol.  */
 711   HOWTO (R_PPC64_PLT16_HI,      /* type */
 712          16,                    /* rightshift */
 713          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 714          16,                    /* bitsize */
 715          FALSE,                 /* pc_relative */
 716          0,                     /* bitpos */
 717          complain_overflow_signed, /* complain_on_overflow */
 718          ppc64_elf_unhandled_reloc, /* special_function */
 719          "R_PPC64_PLT16_HI",    /* name */
 720          FALSE,                 /* partial_inplace */
 721          0,                     /* src_mask */
 722          0xffff,                /* dst_mask */
 723          FALSE),                /* pcrel_offset */
 724
 725   /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
 726      the symbol.  */
 727   HOWTO (R_PPC64_PLT16_HA,      /* type */
 728          16,                    /* rightshift */
 729          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 730          16,                    /* bitsize */
 731          FALSE,                 /* pc_relative */
 732          0,                     /* bitpos */
 733          complain_overflow_signed, /* complain_on_overflow */
 734          ppc64_elf_unhandled_reloc, /* special_function */
 735          "R_PPC64_PLT16_HA",    /* name */
 736          FALSE,                 /* partial_inplace */
 737          0,                     /* src_mask */
 738          0xffff,                /* dst_mask */
 739          FALSE),                /* pcrel_offset */
 740
 741   /* 16-bit section relative relocation.  */
 742   HOWTO (R_PPC64_SECTOFF,       /* type */
 743          0,                     /* rightshift */
 744          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 745          16,                    /* bitsize */
 746          FALSE,                 /* pc_relative */
 747          0,                     /* bitpos */
 748          complain_overflow_signed, /* complain_on_overflow */
 749          ppc64_elf_sectoff_reloc, /* special_function */
 750          "R_PPC64_SECTOFF",     /* name */
 751          FALSE,                 /* partial_inplace */
 752          0,                     /* src_mask */
 753          0xffff,                /* dst_mask */
 754          FALSE),                /* pcrel_offset */
 755
 756   /* Like R_PPC64_SECTOFF, but no overflow warning.  */
 757   HOWTO (R_PPC64_SECTOFF_LO,    /* type */
 758          0,                     /* rightshift */
 759          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 760          16,                    /* bitsize */
 761          FALSE,                 /* pc_relative */
 762          0,                     /* bitpos */
 763          complain_overflow_dont, /* complain_on_overflow */
 764          ppc64_elf_sectoff_reloc, /* special_function */
 765          "R_PPC64_SECTOFF_LO",  /* name */
 766          FALSE,                 /* partial_inplace */
 767          0,                     /* src_mask */
 768          0xffff,                /* dst_mask */
 769          FALSE),                /* pcrel_offset */
 770
 771   /* 16-bit upper half section relative relocation.  */
 772   HOWTO (R_PPC64_SECTOFF_HI,    /* type */
 773          16,                    /* rightshift */
 774          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 775          16,                    /* bitsize */
 776          FALSE,                 /* pc_relative */
 777          0,                     /* bitpos */
 778          complain_overflow_signed, /* complain_on_overflow */
 779          ppc64_elf_sectoff_reloc, /* special_function */
 780          "R_PPC64_SECTOFF_HI",  /* name */
 781          FALSE,                 /* partial_inplace */
 782          0,                     /* src_mask */
 783          0xffff,                /* dst_mask */
 784          FALSE),                /* pcrel_offset */
 785
 786   /* 16-bit upper half adjusted section relative relocation.  */
 787   HOWTO (R_PPC64_SECTOFF_HA,    /* type */
 788          16,                    /* rightshift */
 789          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 790          16,                    /* bitsize */
 791          FALSE,                 /* pc_relative */
 792          0,                     /* bitpos */
 793          complain_overflow_signed, /* complain_on_overflow */
 794          ppc64_elf_sectoff_ha_reloc, /* special_function */
 795          "R_PPC64_SECTOFF_HA",  /* name */
 796          FALSE,                 /* partial_inplace */
 797          0,                     /* src_mask */
 798          0xffff,                /* dst_mask */
 799          FALSE),                /* pcrel_offset */
 800
 801   /* Like R_PPC64_REL24 without touching the two least significant bits.  */
 802   HOWTO (R_PPC64_REL30,         /* type */
 803          2,                     /* rightshift */
 804          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 805          30,                    /* bitsize */
 806          TRUE,                  /* pc_relative */
 807          0,                     /* bitpos */
 808          complain_overflow_dont, /* complain_on_overflow */
 809          bfd_elf_generic_reloc, /* special_function */
 810          "R_PPC64_REL30",       /* name */
 811          FALSE,                 /* partial_inplace */
 812          0,                     /* src_mask */
 813          0xfffffffc,            /* dst_mask */
 814          TRUE),                 /* pcrel_offset */
 815
 816   /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI.  */
 817
 818   /* A standard 64-bit relocation.  */
 819   HOWTO (R_PPC64_ADDR64,        /* type */
 820          0,                     /* rightshift */
 821          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 822          64,                    /* bitsize */
 823          FALSE,                 /* pc_relative */
 824          0,                     /* bitpos */
 825          complain_overflow_dont, /* complain_on_overflow */
 826          bfd_elf_generic_reloc, /* special_function */
 827          "R_PPC64_ADDR64",      /* name */
 828          FALSE,                 /* partial_inplace */
 829          0,                     /* src_mask */
 830          ONES (64),             /* dst_mask */
 831          FALSE),                /* pcrel_offset */
 832
 833   /* The bits 32-47 of an address.  */
 834   HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
 835          32,                    /* rightshift */
 836          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 837          16,                    /* bitsize */
 838          FALSE,                 /* pc_relative */
 839          0,                     /* bitpos */
 840          complain_overflow_dont, /* complain_on_overflow */
 841          bfd_elf_generic_reloc, /* special_function */
 842          "R_PPC64_ADDR16_HIGHER", /* name */
 843          FALSE,                 /* partial_inplace */
 844          0,                     /* src_mask */
 845          0xffff,                /* dst_mask */
 846          FALSE),                /* pcrel_offset */
 847
 848   /* The bits 32-47 of an address, plus 1 if the contents of the low
 849      16 bits, treated as a signed number, is negative.  */
 850   HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
 851          32,                    /* rightshift */
 852          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 853          16,                    /* bitsize */
 854          FALSE,                 /* pc_relative */
 855          0,                     /* bitpos */
 856          complain_overflow_dont, /* complain_on_overflow */
 857          ppc64_elf_ha_reloc,    /* special_function */
 858          "R_PPC64_ADDR16_HIGHERA", /* name */
 859          FALSE,                 /* partial_inplace */
 860          0,                     /* src_mask */
 861          0xffff,                /* dst_mask */
 862          FALSE),                /* pcrel_offset */
 863
 864   /* The bits 48-63 of an address.  */
 865   HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
 866          48,                    /* rightshift */
 867          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 868          16,                    /* bitsize */
 869          FALSE,                 /* pc_relative */
 870          0,                     /* bitpos */
 871          complain_overflow_dont, /* complain_on_overflow */
 872          bfd_elf_generic_reloc, /* special_function */
 873          "R_PPC64_ADDR16_HIGHEST", /* name */
 874          FALSE,                 /* partial_inplace */
 875          0,                     /* src_mask */
 876          0xffff,                /* dst_mask */
 877          FALSE),                /* pcrel_offset */
 878
 879   /* The bits 48-63 of an address, plus 1 if the contents of the low
 880      16 bits, treated as a signed number, is negative.  */
 881   HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
 882          48,                    /* rightshift */
 883          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 884          16,                    /* bitsize */
 885          FALSE,                 /* pc_relative */
 886          0,                     /* bitpos */
 887          complain_overflow_dont, /* complain_on_overflow */
 888          ppc64_elf_ha_reloc,    /* special_function */
 889          "R_PPC64_ADDR16_HIGHESTA", /* name */
 890          FALSE,                 /* partial_inplace */
 891          0,                     /* src_mask */
 892          0xffff,                /* dst_mask */
 893          FALSE),                /* pcrel_offset */
 894
 895   /* Like ADDR64, but may be unaligned.  */
 896   HOWTO (R_PPC64_UADDR64,       /* type */
 897          0,                     /* rightshift */
 898          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 899          64,                    /* bitsize */
 900          FALSE,                 /* pc_relative */
 901          0,                     /* bitpos */
 902          complain_overflow_dont, /* complain_on_overflow */
 903          bfd_elf_generic_reloc, /* special_function */
 904          "R_PPC64_UADDR64",     /* name */
 905          FALSE,                 /* partial_inplace */
 906          0,                     /* src_mask */
 907          ONES (64),             /* dst_mask */
 908          FALSE),                /* pcrel_offset */
 909
 910   /* 64-bit relative relocation.  */
 911   HOWTO (R_PPC64_REL64,         /* type */
 912          0,                     /* rightshift */
 913          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 914          64,                    /* bitsize */
 915          TRUE,                  /* pc_relative */
 916          0,                     /* bitpos */
 917          complain_overflow_dont, /* complain_on_overflow */
 918          bfd_elf_generic_reloc, /* special_function */
 919          "R_PPC64_REL64",       /* name */
 920          FALSE,                 /* partial_inplace */
 921          0,                     /* src_mask */
 922          ONES (64),             /* dst_mask */
 923          TRUE),                 /* pcrel_offset */
 924
 925   /* 64-bit relocation to the symbol's procedure linkage table.  */
 926   HOWTO (R_PPC64_PLT64,         /* type */
 927          0,                     /* rightshift */
 928          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 929          64,                    /* bitsize */
 930          FALSE,                 /* pc_relative */
 931          0,                     /* bitpos */
 932          complain_overflow_dont, /* complain_on_overflow */
 933          ppc64_elf_unhandled_reloc, /* special_function */
 934          "R_PPC64_PLT64",       /* name */
 935          FALSE,                 /* partial_inplace */
 936          0,                     /* src_mask */
 937          ONES (64),             /* dst_mask */
 938          FALSE),                /* pcrel_offset */
 939
 940   /* 64-bit PC relative relocation to the symbol's procedure linkage
 941      table.  */
 942   /* FIXME: R_PPC64_PLTREL64 not supported.  */
 943   HOWTO (R_PPC64_PLTREL64,      /* type */
 944          0,                     /* rightshift */
 945          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 946          64,                    /* bitsize */
 947          TRUE,                  /* pc_relative */
 948          0,                     /* bitpos */
 949          complain_overflow_dont, /* complain_on_overflow */
 950          ppc64_elf_unhandled_reloc, /* special_function */
 951          "R_PPC64_PLTREL64",    /* name */
 952          FALSE,                 /* partial_inplace */
 953          0,                     /* src_mask */
 954          ONES (64),             /* dst_mask */
 955          TRUE),                 /* pcrel_offset */
 956
 957   /* 16 bit TOC-relative relocation.  */
 958
 959   /* R_PPC64_TOC16        47       half16*      S + A - .TOC.  */
 960   HOWTO (R_PPC64_TOC16,         /* type */
 961          0,                     /* rightshift */
 962          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 963          16,                    /* bitsize */
 964          FALSE,                 /* pc_relative */
 965          0,                     /* bitpos */
 966          complain_overflow_signed, /* complain_on_overflow */
 967          ppc64_elf_toc_reloc,   /* special_function */
 968          "R_PPC64_TOC16",       /* name */
 969          FALSE,                 /* partial_inplace */
 970          0,                     /* src_mask */
 971          0xffff,                /* dst_mask */
 972          FALSE),                /* pcrel_offset */
 973
 974   /* 16 bit TOC-relative relocation without overflow.  */
 975
 976   /* R_PPC64_TOC16_LO     48       half16        #lo (S + A - .TOC.)  */
 977   HOWTO (R_PPC64_TOC16_LO,      /* type */
 978          0,                     /* rightshift */
 979          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 980          16,                    /* bitsize */
 981          FALSE,                 /* pc_relative */
 982          0,                     /* bitpos */
 983          complain_overflow_dont, /* complain_on_overflow */
 984          ppc64_elf_toc_reloc,   /* special_function */
 985          "R_PPC64_TOC16_LO",    /* name */
 986          FALSE,                 /* partial_inplace */
 987          0,                     /* src_mask */
 988          0xffff,                /* dst_mask */
 989          FALSE),                /* pcrel_offset */
 990
 991   /* 16 bit TOC-relative relocation, high 16 bits.  */
 992
 993   /* R_PPC64_TOC16_HI     49       half16        #hi (S + A - .TOC.)  */
 994   HOWTO (R_PPC64_TOC16_HI,      /* type */
 995          16,                    /* rightshift */
 996          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 997          16,                    /* bitsize */
 998          FALSE,                 /* pc_relative */
 999          0,                     /* bitpos */
1000          complain_overflow_signed, /* complain_on_overflow */
1001          ppc64_elf_toc_reloc,   /* special_function */
1002          "R_PPC64_TOC16_HI",    /* name */
1003          FALSE,                 /* partial_inplace */
1004          0,                     /* src_mask */
1005          0xffff,                /* dst_mask */
1006          FALSE),                /* pcrel_offset */
1007
1008   /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
1009      contents of the low 16 bits, treated as a signed number, is
1010      negative.  */
1011
1012   /* R_PPC64_TOC16_HA     50       half16        #ha (S + A - .TOC.)  */
1013   HOWTO (R_PPC64_TOC16_HA,      /* type */
1014          16,                    /* rightshift */
1015          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1016          16,                    /* bitsize */
1017          FALSE,                 /* pc_relative */
1018          0,                     /* bitpos */
1019          complain_overflow_signed, /* complain_on_overflow */
1020          ppc64_elf_toc_ha_reloc, /* special_function */
1021          "R_PPC64_TOC16_HA",    /* name */
1022          FALSE,                 /* partial_inplace */
1023          0,                     /* src_mask */
1024          0xffff,                /* dst_mask */
1025          FALSE),                /* pcrel_offset */
1026
1027   /* 64-bit relocation; insert value of TOC base (.TOC.).  */
1028
1029   /* R_PPC64_TOC                  51       doubleword64  .TOC.  */
1030   HOWTO (R_PPC64_TOC,           /* type */
1031          0,                     /* rightshift */
1032          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1033          64,                    /* bitsize */
1034          FALSE,                 /* pc_relative */
1035          0,                     /* bitpos */
1036          complain_overflow_dont, /* complain_on_overflow */
1037          ppc64_elf_toc64_reloc, /* special_function */
1038          "R_PPC64_TOC",         /* name */
1039          FALSE,                 /* partial_inplace */
1040          0,                     /* src_mask */
1041          ONES (64),             /* dst_mask */
1042          FALSE),                /* pcrel_offset */
1043
1044   /* Like R_PPC64_GOT16, but also informs the link editor that the
1045      value to relocate may (!) refer to a PLT entry which the link
1046      editor (a) may replace with the symbol value.  If the link editor
1047      is unable to fully resolve the symbol, it may (b) create a PLT
1048      entry and store the address to the new PLT entry in the GOT.
1049      This permits lazy resolution of function symbols at run time.
1050      The link editor may also skip all of this and just (c) emit a
1051      R_PPC64_GLOB_DAT to tie the symbol to the GOT entry.  */
1052   /* FIXME: R_PPC64_PLTGOT16 not implemented.  */
1053     HOWTO (R_PPC64_PLTGOT16,    /* type */
1054          0,                     /* rightshift */
1055          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1056          16,                    /* bitsize */
1057          FALSE,                 /* pc_relative */
1058          0,                     /* bitpos */
1059          complain_overflow_signed, /* complain_on_overflow */
1060          ppc64_elf_unhandled_reloc, /* special_function */
1061          "R_PPC64_PLTGOT16",    /* name */
1062          FALSE,                 /* partial_inplace */
1063          0,                     /* src_mask */
1064          0xffff,                /* dst_mask */
1065          FALSE),                /* pcrel_offset */
1066
1067   /* Like R_PPC64_PLTGOT16, but without overflow.  */
1068   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1069   HOWTO (R_PPC64_PLTGOT16_LO,   /* type */
1070          0,                     /* rightshift */
1071          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1072          16,                    /* bitsize */
1073          FALSE,                 /* pc_relative */
1074          0,                     /* bitpos */
1075          complain_overflow_dont, /* complain_on_overflow */
1076          ppc64_elf_unhandled_reloc, /* special_function */
1077          "R_PPC64_PLTGOT16_LO", /* name */
1078          FALSE,                 /* partial_inplace */
1079          0,                     /* src_mask */
1080          0xffff,                /* dst_mask */
1081          FALSE),                /* pcrel_offset */
1082
1083   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address.  */
1084   /* FIXME: R_PPC64_PLTGOT16_HI not implemented.  */
1085   HOWTO (R_PPC64_PLTGOT16_HI,   /* type */
1086          16,                    /* rightshift */
1087          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1088          16,                    /* bitsize */
1089          FALSE,                 /* pc_relative */
1090          0,                     /* bitpos */
1091          complain_overflow_signed, /* complain_on_overflow */
1092          ppc64_elf_unhandled_reloc, /* special_function */
1093          "R_PPC64_PLTGOT16_HI", /* name */
1094          FALSE,                 /* partial_inplace */
1095          0,                     /* src_mask */
1096          0xffff,                /* dst_mask */
1097          FALSE),                /* pcrel_offset */
1098
1099   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1100      1 if the contents of the low 16 bits, treated as a signed number,
1101      is negative.  */
1102   /* FIXME: R_PPC64_PLTGOT16_HA not implemented.  */
1103   HOWTO (R_PPC64_PLTGOT16_HA,   /* type */
1104          16,                    /* rightshift */
1105          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1106          16,                    /* bitsize */
1107          FALSE,                 /* pc_relative */
1108          0,                     /* bitpos */
1109          complain_overflow_signed, /* complain_on_overflow */
1110          ppc64_elf_unhandled_reloc, /* special_function */
1111          "R_PPC64_PLTGOT16_HA", /* name */
1112          FALSE,                 /* partial_inplace */
1113          0,                     /* src_mask */
1114          0xffff,                /* dst_mask */
1115          FALSE),                /* pcrel_offset */
1116
1117   /* Like R_PPC64_ADDR16, but for instructions with a DS field.  */
1118   HOWTO (R_PPC64_ADDR16_DS,     /* type */
1119          0,                     /* rightshift */
1120          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1121          16,                    /* bitsize */
1122          FALSE,                 /* pc_relative */
1123          0,                     /* bitpos */
1124          complain_overflow_signed, /* complain_on_overflow */
1125          bfd_elf_generic_reloc, /* special_function */
1126          "R_PPC64_ADDR16_DS",   /* name */
1127          FALSE,                 /* partial_inplace */
1128          0,                     /* src_mask */
1129          0xfffc,                /* dst_mask */
1130          FALSE),                /* pcrel_offset */
1131
1132   /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field.  */
1133   HOWTO (R_PPC64_ADDR16_LO_DS,  /* type */
1134          0,                     /* rightshift */
1135          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1136          16,                    /* bitsize */
1137          FALSE,                 /* pc_relative */
1138          0,                     /* bitpos */
1139          complain_overflow_dont,/* complain_on_overflow */
1140          bfd_elf_generic_reloc, /* special_function */
1141          "R_PPC64_ADDR16_LO_DS",/* name */
1142          FALSE,                 /* partial_inplace */
1143          0,                     /* src_mask */
1144          0xfffc,                /* dst_mask */
1145          FALSE),                /* pcrel_offset */
1146
1147   /* Like R_PPC64_GOT16, but for instructions with a DS field.  */
1148   HOWTO (R_PPC64_GOT16_DS,      /* type */
1149          0,                     /* rightshift */
1150          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1151          16,                    /* bitsize */
1152          FALSE,                 /* pc_relative */
1153          0,                     /* bitpos */
1154          complain_overflow_signed, /* complain_on_overflow */
1155          ppc64_elf_unhandled_reloc, /* special_function */
1156          "R_PPC64_GOT16_DS",    /* name */
1157          FALSE,                 /* partial_inplace */
1158          0,                     /* src_mask */
1159          0xfffc,                /* dst_mask */
1160          FALSE),                /* pcrel_offset */
1161
1162   /* Like R_PPC64_GOT16_LO, but for instructions with a DS field.  */
1163   HOWTO (R_PPC64_GOT16_LO_DS,   /* type */
1164          0,                     /* rightshift */
1165          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1166          16,                    /* bitsize */
1167          FALSE,                 /* pc_relative */
1168          0,                     /* bitpos */
1169          complain_overflow_dont, /* complain_on_overflow */
1170          ppc64_elf_unhandled_reloc, /* special_function */
1171          "R_PPC64_GOT16_LO_DS", /* name */
1172          FALSE,                 /* partial_inplace */
1173          0,                     /* src_mask */
1174          0xfffc,                /* dst_mask */
1175          FALSE),                /* pcrel_offset */
1176
1177   /* Like R_PPC64_PLT16_LO, but for instructions with a DS field.  */
1178   HOWTO (R_PPC64_PLT16_LO_DS,   /* type */
1179          0,                     /* rightshift */
1180          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1181          16,                    /* bitsize */
1182          FALSE,                 /* pc_relative */
1183          0,                     /* bitpos */
1184          complain_overflow_dont, /* complain_on_overflow */
1185          ppc64_elf_unhandled_reloc, /* special_function */
1186          "R_PPC64_PLT16_LO_DS", /* name */
1187          FALSE,                 /* partial_inplace */
1188          0,                     /* src_mask */
1189          0xfffc,                /* dst_mask */
1190          FALSE),                /* pcrel_offset */
1191
1192   /* Like R_PPC64_SECTOFF, but for instructions with a DS field.  */
1193   HOWTO (R_PPC64_SECTOFF_DS,    /* type */
1194          0,                     /* rightshift */
1195          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1196          16,                    /* bitsize */
1197          FALSE,                 /* pc_relative */
1198          0,                     /* bitpos */
1199          complain_overflow_signed, /* complain_on_overflow */
1200          ppc64_elf_sectoff_reloc, /* special_function */
1201          "R_PPC64_SECTOFF_DS",  /* name */
1202          FALSE,                 /* partial_inplace */
1203          0,                     /* src_mask */
1204          0xfffc,                /* dst_mask */
1205          FALSE),                /* pcrel_offset */
1206
1207   /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field.  */
1208   HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1209          0,                     /* rightshift */
1210          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1211          16,                    /* bitsize */
1212          FALSE,                 /* pc_relative */
1213          0,                     /* bitpos */
1214          complain_overflow_dont, /* complain_on_overflow */
1215          ppc64_elf_sectoff_reloc, /* special_function */
1216          "R_PPC64_SECTOFF_LO_DS",/* name */
1217          FALSE,                 /* partial_inplace */
1218          0,                     /* src_mask */
1219          0xfffc,                /* dst_mask */
1220          FALSE),                /* pcrel_offset */
1221
1222   /* Like R_PPC64_TOC16, but for instructions with a DS field.  */
1223   HOWTO (R_PPC64_TOC16_DS,      /* type */
1224          0,                     /* rightshift */
1225          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1226          16,                    /* bitsize */
1227          FALSE,                 /* pc_relative */
1228          0,                     /* bitpos */
1229          complain_overflow_signed, /* complain_on_overflow */
1230          ppc64_elf_toc_reloc,   /* special_function */
1231          "R_PPC64_TOC16_DS",    /* name */
1232          FALSE,                 /* partial_inplace */
1233          0,                     /* src_mask */
1234          0xfffc,                /* dst_mask */
1235          FALSE),                /* pcrel_offset */
1236
1237   /* Like R_PPC64_TOC16_LO, but for instructions with a DS field.  */
1238   HOWTO (R_PPC64_TOC16_LO_DS,   /* type */
1239          0,                     /* rightshift */
1240          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1241          16,                    /* bitsize */
1242          FALSE,                 /* pc_relative */
1243          0,                     /* bitpos */
1244          complain_overflow_dont, /* complain_on_overflow */
1245          ppc64_elf_toc_reloc,   /* special_function */
1246          "R_PPC64_TOC16_LO_DS", /* name */
1247          FALSE,                 /* partial_inplace */
1248          0,                     /* src_mask */
1249          0xfffc,                /* dst_mask */
1250          FALSE),                /* pcrel_offset */
1251
1252   /* Like R_PPC64_PLTGOT16, but for instructions with a DS field.  */
1253   /* FIXME: R_PPC64_PLTGOT16_DS not implemented.  */
1254   HOWTO (R_PPC64_PLTGOT16_DS,   /* type */
1255          0,                     /* rightshift */
1256          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1257          16,                    /* bitsize */
1258          FALSE,                 /* pc_relative */
1259          0,                     /* bitpos */
1260          complain_overflow_signed, /* complain_on_overflow */
1261          ppc64_elf_unhandled_reloc, /* special_function */
1262          "R_PPC64_PLTGOT16_DS", /* name */
1263          FALSE,                 /* partial_inplace */
1264          0,                     /* src_mask */
1265          0xfffc,                /* dst_mask */
1266          FALSE),                /* pcrel_offset */
1267
1268   /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field.  */
1269   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1270   HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1271          0,                     /* rightshift */
1272          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1273          16,                    /* bitsize */
1274          FALSE,                 /* pc_relative */
1275          0,                     /* bitpos */
1276          complain_overflow_dont, /* complain_on_overflow */
1277          ppc64_elf_unhandled_reloc, /* special_function */
1278          "R_PPC64_PLTGOT16_LO_DS",/* name */
1279          FALSE,                 /* partial_inplace */
1280          0,                     /* src_mask */
1281          0xfffc,                /* dst_mask */
1282          FALSE),                /* pcrel_offset */
1283
1284   /* Marker relocs for TLS.  */
1285   HOWTO (R_PPC64_TLS,
1286          0,                     /* rightshift */
1287          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1288          32,                    /* bitsize */
1289          FALSE,                 /* pc_relative */
1290          0,                     /* bitpos */
1291          complain_overflow_dont, /* complain_on_overflow */
1292          bfd_elf_generic_reloc, /* special_function */
1293          "R_PPC64_TLS",         /* name */
1294          FALSE,                 /* partial_inplace */
1295          0,                     /* src_mask */
1296          0,                     /* dst_mask */
1297          FALSE),                /* pcrel_offset */
1298
1299   HOWTO (R_PPC64_TLSGD,
1300          0,                     /* rightshift */
1301          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1302          32,                    /* bitsize */
1303          FALSE,                 /* pc_relative */
1304          0,                     /* bitpos */
1305          complain_overflow_dont, /* complain_on_overflow */
1306          bfd_elf_generic_reloc, /* special_function */
1307          "R_PPC64_TLSGD",       /* name */
1308          FALSE,                 /* partial_inplace */
1309          0,                     /* src_mask */
1310          0,                     /* dst_mask */
1311          FALSE),                /* pcrel_offset */
1312
1313   HOWTO (R_PPC64_TLSLD,
1314          0,                     /* rightshift */
1315          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1316          32,                    /* bitsize */
1317          FALSE,                 /* pc_relative */
1318          0,                     /* bitpos */
1319          complain_overflow_dont, /* complain_on_overflow */
1320          bfd_elf_generic_reloc, /* special_function */
1321          "R_PPC64_TLSLD",       /* name */
1322          FALSE,                 /* partial_inplace */
1323          0,                     /* src_mask */
1324          0,                     /* dst_mask */
1325          FALSE),                /* pcrel_offset */
1326
1327   HOWTO (R_PPC64_TOCSAVE,
1328          0,                     /* rightshift */
1329          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1330          32,                    /* bitsize */
1331          FALSE,                 /* pc_relative */
1332          0,                     /* bitpos */
1333          complain_overflow_dont, /* complain_on_overflow */
1334          bfd_elf_generic_reloc, /* special_function */
1335          "R_PPC64_TOCSAVE",     /* name */
1336          FALSE,                 /* partial_inplace */
1337          0,                     /* src_mask */
1338          0,                     /* dst_mask */
1339          FALSE),                /* pcrel_offset */
1340
1341   /* Computes the load module index of the load module that contains the
1342      definition of its TLS sym.  */
1343   HOWTO (R_PPC64_DTPMOD64,
1344          0,                     /* rightshift */
1345          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1346          64,                    /* bitsize */
1347          FALSE,                 /* pc_relative */
1348          0,                     /* bitpos */
1349          complain_overflow_dont, /* complain_on_overflow */
1350          ppc64_elf_unhandled_reloc, /* special_function */
1351          "R_PPC64_DTPMOD64",    /* name */
1352          FALSE,                 /* partial_inplace */
1353          0,                     /* src_mask */
1354          ONES (64),             /* dst_mask */
1355          FALSE),                /* pcrel_offset */
1356
1357   /* Computes a dtv-relative displacement, the difference between the value
1358      of sym+add and the base address of the thread-local storage block that
1359      contains the definition of sym, minus 0x8000.  */
1360   HOWTO (R_PPC64_DTPREL64,
1361          0,                     /* rightshift */
1362          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1363          64,                    /* bitsize */
1364          FALSE,                 /* pc_relative */
1365          0,                     /* bitpos */
1366          complain_overflow_dont, /* complain_on_overflow */
1367          ppc64_elf_unhandled_reloc, /* special_function */
1368          "R_PPC64_DTPREL64",    /* name */
1369          FALSE,                 /* partial_inplace */
1370          0,                     /* src_mask */
1371          ONES (64),             /* dst_mask */
1372          FALSE),                /* pcrel_offset */
1373
1374   /* A 16 bit dtprel reloc.  */
1375   HOWTO (R_PPC64_DTPREL16,
1376          0,                     /* rightshift */
1377          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1378          16,                    /* bitsize */
1379          FALSE,                 /* pc_relative */
1380          0,                     /* bitpos */
1381          complain_overflow_signed, /* complain_on_overflow */
1382          ppc64_elf_unhandled_reloc, /* special_function */
1383          "R_PPC64_DTPREL16",    /* name */
1384          FALSE,                 /* partial_inplace */
1385          0,                     /* src_mask */
1386          0xffff,                /* dst_mask */
1387          FALSE),                /* pcrel_offset */
1388
1389   /* Like DTPREL16, but no overflow.  */
1390   HOWTO (R_PPC64_DTPREL16_LO,
1391          0,                     /* rightshift */
1392          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1393          16,                    /* bitsize */
1394          FALSE,                 /* pc_relative */
1395          0,                     /* bitpos */
1396          complain_overflow_dont, /* complain_on_overflow */
1397          ppc64_elf_unhandled_reloc, /* special_function */
1398          "R_PPC64_DTPREL16_LO", /* name */
1399          FALSE,                 /* partial_inplace */
1400          0,                     /* src_mask */
1401          0xffff,                /* dst_mask */
1402          FALSE),                /* pcrel_offset */
1403
1404   /* Like DTPREL16_LO, but next higher group of 16 bits.  */
1405   HOWTO (R_PPC64_DTPREL16_HI,
1406          16,                    /* rightshift */
1407          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1408          16,                    /* bitsize */
1409          FALSE,                 /* pc_relative */
1410          0,                     /* bitpos */
1411          complain_overflow_signed, /* complain_on_overflow */
1412          ppc64_elf_unhandled_reloc, /* special_function */
1413          "R_PPC64_DTPREL16_HI", /* name */
1414          FALSE,                 /* partial_inplace */
1415          0,                     /* src_mask */
1416          0xffff,                /* dst_mask */
1417          FALSE),                /* pcrel_offset */
1418
1419   /* Like DTPREL16_HI, but adjust for low 16 bits.  */
1420   HOWTO (R_PPC64_DTPREL16_HA,
1421          16,                    /* rightshift */
1422          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1423          16,                    /* bitsize */
1424          FALSE,                 /* pc_relative */
1425          0,                     /* bitpos */
1426          complain_overflow_signed, /* complain_on_overflow */
1427          ppc64_elf_unhandled_reloc, /* special_function */
1428          "R_PPC64_DTPREL16_HA", /* name */
1429          FALSE,                 /* partial_inplace */
1430          0,                     /* src_mask */
1431          0xffff,                /* dst_mask */
1432          FALSE),                /* pcrel_offset */
1433
1434   /* Like DTPREL16_HI, but next higher group of 16 bits.  */
1435   HOWTO (R_PPC64_DTPREL16_HIGHER,
1436          32,                    /* rightshift */
1437          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1438          16,                    /* bitsize */
1439          FALSE,                 /* pc_relative */
1440          0,                     /* bitpos */
1441          complain_overflow_dont, /* complain_on_overflow */
1442          ppc64_elf_unhandled_reloc, /* special_function */
1443          "R_PPC64_DTPREL16_HIGHER", /* name */
1444          FALSE,                 /* partial_inplace */
1445          0,                     /* src_mask */
1446          0xffff,                /* dst_mask */
1447          FALSE),                /* pcrel_offset */
1448
1449   /* Like DTPREL16_HIGHER, but adjust for low 16 bits.  */
1450   HOWTO (R_PPC64_DTPREL16_HIGHERA,
1451          32,                    /* rightshift */
1452          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1453          16,                    /* bitsize */
1454          FALSE,                 /* pc_relative */
1455          0,                     /* bitpos */
1456          complain_overflow_dont, /* complain_on_overflow */
1457          ppc64_elf_unhandled_reloc, /* special_function */
1458          "R_PPC64_DTPREL16_HIGHERA", /* name */
1459          FALSE,                 /* partial_inplace */
1460          0,                     /* src_mask */
1461          0xffff,                /* dst_mask */
1462          FALSE),                /* pcrel_offset */
1463
1464   /* Like DTPREL16_HIGHER, but next higher group of 16 bits.  */
1465   HOWTO (R_PPC64_DTPREL16_HIGHEST,
1466          48,                    /* rightshift */
1467          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1468          16,                    /* bitsize */
1469          FALSE,                 /* pc_relative */
1470          0,                     /* bitpos */
1471          complain_overflow_dont, /* complain_on_overflow */
1472          ppc64_elf_unhandled_reloc, /* special_function */
1473          "R_PPC64_DTPREL16_HIGHEST", /* name */
1474          FALSE,                 /* partial_inplace */
1475          0,                     /* src_mask */
1476          0xffff,                /* dst_mask */
1477          FALSE),                /* pcrel_offset */
1478
1479   /* Like DTPREL16_HIGHEST, but adjust for low 16 bits.  */
1480   HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1481          48,                    /* rightshift */
1482          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1483          16,                    /* bitsize */
1484          FALSE,                 /* pc_relative */
1485          0,                     /* bitpos */
1486          complain_overflow_dont, /* complain_on_overflow */
1487          ppc64_elf_unhandled_reloc, /* special_function */
1488          "R_PPC64_DTPREL16_HIGHESTA", /* name */
1489          FALSE,                 /* partial_inplace */
1490          0,                     /* src_mask */
1491          0xffff,                /* dst_mask */
1492          FALSE),                /* pcrel_offset */
1493
1494   /* Like DTPREL16, but for insns with a DS field.  */
1495   HOWTO (R_PPC64_DTPREL16_DS,
1496          0,                     /* rightshift */
1497          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1498          16,                    /* bitsize */
1499          FALSE,                 /* pc_relative */
1500          0,                     /* bitpos */
1501          complain_overflow_signed, /* complain_on_overflow */
1502          ppc64_elf_unhandled_reloc, /* special_function */
1503          "R_PPC64_DTPREL16_DS", /* name */
1504          FALSE,                 /* partial_inplace */
1505          0,                     /* src_mask */
1506          0xfffc,                /* dst_mask */
1507          FALSE),                /* pcrel_offset */
1508
1509   /* Like DTPREL16_DS, but no overflow.  */
1510   HOWTO (R_PPC64_DTPREL16_LO_DS,
1511          0,                     /* rightshift */
1512          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1513          16,                    /* bitsize */
1514          FALSE,                 /* pc_relative */
1515          0,                     /* bitpos */
1516          complain_overflow_dont, /* complain_on_overflow */
1517          ppc64_elf_unhandled_reloc, /* special_function */
1518          "R_PPC64_DTPREL16_LO_DS", /* name */
1519          FALSE,                 /* partial_inplace */
1520          0,                     /* src_mask */
1521          0xfffc,                /* dst_mask */
1522          FALSE),                /* pcrel_offset */
1523
1524   /* Computes a tp-relative displacement, the difference between the value of
1525      sym+add and the value of the thread pointer (r13).  */
1526   HOWTO (R_PPC64_TPREL64,
1527          0,                     /* rightshift */
1528          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1529          64,                    /* bitsize */
1530          FALSE,                 /* pc_relative */
1531          0,                     /* bitpos */
1532          complain_overflow_dont, /* complain_on_overflow */
1533          ppc64_elf_unhandled_reloc, /* special_function */
1534          "R_PPC64_TPREL64",     /* name */
1535          FALSE,                 /* partial_inplace */
1536          0,                     /* src_mask */
1537          ONES (64),             /* dst_mask */
1538          FALSE),                /* pcrel_offset */
1539
1540   /* A 16 bit tprel reloc.  */
1541   HOWTO (R_PPC64_TPREL16,
1542          0,                     /* rightshift */
1543          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1544          16,                    /* bitsize */
1545          FALSE,                 /* pc_relative */
1546          0,                     /* bitpos */
1547          complain_overflow_signed, /* complain_on_overflow */
1548          ppc64_elf_unhandled_reloc, /* special_function */
1549          "R_PPC64_TPREL16",     /* name */
1550          FALSE,                 /* partial_inplace */
1551          0,                     /* src_mask */
1552          0xffff,                /* dst_mask */
1553          FALSE),                /* pcrel_offset */
1554
1555   /* Like TPREL16, but no overflow.  */
1556   HOWTO (R_PPC64_TPREL16_LO,
1557          0,                     /* rightshift */
1558          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1559          16,                    /* bitsize */
1560          FALSE,                 /* pc_relative */
1561          0,                     /* bitpos */
1562          complain_overflow_dont, /* complain_on_overflow */
1563          ppc64_elf_unhandled_reloc, /* special_function */
1564          "R_PPC64_TPREL16_LO",  /* name */
1565          FALSE,                 /* partial_inplace */
1566          0,                     /* src_mask */
1567          0xffff,                /* dst_mask */
1568          FALSE),                /* pcrel_offset */
1569
1570   /* Like TPREL16_LO, but next higher group of 16 bits.  */
1571   HOWTO (R_PPC64_TPREL16_HI,
1572          16,                    /* rightshift */
1573          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1574          16,                    /* bitsize */
1575          FALSE,                 /* pc_relative */
1576          0,                     /* bitpos */
1577          complain_overflow_signed, /* complain_on_overflow */
1578          ppc64_elf_unhandled_reloc, /* special_function */
1579          "R_PPC64_TPREL16_HI",  /* name */
1580          FALSE,                 /* partial_inplace */
1581          0,                     /* src_mask */
1582          0xffff,                /* dst_mask */
1583          FALSE),                /* pcrel_offset */
1584
1585   /* Like TPREL16_HI, but adjust for low 16 bits.  */
1586   HOWTO (R_PPC64_TPREL16_HA,
1587          16,                    /* rightshift */
1588          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1589          16,                    /* bitsize */
1590          FALSE,                 /* pc_relative */
1591          0,                     /* bitpos */
1592          complain_overflow_signed, /* complain_on_overflow */
1593          ppc64_elf_unhandled_reloc, /* special_function */
1594          "R_PPC64_TPREL16_HA",  /* name */
1595          FALSE,                 /* partial_inplace */
1596          0,                     /* src_mask */
1597          0xffff,                /* dst_mask */
1598          FALSE),                /* pcrel_offset */
1599
1600   /* Like TPREL16_HI, but next higher group of 16 bits.  */
1601   HOWTO (R_PPC64_TPREL16_HIGHER,
1602          32,                    /* rightshift */
1603          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1604          16,                    /* bitsize */
1605          FALSE,                 /* pc_relative */
1606          0,                     /* bitpos */
1607          complain_overflow_dont, /* complain_on_overflow */
1608          ppc64_elf_unhandled_reloc, /* special_function */
1609          "R_PPC64_TPREL16_HIGHER",      /* name */
1610          FALSE,                 /* partial_inplace */
1611          0,                     /* src_mask */
1612          0xffff,                /* dst_mask */
1613          FALSE),                /* pcrel_offset */
1614
1615   /* Like TPREL16_HIGHER, but adjust for low 16 bits.  */
1616   HOWTO (R_PPC64_TPREL16_HIGHERA,
1617          32,                    /* rightshift */
1618          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1619          16,                    /* bitsize */
1620          FALSE,                 /* pc_relative */
1621          0,                     /* bitpos */
1622          complain_overflow_dont, /* complain_on_overflow */
1623          ppc64_elf_unhandled_reloc, /* special_function */
1624          "R_PPC64_TPREL16_HIGHERA", /* name */
1625          FALSE,                 /* partial_inplace */
1626          0,                     /* src_mask */
1627          0xffff,                /* dst_mask */
1628          FALSE),                /* pcrel_offset */
1629
1630   /* Like TPREL16_HIGHER, but next higher group of 16 bits.  */
1631   HOWTO (R_PPC64_TPREL16_HIGHEST,
1632          48,                    /* rightshift */
1633          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1634          16,                    /* bitsize */
1635          FALSE,                 /* pc_relative */
1636          0,                     /* bitpos */
1637          complain_overflow_dont, /* complain_on_overflow */
1638          ppc64_elf_unhandled_reloc, /* special_function */
1639          "R_PPC64_TPREL16_HIGHEST", /* name */
1640          FALSE,                 /* partial_inplace */
1641          0,                     /* src_mask */
1642          0xffff,                /* dst_mask */
1643          FALSE),                /* pcrel_offset */
1644
1645   /* Like TPREL16_HIGHEST, but adjust for low 16 bits.  */
1646   HOWTO (R_PPC64_TPREL16_HIGHESTA,
1647          48,                    /* rightshift */
1648          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1649          16,                    /* bitsize */
1650          FALSE,                 /* pc_relative */
1651          0,                     /* bitpos */
1652          complain_overflow_dont, /* complain_on_overflow */
1653          ppc64_elf_unhandled_reloc, /* special_function */
1654          "R_PPC64_TPREL16_HIGHESTA", /* name */
1655          FALSE,                 /* partial_inplace */
1656          0,                     /* src_mask */
1657          0xffff,                /* dst_mask */
1658          FALSE),                /* pcrel_offset */
1659
1660   /* Like TPREL16, but for insns with a DS field.  */
1661   HOWTO (R_PPC64_TPREL16_DS,
1662          0,                     /* rightshift */
1663          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1664          16,                    /* bitsize */
1665          FALSE,                 /* pc_relative */
1666          0,                     /* bitpos */
1667          complain_overflow_signed, /* complain_on_overflow */
1668          ppc64_elf_unhandled_reloc, /* special_function */
1669          "R_PPC64_TPREL16_DS",  /* name */
1670          FALSE,                 /* partial_inplace */
1671          0,                     /* src_mask */
1672          0xfffc,                /* dst_mask */
1673          FALSE),                /* pcrel_offset */
1674
1675   /* Like TPREL16_DS, but no overflow.  */
1676   HOWTO (R_PPC64_TPREL16_LO_DS,
1677          0,                     /* rightshift */
1678          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1679          16,                    /* bitsize */
1680          FALSE,                 /* pc_relative */
1681          0,                     /* bitpos */
1682          complain_overflow_dont, /* complain_on_overflow */
1683          ppc64_elf_unhandled_reloc, /* special_function */
1684          "R_PPC64_TPREL16_LO_DS", /* name */
1685          FALSE,                 /* partial_inplace */
1686          0,                     /* src_mask */
1687          0xfffc,                /* dst_mask */
1688          FALSE),                /* pcrel_offset */
1689
1690   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1691      with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1692      to the first entry relative to the TOC base (r2).  */
1693   HOWTO (R_PPC64_GOT_TLSGD16,
1694          0,                     /* rightshift */
1695          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1696          16,                    /* bitsize */
1697          FALSE,                 /* pc_relative */
1698          0,                     /* bitpos */
1699          complain_overflow_signed, /* complain_on_overflow */
1700          ppc64_elf_unhandled_reloc, /* special_function */
1701          "R_PPC64_GOT_TLSGD16", /* name */
1702          FALSE,                 /* partial_inplace */
1703          0,                     /* src_mask */
1704          0xffff,                /* dst_mask */
1705          FALSE),                /* pcrel_offset */
1706
1707   /* Like GOT_TLSGD16, but no overflow.  */
1708   HOWTO (R_PPC64_GOT_TLSGD16_LO,
1709          0,                     /* rightshift */
1710          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1711          16,                    /* bitsize */
1712          FALSE,                 /* pc_relative */
1713          0,                     /* bitpos */
1714          complain_overflow_dont, /* complain_on_overflow */
1715          ppc64_elf_unhandled_reloc, /* special_function */
1716          "R_PPC64_GOT_TLSGD16_LO", /* name */
1717          FALSE,                 /* partial_inplace */
1718          0,                     /* src_mask */
1719          0xffff,                /* dst_mask */
1720          FALSE),                /* pcrel_offset */
1721
1722   /* Like GOT_TLSGD16_LO, but next higher group of 16 bits.  */
1723   HOWTO (R_PPC64_GOT_TLSGD16_HI,
1724          16,                    /* rightshift */
1725          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1726          16,                    /* bitsize */
1727          FALSE,                 /* pc_relative */
1728          0,                     /* bitpos */
1729          complain_overflow_signed, /* complain_on_overflow */
1730          ppc64_elf_unhandled_reloc, /* special_function */
1731          "R_PPC64_GOT_TLSGD16_HI", /* name */
1732          FALSE,                 /* partial_inplace */
1733          0,                     /* src_mask */
1734          0xffff,                /* dst_mask */
1735          FALSE),                /* pcrel_offset */
1736
1737   /* Like GOT_TLSGD16_HI, but adjust for low 16 bits.  */
1738   HOWTO (R_PPC64_GOT_TLSGD16_HA,
1739          16,                    /* rightshift */
1740          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1741          16,                    /* bitsize */
1742          FALSE,                 /* pc_relative */
1743          0,                     /* bitpos */
1744          complain_overflow_signed, /* complain_on_overflow */
1745          ppc64_elf_unhandled_reloc, /* special_function */
1746          "R_PPC64_GOT_TLSGD16_HA", /* name */
1747          FALSE,                 /* partial_inplace */
1748          0,                     /* src_mask */
1749          0xffff,                /* dst_mask */
1750          FALSE),                /* pcrel_offset */
1751
1752   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1753      with values (sym+add)@dtpmod and zero, and computes the offset to the
1754      first entry relative to the TOC base (r2).  */
1755   HOWTO (R_PPC64_GOT_TLSLD16,
1756          0,                     /* rightshift */
1757          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1758          16,                    /* bitsize */
1759          FALSE,                 /* pc_relative */
1760          0,                     /* bitpos */
1761          complain_overflow_signed, /* complain_on_overflow */
1762          ppc64_elf_unhandled_reloc, /* special_function */
1763          "R_PPC64_GOT_TLSLD16", /* name */
1764          FALSE,                 /* partial_inplace */
1765          0,                     /* src_mask */
1766          0xffff,                /* dst_mask */
1767          FALSE),                /* pcrel_offset */
1768
1769   /* Like GOT_TLSLD16, but no overflow.  */
1770   HOWTO (R_PPC64_GOT_TLSLD16_LO,
1771          0,                     /* rightshift */
1772          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1773          16,                    /* bitsize */
1774          FALSE,                 /* pc_relative */
1775          0,                     /* bitpos */
1776          complain_overflow_dont, /* complain_on_overflow */
1777          ppc64_elf_unhandled_reloc, /* special_function */
1778          "R_PPC64_GOT_TLSLD16_LO", /* name */
1779          FALSE,                 /* partial_inplace */
1780          0,                     /* src_mask */
1781          0xffff,                /* dst_mask */
1782          FALSE),                /* pcrel_offset */
1783
1784   /* Like GOT_TLSLD16_LO, but next higher group of 16 bits.  */
1785   HOWTO (R_PPC64_GOT_TLSLD16_HI,
1786          16,                    /* rightshift */
1787          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1788          16,                    /* bitsize */
1789          FALSE,                 /* pc_relative */
1790          0,                     /* bitpos */
1791          complain_overflow_signed, /* complain_on_overflow */
1792          ppc64_elf_unhandled_reloc, /* special_function */
1793          "R_PPC64_GOT_TLSLD16_HI", /* name */
1794          FALSE,                 /* partial_inplace */
1795          0,                     /* src_mask */
1796          0xffff,                /* dst_mask */
1797          FALSE),                /* pcrel_offset */
1798
1799   /* Like GOT_TLSLD16_HI, but adjust for low 16 bits.  */
1800   HOWTO (R_PPC64_GOT_TLSLD16_HA,
1801          16,                    /* rightshift */
1802          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1803          16,                    /* bitsize */
1804          FALSE,                 /* pc_relative */
1805          0,                     /* bitpos */
1806          complain_overflow_signed, /* complain_on_overflow */
1807          ppc64_elf_unhandled_reloc, /* special_function */
1808          "R_PPC64_GOT_TLSLD16_HA", /* name */
1809          FALSE,                 /* partial_inplace */
1810          0,                     /* src_mask */
1811          0xffff,                /* dst_mask */
1812          FALSE),                /* pcrel_offset */
1813
1814   /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1815      the offset to the entry relative to the TOC base (r2).  */
1816   HOWTO (R_PPC64_GOT_DTPREL16_DS,
1817          0,                     /* rightshift */
1818          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1819          16,                    /* bitsize */
1820          FALSE,                 /* pc_relative */
1821          0,                     /* bitpos */
1822          complain_overflow_signed, /* complain_on_overflow */
1823          ppc64_elf_unhandled_reloc, /* special_function */
1824          "R_PPC64_GOT_DTPREL16_DS", /* name */
1825          FALSE,                 /* partial_inplace */
1826          0,                     /* src_mask */
1827          0xfffc,                /* dst_mask */
1828          FALSE),                /* pcrel_offset */
1829
1830   /* Like GOT_DTPREL16_DS, but no overflow.  */
1831   HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1832          0,                     /* rightshift */
1833          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1834          16,                    /* bitsize */
1835          FALSE,                 /* pc_relative */
1836          0,                     /* bitpos */
1837          complain_overflow_dont, /* complain_on_overflow */
1838          ppc64_elf_unhandled_reloc, /* special_function */
1839          "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1840          FALSE,                 /* partial_inplace */
1841          0,                     /* src_mask */
1842          0xfffc,                /* dst_mask */
1843          FALSE),                /* pcrel_offset */
1844
1845   /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits.  */
1846   HOWTO (R_PPC64_GOT_DTPREL16_HI,
1847          16,                    /* rightshift */
1848          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1849          16,                    /* bitsize */
1850          FALSE,                 /* pc_relative */
1851          0,                     /* bitpos */
1852          complain_overflow_signed, /* complain_on_overflow */
1853          ppc64_elf_unhandled_reloc, /* special_function */
1854          "R_PPC64_GOT_DTPREL16_HI", /* name */
1855          FALSE,                 /* partial_inplace */
1856          0,                     /* src_mask */
1857          0xffff,                /* dst_mask */
1858          FALSE),                /* pcrel_offset */
1859
1860   /* Like GOT_DTPREL16_HI, but adjust for low 16 bits.  */
1861   HOWTO (R_PPC64_GOT_DTPREL16_HA,
1862          16,                    /* rightshift */
1863          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1864          16,                    /* bitsize */
1865          FALSE,                 /* pc_relative */
1866          0,                     /* bitpos */
1867          complain_overflow_signed, /* complain_on_overflow */
1868          ppc64_elf_unhandled_reloc, /* special_function */
1869          "R_PPC64_GOT_DTPREL16_HA", /* name */
1870          FALSE,                 /* partial_inplace */
1871          0,                     /* src_mask */
1872          0xffff,                /* dst_mask */
1873          FALSE),                /* pcrel_offset */
1874
1875   /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1876      offset to the entry relative to the TOC base (r2).  */
1877   HOWTO (R_PPC64_GOT_TPREL16_DS,
1878          0,                     /* rightshift */
1879          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1880          16,                    /* bitsize */
1881          FALSE,                 /* pc_relative */
1882          0,                     /* bitpos */
1883          complain_overflow_signed, /* complain_on_overflow */
1884          ppc64_elf_unhandled_reloc, /* special_function */
1885          "R_PPC64_GOT_TPREL16_DS", /* name */
1886          FALSE,                 /* partial_inplace */
1887          0,                     /* src_mask */
1888          0xfffc,                /* dst_mask */
1889          FALSE),                /* pcrel_offset */
1890
1891   /* Like GOT_TPREL16_DS, but no overflow.  */
1892   HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1893          0,                     /* rightshift */
1894          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1895          16,                    /* bitsize */
1896          FALSE,                 /* pc_relative */
1897          0,                     /* bitpos */
1898          complain_overflow_dont, /* complain_on_overflow */
1899          ppc64_elf_unhandled_reloc, /* special_function */
1900          "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1901          FALSE,                 /* partial_inplace */
1902          0,                     /* src_mask */
1903          0xfffc,                /* dst_mask */
1904          FALSE),                /* pcrel_offset */
1905
1906   /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits.  */
1907   HOWTO (R_PPC64_GOT_TPREL16_HI,
1908          16,                    /* rightshift */
1909          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1910          16,                    /* bitsize */
1911          FALSE,                 /* pc_relative */
1912          0,                     /* bitpos */
1913          complain_overflow_signed, /* complain_on_overflow */
1914          ppc64_elf_unhandled_reloc, /* special_function */
1915          "R_PPC64_GOT_TPREL16_HI", /* name */
1916          FALSE,                 /* partial_inplace */
1917          0,                     /* src_mask */
1918          0xffff,                /* dst_mask */
1919          FALSE),                /* pcrel_offset */
1920
1921   /* Like GOT_TPREL16_HI, but adjust for low 16 bits.  */
1922   HOWTO (R_PPC64_GOT_TPREL16_HA,
1923          16,                    /* rightshift */
1924          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1925          16,                    /* bitsize */
1926          FALSE,                 /* pc_relative */
1927          0,                     /* bitpos */
1928          complain_overflow_signed, /* complain_on_overflow */
1929          ppc64_elf_unhandled_reloc, /* special_function */
1930          "R_PPC64_GOT_TPREL16_HA", /* name */
1931          FALSE,                 /* partial_inplace */
1932          0,                     /* src_mask */
1933          0xffff,                /* dst_mask */
1934          FALSE),                /* pcrel_offset */
1935
1936   HOWTO (R_PPC64_JMP_IREL,      /* type */
1937          0,                     /* rightshift */
1938          0,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1939          0,                     /* bitsize */
1940          FALSE,                 /* pc_relative */
1941          0,                     /* bitpos */
1942          complain_overflow_dont, /* complain_on_overflow */
1943          ppc64_elf_unhandled_reloc, /* special_function */
1944          "R_PPC64_JMP_IREL",    /* name */
1945          FALSE,                 /* partial_inplace */
1946          0,                     /* src_mask */
1947          0,                     /* dst_mask */
1948          FALSE),                /* pcrel_offset */
1949
1950   HOWTO (R_PPC64_IRELATIVE,     /* type */
1951          0,                     /* rightshift */
1952          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1953          64,                    /* bitsize */
1954          FALSE,                 /* pc_relative */
1955          0,                     /* bitpos */
1956          complain_overflow_dont, /* complain_on_overflow */
1957          bfd_elf_generic_reloc, /* special_function */
1958          "R_PPC64_IRELATIVE",   /* name */
1959          FALSE,                 /* partial_inplace */
1960          0,                     /* src_mask */
1961          ONES (64),             /* dst_mask */
1962          FALSE),                /* pcrel_offset */
1963
1964   /* A 16 bit relative relocation.  */
1965   HOWTO (R_PPC64_REL16,         /* type */
1966          0,                     /* rightshift */
1967          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1968          16,                    /* bitsize */
1969          TRUE,                  /* pc_relative */
1970          0,                     /* bitpos */
1971          complain_overflow_signed, /* complain_on_overflow */
1972          bfd_elf_generic_reloc, /* special_function */
1973          "R_PPC64_REL16",       /* name */
1974          FALSE,                 /* partial_inplace */
1975          0,                     /* src_mask */
1976          0xffff,                /* dst_mask */
1977          TRUE),                 /* pcrel_offset */
1978
1979   /* A 16 bit relative relocation without overflow.  */
1980   HOWTO (R_PPC64_REL16_LO,      /* type */
1981          0,                     /* rightshift */
1982          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1983          16,                    /* bitsize */
1984          TRUE,                  /* pc_relative */
1985          0,                     /* bitpos */
1986          complain_overflow_dont,/* complain_on_overflow */
1987          bfd_elf_generic_reloc, /* special_function */
1988          "R_PPC64_REL16_LO",    /* name */
1989          FALSE,                 /* partial_inplace */
1990          0,                     /* src_mask */
1991          0xffff,                /* dst_mask */
1992          TRUE),                 /* pcrel_offset */
1993
1994   /* The high order 16 bits of a relative address.  */
1995   HOWTO (R_PPC64_REL16_HI,      /* type */
1996          16,                    /* rightshift */
1997          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1998          16,                    /* bitsize */
1999          TRUE,                  /* pc_relative */
2000          0,                     /* bitpos */
2001          complain_overflow_signed, /* complain_on_overflow */
2002          bfd_elf_generic_reloc, /* special_function */
2003          "R_PPC64_REL16_HI",    /* name */
2004          FALSE,                 /* partial_inplace */
2005          0,                     /* src_mask */
2006          0xffff,                /* dst_mask */
2007          TRUE),                 /* pcrel_offset */
2008
2009   /* The high order 16 bits of a relative address, plus 1 if the contents of
2010      the low 16 bits, treated as a signed number, is negative.  */
2011   HOWTO (R_PPC64_REL16_HA,      /* type */
2012          16,                    /* rightshift */
2013          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2014          16,                    /* bitsize */
2015          TRUE,                  /* pc_relative */
2016          0,                     /* bitpos */
2017          complain_overflow_signed, /* complain_on_overflow */
2018          ppc64_elf_ha_reloc,    /* special_function */
2019          "R_PPC64_REL16_HA",    /* name */
2020          FALSE,                 /* partial_inplace */
2021          0,                     /* src_mask */
2022          0xffff,                /* dst_mask */
2023          TRUE),                 /* pcrel_offset */
2024
2025   /* Like R_PPC64_REL16_HA but for split field in addpcis.  */
2026   HOWTO (R_PPC64_REL16DX_HA,    /* type */
2027          16,                    /* rightshift */
2028          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2029          16,                    /* bitsize */
2030          TRUE,                  /* pc_relative */
2031          0,                     /* bitpos */
2032          complain_overflow_signed, /* complain_on_overflow */
2033          ppc64_elf_ha_reloc,    /* special_function */
2034          "R_PPC64_REL16DX_HA",  /* name */
2035          FALSE,                 /* partial_inplace */
2036          0,                     /* src_mask */
2037          0x1fffc1,              /* dst_mask */
2038          TRUE),                 /* pcrel_offset */
2039
2040   /* Like R_PPC64_ADDR16_HI, but no overflow.  */
2041   HOWTO (R_PPC64_ADDR16_HIGH,   /* type */
2042          16,                    /* rightshift */
2043          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2044          16,                    /* bitsize */
2045          FALSE,                 /* pc_relative */
2046          0,                     /* bitpos */
2047          complain_overflow_dont, /* complain_on_overflow */
2048          bfd_elf_generic_reloc, /* special_function */
2049          "R_PPC64_ADDR16_HIGH", /* name */
2050          FALSE,                 /* partial_inplace */
2051          0,                     /* src_mask */
2052          0xffff,                /* dst_mask */
2053          FALSE),                /* pcrel_offset */
2054
2055   /* Like R_PPC64_ADDR16_HA, but no overflow.  */
2056   HOWTO (R_PPC64_ADDR16_HIGHA,  /* type */
2057          16,                    /* rightshift */
2058          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2059          16,                    /* bitsize */
2060          FALSE,                 /* pc_relative */
2061          0,                     /* bitpos */
2062          complain_overflow_dont, /* complain_on_overflow */
2063          ppc64_elf_ha_reloc,    /* special_function */
2064          "R_PPC64_ADDR16_HIGHA",        /* name */
2065          FALSE,                 /* partial_inplace */
2066          0,                     /* src_mask */
2067          0xffff,                /* dst_mask */
2068          FALSE),                /* pcrel_offset */
2069
2070   /* Like R_PPC64_DTPREL16_HI, but no overflow.  */
2071   HOWTO (R_PPC64_DTPREL16_HIGH,
2072          16,                    /* rightshift */
2073          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2074          16,                    /* bitsize */
2075          FALSE,                 /* pc_relative */
2076          0,                     /* bitpos */
2077          complain_overflow_dont, /* complain_on_overflow */
2078          ppc64_elf_unhandled_reloc, /* special_function */
2079          "R_PPC64_DTPREL16_HIGH", /* name */
2080          FALSE,                 /* partial_inplace */
2081          0,                     /* src_mask */
2082          0xffff,                /* dst_mask */
2083          FALSE),                /* pcrel_offset */
2084
2085   /* Like R_PPC64_DTPREL16_HA, but no overflow.  */
2086   HOWTO (R_PPC64_DTPREL16_HIGHA,
2087          16,                    /* rightshift */
2088          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2089          16,                    /* bitsize */
2090          FALSE,                 /* pc_relative */
2091          0,                     /* bitpos */
2092          complain_overflow_dont, /* complain_on_overflow */
2093          ppc64_elf_unhandled_reloc, /* special_function */
2094          "R_PPC64_DTPREL16_HIGHA", /* name */
2095          FALSE,                 /* partial_inplace */
2096          0,                     /* src_mask */
2097          0xffff,                /* dst_mask */
2098          FALSE),                /* pcrel_offset */
2099
2100   /* Like R_PPC64_TPREL16_HI, but no overflow.  */
2101   HOWTO (R_PPC64_TPREL16_HIGH,
2102          16,                    /* rightshift */
2103          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2104          16,                    /* bitsize */
2105          FALSE,                 /* pc_relative */
2106          0,                     /* bitpos */
2107          complain_overflow_dont, /* complain_on_overflow */
2108          ppc64_elf_unhandled_reloc, /* special_function */
2109          "R_PPC64_TPREL16_HIGH",        /* name */
2110          FALSE,                 /* partial_inplace */
2111          0,                     /* src_mask */
2112          0xffff,                /* dst_mask */
2113          FALSE),                /* pcrel_offset */
2114
2115   /* Like R_PPC64_TPREL16_HA, but no overflow.  */
2116   HOWTO (R_PPC64_TPREL16_HIGHA,
2117          16,                    /* rightshift */
2118          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2119          16,                    /* bitsize */
2120          FALSE,                 /* pc_relative */
2121          0,                     /* bitpos */
2122          complain_overflow_dont, /* complain_on_overflow */
2123          ppc64_elf_unhandled_reloc, /* special_function */
2124          "R_PPC64_TPREL16_HIGHA",       /* name */
2125          FALSE,                 /* partial_inplace */
2126          0,                     /* src_mask */
2127          0xffff,                /* dst_mask */
2128          FALSE),                /* pcrel_offset */
2129
2130   /* Like ADDR64, but use local entry point of function.  */
2131   HOWTO (R_PPC64_ADDR64_LOCAL,  /* type */
2132          0,                     /* rightshift */
2133          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2134          64,                    /* bitsize */
2135          FALSE,                 /* pc_relative */
2136          0,                     /* bitpos */
2137          complain_overflow_dont, /* complain_on_overflow */
2138          bfd_elf_generic_reloc, /* special_function */
2139          "R_PPC64_ADDR64_LOCAL", /* name */
2140          FALSE,                 /* partial_inplace */
2141          0,                     /* src_mask */
2142          ONES (64),             /* dst_mask */
2143          FALSE),                /* pcrel_offset */
2144
2145   /* GNU extension to record C++ vtable hierarchy.  */
2146   HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2147          0,                     /* rightshift */
2148          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2149          0,                     /* bitsize */
2150          FALSE,                 /* pc_relative */
2151          0,                     /* bitpos */
2152          complain_overflow_dont, /* complain_on_overflow */
2153          NULL,                  /* special_function */
2154          "R_PPC64_GNU_VTINHERIT", /* name */
2155          FALSE,                 /* partial_inplace */
2156          0,                     /* src_mask */
2157          0,                     /* dst_mask */
2158          FALSE),                /* pcrel_offset */
2159
2160   /* GNU extension to record C++ vtable member usage.  */
2161   HOWTO (R_PPC64_GNU_VTENTRY,   /* type */
2162          0,                     /* rightshift */
2163          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2164          0,                     /* bitsize */
2165          FALSE,                 /* pc_relative */
2166          0,                     /* bitpos */
2167          complain_overflow_dont, /* complain_on_overflow */
2168          NULL,                  /* special_function */
2169          "R_PPC64_GNU_VTENTRY", /* name */
2170          FALSE,                 /* partial_inplace */
2171          0,                     /* src_mask */
2172          0,                     /* dst_mask */
2173          FALSE),                /* pcrel_offset */
2174 };
2175
2176 \f
2177 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2178    be done.  */
2179
2180 static void
2181 ppc_howto_init (void)
2182 {
2183   unsigned int i, type;
2184
2185   for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2186     {
2187       type = ppc64_elf_howto_raw[i].type;
2188       BFD_ASSERT (type < ARRAY_SIZE (ppc64_elf_howto_table));
2189       ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2190     }
2191 }
2192
2193 static reloc_howto_type *
2194 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2195                              bfd_reloc_code_real_type code)
2196 {
2197   enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2198
2199   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2200     /* Initialize howto table if needed.  */
2201     ppc_howto_init ();
2202
2203   switch (code)
2204     {
2205     default:
2206       return NULL;
2207
2208     case BFD_RELOC_NONE:                        r = R_PPC64_NONE;
2209       break;
2210     case BFD_RELOC_32:                          r = R_PPC64_ADDR32;
2211       break;
2212     case BFD_RELOC_PPC_BA26:                    r = R_PPC64_ADDR24;
2213       break;
2214     case BFD_RELOC_16:                          r = R_PPC64_ADDR16;
2215       break;
2216     case BFD_RELOC_LO16:                        r = R_PPC64_ADDR16_LO;
2217       break;
2218     case BFD_RELOC_HI16:                        r = R_PPC64_ADDR16_HI;
2219       break;
2220     case BFD_RELOC_PPC64_ADDR16_HIGH:           r = R_PPC64_ADDR16_HIGH;
2221       break;
2222     case BFD_RELOC_HI16_S:                      r = R_PPC64_ADDR16_HA;
2223       break;
2224     case BFD_RELOC_PPC64_ADDR16_HIGHA:          r = R_PPC64_ADDR16_HIGHA;
2225       break;
2226     case BFD_RELOC_PPC_BA16:                    r = R_PPC64_ADDR14;
2227       break;
2228     case BFD_RELOC_PPC_BA16_BRTAKEN:            r = R_PPC64_ADDR14_BRTAKEN;
2229       break;
2230     case BFD_RELOC_PPC_BA16_BRNTAKEN:           r = R_PPC64_ADDR14_BRNTAKEN;
2231       break;
2232     case BFD_RELOC_PPC_B26:                     r = R_PPC64_REL24;
2233       break;
2234     case BFD_RELOC_PPC_B16:                     r = R_PPC64_REL14;
2235       break;
2236     case BFD_RELOC_PPC_B16_BRTAKEN:             r = R_PPC64_REL14_BRTAKEN;
2237       break;
2238     case BFD_RELOC_PPC_B16_BRNTAKEN:            r = R_PPC64_REL14_BRNTAKEN;
2239       break;
2240     case BFD_RELOC_16_GOTOFF:                   r = R_PPC64_GOT16;
2241       break;
2242     case BFD_RELOC_LO16_GOTOFF:                 r = R_PPC64_GOT16_LO;
2243       break;
2244     case BFD_RELOC_HI16_GOTOFF:                 r = R_PPC64_GOT16_HI;
2245       break;
2246     case BFD_RELOC_HI16_S_GOTOFF:               r = R_PPC64_GOT16_HA;
2247       break;
2248     case BFD_RELOC_PPC_COPY:                    r = R_PPC64_COPY;
2249       break;
2250     case BFD_RELOC_PPC_GLOB_DAT:                r = R_PPC64_GLOB_DAT;
2251       break;
2252     case BFD_RELOC_32_PCREL:                    r = R_PPC64_REL32;
2253       break;
2254     case BFD_RELOC_32_PLTOFF:                   r = R_PPC64_PLT32;
2255       break;
2256     case BFD_RELOC_32_PLT_PCREL:                r = R_PPC64_PLTREL32;
2257       break;
2258     case BFD_RELOC_LO16_PLTOFF:                 r = R_PPC64_PLT16_LO;
2259       break;
2260     case BFD_RELOC_HI16_PLTOFF:                 r = R_PPC64_PLT16_HI;
2261       break;
2262     case BFD_RELOC_HI16_S_PLTOFF:               r = R_PPC64_PLT16_HA;
2263       break;
2264     case BFD_RELOC_16_BASEREL:                  r = R_PPC64_SECTOFF;
2265       break;
2266     case BFD_RELOC_LO16_BASEREL:                r = R_PPC64_SECTOFF_LO;
2267       break;
2268     case BFD_RELOC_HI16_BASEREL:                r = R_PPC64_SECTOFF_HI;
2269       break;
2270     case BFD_RELOC_HI16_S_BASEREL:              r = R_PPC64_SECTOFF_HA;
2271       break;
2272     case BFD_RELOC_CTOR:                        r = R_PPC64_ADDR64;
2273       break;
2274     case BFD_RELOC_64:                          r = R_PPC64_ADDR64;
2275       break;
2276     case BFD_RELOC_PPC64_HIGHER:                r = R_PPC64_ADDR16_HIGHER;
2277       break;
2278     case BFD_RELOC_PPC64_HIGHER_S:              r = R_PPC64_ADDR16_HIGHERA;
2279       break;
2280     case BFD_RELOC_PPC64_HIGHEST:               r = R_PPC64_ADDR16_HIGHEST;
2281       break;
2282     case BFD_RELOC_PPC64_HIGHEST_S:             r = R_PPC64_ADDR16_HIGHESTA;
2283       break;
2284     case BFD_RELOC_64_PCREL:                    r = R_PPC64_REL64;
2285       break;
2286     case BFD_RELOC_64_PLTOFF:                   r = R_PPC64_PLT64;
2287       break;
2288     case BFD_RELOC_64_PLT_PCREL:                r = R_PPC64_PLTREL64;
2289       break;
2290     case BFD_RELOC_PPC_TOC16:                   r = R_PPC64_TOC16;
2291       break;
2292     case BFD_RELOC_PPC64_TOC16_LO:              r = R_PPC64_TOC16_LO;
2293       break;
2294     case BFD_RELOC_PPC64_TOC16_HI:              r = R_PPC64_TOC16_HI;
2295       break;
2296     case BFD_RELOC_PPC64_TOC16_HA:              r = R_PPC64_TOC16_HA;
2297       break;
2298     case BFD_RELOC_PPC64_TOC:                   r = R_PPC64_TOC;
2299       break;
2300     case BFD_RELOC_PPC64_PLTGOT16:              r = R_PPC64_PLTGOT16;
2301       break;
2302     case BFD_RELOC_PPC64_PLTGOT16_LO:           r = R_PPC64_PLTGOT16_LO;
2303       break;
2304     case BFD_RELOC_PPC64_PLTGOT16_HI:           r = R_PPC64_PLTGOT16_HI;
2305       break;
2306     case BFD_RELOC_PPC64_PLTGOT16_HA:           r = R_PPC64_PLTGOT16_HA;
2307       break;
2308     case BFD_RELOC_PPC64_ADDR16_DS:             r = R_PPC64_ADDR16_DS;
2309       break;
2310     case BFD_RELOC_PPC64_ADDR16_LO_DS:          r = R_PPC64_ADDR16_LO_DS;
2311       break;
2312     case BFD_RELOC_PPC64_GOT16_DS:              r = R_PPC64_GOT16_DS;
2313       break;
2314     case BFD_RELOC_PPC64_GOT16_LO_DS:           r = R_PPC64_GOT16_LO_DS;
2315       break;
2316     case BFD_RELOC_PPC64_PLT16_LO_DS:           r = R_PPC64_PLT16_LO_DS;
2317       break;
2318     case BFD_RELOC_PPC64_SECTOFF_DS:            r = R_PPC64_SECTOFF_DS;
2319       break;
2320     case BFD_RELOC_PPC64_SECTOFF_LO_DS:         r = R_PPC64_SECTOFF_LO_DS;
2321       break;
2322     case BFD_RELOC_PPC64_TOC16_DS:              r = R_PPC64_TOC16_DS;
2323       break;
2324     case BFD_RELOC_PPC64_TOC16_LO_DS:           r = R_PPC64_TOC16_LO_DS;
2325       break;
2326     case BFD_RELOC_PPC64_PLTGOT16_DS:           r = R_PPC64_PLTGOT16_DS;
2327       break;
2328     case BFD_RELOC_PPC64_PLTGOT16_LO_DS:        r = R_PPC64_PLTGOT16_LO_DS;
2329       break;
2330     case BFD_RELOC_PPC_TLS:                     r = R_PPC64_TLS;
2331       break;
2332     case BFD_RELOC_PPC_TLSGD:                   r = R_PPC64_TLSGD;
2333       break;
2334     case BFD_RELOC_PPC_TLSLD:                   r = R_PPC64_TLSLD;
2335       break;
2336     case BFD_RELOC_PPC_DTPMOD:                  r = R_PPC64_DTPMOD64;
2337       break;
2338     case BFD_RELOC_PPC_TPREL16:                 r = R_PPC64_TPREL16;
2339       break;
2340     case BFD_RELOC_PPC_TPREL16_LO:              r = R_PPC64_TPREL16_LO;
2341       break;
2342     case BFD_RELOC_PPC_TPREL16_HI:              r = R_PPC64_TPREL16_HI;
2343       break;
2344     case BFD_RELOC_PPC64_TPREL16_HIGH:          r = R_PPC64_TPREL16_HIGH;
2345       break;
2346     case BFD_RELOC_PPC_TPREL16_HA:              r = R_PPC64_TPREL16_HA;
2347       break;
2348     case BFD_RELOC_PPC64_TPREL16_HIGHA:         r = R_PPC64_TPREL16_HIGHA;
2349       break;
2350     case BFD_RELOC_PPC_TPREL:                   r = R_PPC64_TPREL64;
2351       break;
2352     case BFD_RELOC_PPC_DTPREL16:                r = R_PPC64_DTPREL16;
2353       break;
2354     case BFD_RELOC_PPC_DTPREL16_LO:             r = R_PPC64_DTPREL16_LO;
2355       break;
2356     case BFD_RELOC_PPC_DTPREL16_HI:             r = R_PPC64_DTPREL16_HI;
2357       break;
2358     case BFD_RELOC_PPC64_DTPREL16_HIGH:         r = R_PPC64_DTPREL16_HIGH;
2359       break;
2360     case BFD_RELOC_PPC_DTPREL16_HA:             r = R_PPC64_DTPREL16_HA;
2361       break;
2362     case BFD_RELOC_PPC64_DTPREL16_HIGHA:        r = R_PPC64_DTPREL16_HIGHA;
2363       break;
2364     case BFD_RELOC_PPC_DTPREL:                  r = R_PPC64_DTPREL64;
2365       break;
2366     case BFD_RELOC_PPC_GOT_TLSGD16:             r = R_PPC64_GOT_TLSGD16;
2367       break;
2368     case BFD_RELOC_PPC_GOT_TLSGD16_LO:          r = R_PPC64_GOT_TLSGD16_LO;
2369       break;
2370     case BFD_RELOC_PPC_GOT_TLSGD16_HI:          r = R_PPC64_GOT_TLSGD16_HI;
2371       break;
2372     case BFD_RELOC_PPC_GOT_TLSGD16_HA:          r = R_PPC64_GOT_TLSGD16_HA;
2373       break;
2374     case BFD_RELOC_PPC_GOT_TLSLD16:             r = R_PPC64_GOT_TLSLD16;
2375       break;
2376     case BFD_RELOC_PPC_GOT_TLSLD16_LO:          r = R_PPC64_GOT_TLSLD16_LO;
2377       break;
2378     case BFD_RELOC_PPC_GOT_TLSLD16_HI:          r = R_PPC64_GOT_TLSLD16_HI;
2379       break;
2380     case BFD_RELOC_PPC_GOT_TLSLD16_HA:          r = R_PPC64_GOT_TLSLD16_HA;
2381       break;
2382     case BFD_RELOC_PPC_GOT_TPREL16:             r = R_PPC64_GOT_TPREL16_DS;
2383       break;
2384     case BFD_RELOC_PPC_GOT_TPREL16_LO:          r = R_PPC64_GOT_TPREL16_LO_DS;
2385       break;
2386     case BFD_RELOC_PPC_GOT_TPREL16_HI:          r = R_PPC64_GOT_TPREL16_HI;
2387       break;
2388     case BFD_RELOC_PPC_GOT_TPREL16_HA:          r = R_PPC64_GOT_TPREL16_HA;
2389       break;
2390     case BFD_RELOC_PPC_GOT_DTPREL16:            r = R_PPC64_GOT_DTPREL16_DS;
2391       break;
2392     case BFD_RELOC_PPC_GOT_DTPREL16_LO:         r = R_PPC64_GOT_DTPREL16_LO_DS;
2393       break;
2394     case BFD_RELOC_PPC_GOT_DTPREL16_HI:         r = R_PPC64_GOT_DTPREL16_HI;
2395       break;
2396     case BFD_RELOC_PPC_GOT_DTPREL16_HA:         r = R_PPC64_GOT_DTPREL16_HA;
2397       break;
2398     case BFD_RELOC_PPC64_TPREL16_DS:            r = R_PPC64_TPREL16_DS;
2399       break;
2400     case BFD_RELOC_PPC64_TPREL16_LO_DS:         r = R_PPC64_TPREL16_LO_DS;
2401       break;
2402     case BFD_RELOC_PPC64_TPREL16_HIGHER:        r = R_PPC64_TPREL16_HIGHER;
2403       break;
2404     case BFD_RELOC_PPC64_TPREL16_HIGHERA:       r = R_PPC64_TPREL16_HIGHERA;
2405       break;
2406     case BFD_RELOC_PPC64_TPREL16_HIGHEST:       r = R_PPC64_TPREL16_HIGHEST;
2407       break;
2408     case BFD_RELOC_PPC64_TPREL16_HIGHESTA:      r = R_PPC64_TPREL16_HIGHESTA;
2409       break;
2410     case BFD_RELOC_PPC64_DTPREL16_DS:           r = R_PPC64_DTPREL16_DS;
2411       break;
2412     case BFD_RELOC_PPC64_DTPREL16_LO_DS:        r = R_PPC64_DTPREL16_LO_DS;
2413       break;
2414     case BFD_RELOC_PPC64_DTPREL16_HIGHER:       r = R_PPC64_DTPREL16_HIGHER;
2415       break;
2416     case BFD_RELOC_PPC64_DTPREL16_HIGHERA:      r = R_PPC64_DTPREL16_HIGHERA;
2417       break;
2418     case BFD_RELOC_PPC64_DTPREL16_HIGHEST:      r = R_PPC64_DTPREL16_HIGHEST;
2419       break;
2420     case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:     r = R_PPC64_DTPREL16_HIGHESTA;
2421       break;
2422     case BFD_RELOC_16_PCREL:                    r = R_PPC64_REL16;
2423       break;
2424     case BFD_RELOC_LO16_PCREL:                  r = R_PPC64_REL16_LO;
2425       break;
2426     case BFD_RELOC_HI16_PCREL:                  r = R_PPC64_REL16_HI;
2427       break;
2428     case BFD_RELOC_HI16_S_PCREL:                r = R_PPC64_REL16_HA;
2429       break;
2430     case BFD_RELOC_PPC_REL16DX_HA:              r = R_PPC64_REL16DX_HA;
2431       break;
2432     case BFD_RELOC_PPC64_ADDR64_LOCAL:          r = R_PPC64_ADDR64_LOCAL;
2433       break;
2434     case BFD_RELOC_VTABLE_INHERIT:              r = R_PPC64_GNU_VTINHERIT;
2435       break;
2436     case BFD_RELOC_VTABLE_ENTRY:                r = R_PPC64_GNU_VTENTRY;
2437       break;
2438     }
2439
2440   return ppc64_elf_howto_table[r];
2441 };
2442
2443 static reloc_howto_type *
2444 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2445                              const char *r_name)
2446 {
2447   unsigned int i;
2448
2449   for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2450     if (ppc64_elf_howto_raw[i].name != NULL
2451         && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2452       return &ppc64_elf_howto_raw[i];
2453
2454   return NULL;
2455 }
2456
2457 /* Set the howto pointer for a PowerPC ELF reloc.  */
2458
2459 static void
2460 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2461                          Elf_Internal_Rela *dst)
2462 {
2463   unsigned int type;
2464
2465   /* Initialize howto table if needed.  */
2466   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2467     ppc_howto_init ();
2468
2469   type = ELF64_R_TYPE (dst->r_info);
2470   if (type >= ARRAY_SIZE (ppc64_elf_howto_table))
2471     {
2472       (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
2473                              abfd, (int) type);
2474       type = R_PPC64_NONE;
2475     }
2476   cache_ptr->howto = ppc64_elf_howto_table[type];
2477 }
2478
2479 /* Handle the R_PPC64_ADDR16_HA and similar relocs.  */
2480
2481 static bfd_reloc_status_type
2482 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2483                     void *data, asection *input_section,
2484                     bfd *output_bfd, char **error_message)
2485 {
2486   enum elf_ppc64_reloc_type r_type;
2487   long insn;
2488   bfd_size_type octets;
2489   bfd_vma value;
2490
2491   /* If this is a relocatable link (output_bfd test tells us), just
2492      call the generic function.  Any adjustment will be done at final
2493      link time.  */
2494   if (output_bfd != NULL)
2495     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2496                                   input_section, output_bfd, error_message);
2497
2498   /* Adjust the addend for sign extension of the low 16 bits.
2499      We won't actually be using the low 16 bits, so trashing them
2500      doesn't matter.  */
2501   reloc_entry->addend += 0x8000;
2502   r_type = reloc_entry->howto->type;
2503   if (r_type != R_PPC64_REL16DX_HA)
2504     return bfd_reloc_continue;
2505
2506   value = 0;
2507   if (!bfd_is_com_section (symbol->section))
2508     value = symbol->value;
2509   value += (reloc_entry->addend
2510             + symbol->section->output_offset
2511             + symbol->section->output_section->vma);
2512   value -= (reloc_entry->address
2513             + input_section->output_offset
2514             + input_section->output_section->vma);
2515   value = (bfd_signed_vma) value >> 16;
2516
2517   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2518   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2519   insn &= ~0x1fffc1;
2520   insn |= (value & 0xffc1) | ((value & 0x3e) << 15);
2521   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2522   if (value + 0x8000 > 0xffff)
2523     return bfd_reloc_overflow;
2524   return bfd_reloc_ok;
2525 }
2526
2527 static bfd_reloc_status_type
2528 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2529                         void *data, asection *input_section,
2530                         bfd *output_bfd, char **error_message)
2531 {
2532   if (output_bfd != NULL)
2533     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2534                                   input_section, output_bfd, error_message);
2535
2536   if (strcmp (symbol->section->name, ".opd") == 0
2537       && (symbol->section->owner->flags & DYNAMIC) == 0)
2538     {
2539       bfd_vma dest = opd_entry_value (symbol->section,
2540                                       symbol->value + reloc_entry->addend,
2541                                       NULL, NULL, FALSE);
2542       if (dest != (bfd_vma) -1)
2543         reloc_entry->addend = dest - (symbol->value
2544                                       + symbol->section->output_section->vma
2545                                       + symbol->section->output_offset);
2546     }
2547   else
2548     {
2549       elf_symbol_type *elfsym = (elf_symbol_type *) symbol;
2550
2551       if (symbol->section->owner != abfd
2552           && abiversion (symbol->section->owner) >= 2)
2553         {
2554           unsigned int i;
2555
2556           for (i = 0; i < symbol->section->owner->symcount; ++i)
2557             {
2558               asymbol *symdef = symbol->section->owner->outsymbols[i];
2559
2560               if (strcmp (symdef->name, symbol->name) == 0)
2561                 {
2562                   elfsym = (elf_symbol_type *) symdef;
2563                   break;
2564                 }
2565             }
2566         }
2567       reloc_entry->addend
2568         += PPC64_LOCAL_ENTRY_OFFSET (elfsym->internal_elf_sym.st_other);
2569     }
2570   return bfd_reloc_continue;
2571 }
2572
2573 static bfd_reloc_status_type
2574 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2575                          void *data, asection *input_section,
2576                          bfd *output_bfd, char **error_message)
2577 {
2578   long insn;
2579   enum elf_ppc64_reloc_type r_type;
2580   bfd_size_type octets;
2581   /* Assume 'at' branch hints.  */
2582   bfd_boolean is_isa_v2 = TRUE;
2583
2584   /* If this is a relocatable link (output_bfd test tells us), just
2585      call the generic function.  Any adjustment will be done at final
2586      link time.  */
2587   if (output_bfd != NULL)
2588     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2589                                   input_section, output_bfd, error_message);
2590
2591   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2592   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2593   insn &= ~(0x01 << 21);
2594   r_type = reloc_entry->howto->type;
2595   if (r_type == R_PPC64_ADDR14_BRTAKEN
2596       || r_type == R_PPC64_REL14_BRTAKEN)
2597     insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
2598
2599   if (is_isa_v2)
2600     {
2601       /* Set 'a' bit.  This is 0b00010 in BO field for branch
2602          on CR(BI) insns (BO == 001at or 011at), and 0b01000
2603          for branch on CTR insns (BO == 1a00t or 1a01t).  */
2604       if ((insn & (0x14 << 21)) == (0x04 << 21))
2605         insn |= 0x02 << 21;
2606       else if ((insn & (0x14 << 21)) == (0x10 << 21))
2607         insn |= 0x08 << 21;
2608       else
2609         goto out;
2610     }
2611   else
2612     {
2613       bfd_vma target = 0;
2614       bfd_vma from;
2615
2616       if (!bfd_is_com_section (symbol->section))
2617         target = symbol->value;
2618       target += symbol->section->output_section->vma;
2619       target += symbol->section->output_offset;
2620       target += reloc_entry->addend;
2621
2622       from = (reloc_entry->address
2623               + input_section->output_offset
2624               + input_section->output_section->vma);
2625
2626       /* Invert 'y' bit if not the default.  */
2627       if ((bfd_signed_vma) (target - from) < 0)
2628         insn ^= 0x01 << 21;
2629     }
2630   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2631  out:
2632   return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2633                                  input_section, output_bfd, error_message);
2634 }
2635
2636 static bfd_reloc_status_type
2637 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2638                          void *data, asection *input_section,
2639                          bfd *output_bfd, char **error_message)
2640 {
2641   /* If this is a relocatable link (output_bfd test tells us), just
2642      call the generic function.  Any adjustment will be done at final
2643      link time.  */
2644   if (output_bfd != NULL)
2645     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2646                                   input_section, output_bfd, error_message);
2647
2648   /* Subtract the symbol section base address.  */
2649   reloc_entry->addend -= symbol->section->output_section->vma;
2650   return bfd_reloc_continue;
2651 }
2652
2653 static bfd_reloc_status_type
2654 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2655                             void *data, asection *input_section,
2656                             bfd *output_bfd, char **error_message)
2657 {
2658   /* If this is a relocatable link (output_bfd test tells us), just
2659      call the generic function.  Any adjustment will be done at final
2660      link time.  */
2661   if (output_bfd != NULL)
2662     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2663                                   input_section, output_bfd, error_message);
2664
2665   /* Subtract the symbol section base address.  */
2666   reloc_entry->addend -= symbol->section->output_section->vma;
2667
2668   /* Adjust the addend for sign extension of the low 16 bits.  */
2669   reloc_entry->addend += 0x8000;
2670   return bfd_reloc_continue;
2671 }
2672
2673 static bfd_reloc_status_type
2674 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2675                      void *data, asection *input_section,
2676                      bfd *output_bfd, char **error_message)
2677 {
2678   bfd_vma TOCstart;
2679
2680   /* If this is a relocatable link (output_bfd test tells us), just
2681      call the generic function.  Any adjustment will be done at final
2682      link time.  */
2683   if (output_bfd != NULL)
2684     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2685                                   input_section, output_bfd, error_message);
2686
2687   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2688   if (TOCstart == 0)
2689     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2690
2691   /* Subtract the TOC base address.  */
2692   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2693   return bfd_reloc_continue;
2694 }
2695
2696 static bfd_reloc_status_type
2697 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2698                         void *data, asection *input_section,
2699                         bfd *output_bfd, char **error_message)
2700 {
2701   bfd_vma TOCstart;
2702
2703   /* If this is a relocatable link (output_bfd test tells us), just
2704      call the generic function.  Any adjustment will be done at final
2705      link time.  */
2706   if (output_bfd != NULL)
2707     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2708                                   input_section, output_bfd, error_message);
2709
2710   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2711   if (TOCstart == 0)
2712     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2713
2714   /* Subtract the TOC base address.  */
2715   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2716
2717   /* Adjust the addend for sign extension of the low 16 bits.  */
2718   reloc_entry->addend += 0x8000;
2719   return bfd_reloc_continue;
2720 }
2721
2722 static bfd_reloc_status_type
2723 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2724                        void *data, asection *input_section,
2725                        bfd *output_bfd, char **error_message)
2726 {
2727   bfd_vma TOCstart;
2728   bfd_size_type octets;
2729
2730   /* If this is a relocatable link (output_bfd test tells us), just
2731      call the generic function.  Any adjustment will be done at final
2732      link time.  */
2733   if (output_bfd != NULL)
2734     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2735                                   input_section, output_bfd, error_message);
2736
2737   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2738   if (TOCstart == 0)
2739     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2740
2741   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2742   bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2743   return bfd_reloc_ok;
2744 }
2745
2746 static bfd_reloc_status_type
2747 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2748                            void *data, asection *input_section,
2749                            bfd *output_bfd, char **error_message)
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   if (error_message != NULL)
2759     {
2760       static char buf[60];
2761       sprintf (buf, "generic linker can't handle %s",
2762                reloc_entry->howto->name);
2763       *error_message = buf;
2764     }
2765   return bfd_reloc_dangerous;
2766 }
2767
2768 /* Track GOT entries needed for a given symbol.  We might need more
2769    than one got entry per symbol.  */
2770 struct got_entry
2771 {
2772   struct got_entry *next;
2773
2774   /* The symbol addend that we'll be placing in the GOT.  */
2775   bfd_vma addend;
2776
2777   /* Unlike other ELF targets, we use separate GOT entries for the same
2778      symbol referenced from different input files.  This is to support
2779      automatic multiple TOC/GOT sections, where the TOC base can vary
2780      from one input file to another.  After partitioning into TOC groups
2781      we merge entries within the group.
2782
2783      Point to the BFD owning this GOT entry.  */
2784   bfd *owner;
2785
2786   /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2787      TLS_TPREL or TLS_DTPREL for tls entries.  */
2788   unsigned char tls_type;
2789
2790   /* Non-zero if got.ent points to real entry.  */
2791   unsigned char is_indirect;
2792
2793   /* Reference count until size_dynamic_sections, GOT offset thereafter.  */
2794   union
2795     {
2796       bfd_signed_vma refcount;
2797       bfd_vma offset;
2798       struct got_entry *ent;
2799     } got;
2800 };
2801
2802 /* The same for PLT.  */
2803 struct plt_entry
2804 {
2805   struct plt_entry *next;
2806
2807   bfd_vma addend;
2808
2809   union
2810     {
2811       bfd_signed_vma refcount;
2812       bfd_vma offset;
2813     } plt;
2814 };
2815
2816 struct ppc64_elf_obj_tdata
2817 {
2818   struct elf_obj_tdata elf;
2819
2820   /* Shortcuts to dynamic linker sections.  */
2821   asection *got;
2822   asection *relgot;
2823
2824   /* Used during garbage collection.  We attach global symbols defined
2825      on removed .opd entries to this section so that the sym is removed.  */
2826   asection *deleted_section;
2827
2828   /* TLS local dynamic got entry handling.  Support for multiple GOT
2829      sections means we potentially need one of these for each input bfd.  */
2830   struct got_entry tlsld_got;
2831
2832   union {
2833     /* A copy of relocs before they are modified for --emit-relocs.  */
2834     Elf_Internal_Rela *relocs;
2835
2836     /* Section contents.  */
2837     bfd_byte *contents;
2838   } opd;
2839
2840   /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2841      the reloc to be in the range -32768 to 32767.  */
2842   unsigned int has_small_toc_reloc : 1;
2843
2844   /* Set if toc/got ha relocs detected not using r2, or lo reloc
2845      instruction not one we handle.  */
2846   unsigned int unexpected_toc_insn : 1;
2847 };
2848
2849 #define ppc64_elf_tdata(bfd) \
2850   ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2851
2852 #define ppc64_tlsld_got(bfd) \
2853   (&ppc64_elf_tdata (bfd)->tlsld_got)
2854
2855 #define is_ppc64_elf(bfd) \
2856   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2857    && elf_object_id (bfd) == PPC64_ELF_DATA)
2858
2859 /* Override the generic function because we store some extras.  */
2860
2861 static bfd_boolean
2862 ppc64_elf_mkobject (bfd *abfd)
2863 {
2864   return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2865                                   PPC64_ELF_DATA);
2866 }
2867
2868 /* Fix bad default arch selected for a 64 bit input bfd when the
2869    default is 32 bit.  */
2870
2871 static bfd_boolean
2872 ppc64_elf_object_p (bfd *abfd)
2873 {
2874   if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32)
2875     {
2876       Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2877
2878       if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2879         {
2880           /* Relies on arch after 32 bit default being 64 bit default.  */
2881           abfd->arch_info = abfd->arch_info->next;
2882           BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2883         }
2884     }
2885   return TRUE;
2886 }
2887
2888 /* Support for core dump NOTE sections.  */
2889
2890 static bfd_boolean
2891 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2892 {
2893   size_t offset, size;
2894
2895   if (note->descsz != 504)
2896     return FALSE;
2897
2898   /* pr_cursig */
2899   elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2900
2901   /* pr_pid */
2902   elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2903
2904   /* pr_reg */
2905   offset = 112;
2906   size = 384;
2907
2908   /* Make a ".reg/999" section.  */
2909   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2910                                           size, note->descpos + offset);
2911 }
2912
2913 static bfd_boolean
2914 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2915 {
2916   if (note->descsz != 136)
2917     return FALSE;
2918
2919   elf_tdata (abfd)->core->pid
2920     = bfd_get_32 (abfd, note->descdata + 24);
2921   elf_tdata (abfd)->core->program
2922     = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2923   elf_tdata (abfd)->core->command
2924     = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2925
2926   return TRUE;
2927 }
2928
2929 static char *
2930 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2931                            ...)
2932 {
2933   switch (note_type)
2934     {
2935     default:
2936       return NULL;
2937
2938     case NT_PRPSINFO:
2939       {
2940         char data[136];
2941         va_list ap;
2942
2943         va_start (ap, note_type);
2944         memset (data, 0, sizeof (data));
2945         strncpy (data + 40, va_arg (ap, const char *), 16);
2946         strncpy (data + 56, va_arg (ap, const char *), 80);
2947         va_end (ap);
2948         return elfcore_write_note (abfd, buf, bufsiz,
2949                                    "CORE", note_type, data, sizeof (data));
2950       }
2951
2952     case NT_PRSTATUS:
2953       {
2954         char data[504];
2955         va_list ap;
2956         long pid;
2957         int cursig;
2958         const void *greg;
2959
2960         va_start (ap, note_type);
2961         memset (data, 0, 112);
2962         pid = va_arg (ap, long);
2963         bfd_put_32 (abfd, pid, data + 32);
2964         cursig = va_arg (ap, int);
2965         bfd_put_16 (abfd, cursig, data + 12);
2966         greg = va_arg (ap, const void *);
2967         memcpy (data + 112, greg, 384);
2968         memset (data + 496, 0, 8);
2969         va_end (ap);
2970         return elfcore_write_note (abfd, buf, bufsiz,
2971                                    "CORE", note_type, data, sizeof (data));
2972       }
2973     }
2974 }
2975
2976 /* Add extra PPC sections.  */
2977
2978 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
2979 {
2980   { STRING_COMMA_LEN (".plt"),    0, SHT_NOBITS,   0 },
2981   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2982   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2983   { STRING_COMMA_LEN (".toc"),    0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2984   { STRING_COMMA_LEN (".toc1"),   0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2985   { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2986   { NULL,                     0,  0, 0,            0 }
2987 };
2988
2989 enum _ppc64_sec_type {
2990   sec_normal = 0,
2991   sec_opd = 1,
2992   sec_toc = 2
2993 };
2994
2995 struct _ppc64_elf_section_data
2996 {
2997   struct bfd_elf_section_data elf;
2998
2999   union
3000   {
3001     /* An array with one entry for each opd function descriptor,
3002        and some spares since opd entries may be either 16 or 24 bytes.  */
3003 #define OPD_NDX(OFF) ((OFF) >> 4)
3004     struct _opd_sec_data
3005     {
3006       /* Points to the function code section for local opd entries.  */
3007       asection **func_sec;
3008
3009       /* After editing .opd, adjust references to opd local syms.  */
3010       long *adjust;
3011     } opd;
3012
3013     /* An array for toc sections, indexed by offset/8.  */
3014     struct _toc_sec_data
3015     {
3016       /* Specifies the relocation symbol index used at a given toc offset.  */
3017       unsigned *symndx;
3018
3019       /* And the relocation addend.  */
3020       bfd_vma *add;
3021     } toc;
3022   } u;
3023
3024   enum _ppc64_sec_type sec_type:2;
3025
3026   /* Flag set when small branches are detected.  Used to
3027      select suitable defaults for the stub group size.  */
3028   unsigned int has_14bit_branch:1;
3029 };
3030
3031 #define ppc64_elf_section_data(sec) \
3032   ((struct _ppc64_elf_section_data *) elf_section_data (sec))
3033
3034 static bfd_boolean
3035 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
3036 {
3037   if (!sec->used_by_bfd)
3038     {
3039       struct _ppc64_elf_section_data *sdata;
3040       bfd_size_type amt = sizeof (*sdata);
3041
3042       sdata = bfd_zalloc (abfd, amt);
3043       if (sdata == NULL)
3044         return FALSE;
3045       sec->used_by_bfd = sdata;
3046     }
3047
3048   return _bfd_elf_new_section_hook (abfd, sec);
3049 }
3050
3051 static struct _opd_sec_data *
3052 get_opd_info (asection * sec)
3053 {
3054   if (sec != NULL
3055       && ppc64_elf_section_data (sec) != NULL
3056       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
3057     return &ppc64_elf_section_data (sec)->u.opd;
3058   return NULL;
3059 }
3060 \f
3061 /* Parameters for the qsort hook.  */
3062 static bfd_boolean synthetic_relocatable;
3063
3064 /* qsort comparison function for ppc64_elf_get_synthetic_symtab.  */
3065
3066 static int
3067 compare_symbols (const void *ap, const void *bp)
3068 {
3069   const asymbol *a = * (const asymbol **) ap;
3070   const asymbol *b = * (const asymbol **) bp;
3071
3072   /* Section symbols first.  */
3073   if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
3074     return -1;
3075   if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
3076     return 1;
3077
3078   /* then .opd symbols.  */
3079   if (strcmp (a->section->name, ".opd") == 0
3080       && strcmp (b->section->name, ".opd") != 0)
3081     return -1;
3082   if (strcmp (a->section->name, ".opd") != 0
3083       && strcmp (b->section->name, ".opd") == 0)
3084     return 1;
3085
3086   /* then other code symbols.  */
3087   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3088       == (SEC_CODE | SEC_ALLOC)
3089       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3090          != (SEC_CODE | SEC_ALLOC))
3091     return -1;
3092
3093   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3094       != (SEC_CODE | SEC_ALLOC)
3095       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3096          == (SEC_CODE | SEC_ALLOC))
3097     return 1;
3098
3099   if (synthetic_relocatable)
3100     {
3101       if (a->section->id < b->section->id)
3102         return -1;
3103
3104       if (a->section->id > b->section->id)
3105         return 1;
3106     }
3107
3108   if (a->value + a->section->vma < b->value + b->section->vma)
3109     return -1;
3110
3111   if (a->value + a->section->vma > b->value + b->section->vma)
3112     return 1;
3113
3114   /* For syms with the same value, prefer strong dynamic global function
3115      syms over other syms.  */
3116   if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3117     return -1;
3118
3119   if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3120     return 1;
3121
3122   if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3123     return -1;
3124
3125   if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3126     return 1;
3127
3128   if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3129     return -1;
3130
3131   if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3132     return 1;
3133
3134   if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3135     return -1;
3136
3137   if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3138     return 1;
3139
3140   return 0;
3141 }
3142
3143 /* Search SYMS for a symbol of the given VALUE.  */
3144
3145 static asymbol *
3146 sym_exists_at (asymbol **syms, long lo, long hi, unsigned int id, bfd_vma value)
3147 {
3148   long mid;
3149
3150   if (id == (unsigned) -1)
3151     {
3152       while (lo < hi)
3153         {
3154           mid = (lo + hi) >> 1;
3155           if (syms[mid]->value + syms[mid]->section->vma < value)
3156             lo = mid + 1;
3157           else if (syms[mid]->value + syms[mid]->section->vma > value)
3158             hi = mid;
3159           else
3160             return syms[mid];
3161         }
3162     }
3163   else
3164     {
3165       while (lo < hi)
3166         {
3167           mid = (lo + hi) >> 1;
3168           if (syms[mid]->section->id < id)
3169             lo = mid + 1;
3170           else if (syms[mid]->section->id > id)
3171             hi = mid;
3172           else if (syms[mid]->value < value)
3173             lo = mid + 1;
3174           else if (syms[mid]->value > value)
3175             hi = mid;
3176           else
3177             return syms[mid];
3178         }
3179     }
3180   return NULL;
3181 }
3182
3183 static bfd_boolean
3184 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3185 {
3186   bfd_vma vma = *(bfd_vma *) ptr;
3187   return ((section->flags & SEC_ALLOC) != 0
3188           && section->vma <= vma
3189           && vma < section->vma + section->size);
3190 }
3191
3192 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3193    entry syms.  Also generate @plt symbols for the glink branch table.
3194    Returns count of synthetic symbols in RET or -1 on error.  */
3195
3196 static long
3197 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3198                                 long static_count, asymbol **static_syms,
3199                                 long dyn_count, asymbol **dyn_syms,
3200                                 asymbol **ret)
3201 {
3202   asymbol *s;
3203   long i;
3204   long count;
3205   char *names;
3206   long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3207   asection *opd = NULL;
3208   bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3209   asymbol **syms;
3210   int abi = abiversion (abfd);
3211
3212   *ret = NULL;
3213
3214   if (abi < 2)
3215     {
3216       opd = bfd_get_section_by_name (abfd, ".opd");
3217       if (opd == NULL && abi == 1)
3218         return 0;
3219     }
3220
3221   symcount = static_count;
3222   if (!relocatable)
3223     symcount += dyn_count;
3224   if (symcount == 0)
3225     return 0;
3226
3227   syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3228   if (syms == NULL)
3229     return -1;
3230
3231   if (!relocatable && static_count != 0 && dyn_count != 0)
3232     {
3233       /* Use both symbol tables.  */
3234       memcpy (syms, static_syms, static_count * sizeof (*syms));
3235       memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3236     }
3237   else if (!relocatable && static_count == 0)
3238     memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3239   else
3240     memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3241
3242   synthetic_relocatable = relocatable;
3243   qsort (syms, symcount, sizeof (*syms), compare_symbols);
3244
3245   if (!relocatable && symcount > 1)
3246     {
3247       long j;
3248       /* Trim duplicate syms, since we may have merged the normal and
3249          dynamic symbols.  Actually, we only care about syms that have
3250          different values, so trim any with the same value.  */
3251       for (i = 1, j = 1; i < symcount; ++i)
3252         if (syms[i - 1]->value + syms[i - 1]->section->vma
3253             != syms[i]->value + syms[i]->section->vma)
3254           syms[j++] = syms[i];
3255       symcount = j;
3256     }
3257
3258   i = 0;
3259   if (strcmp (syms[i]->section->name, ".opd") == 0)
3260     ++i;
3261   codesecsym = i;
3262
3263   for (; i < symcount; ++i)
3264     if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3265          != (SEC_CODE | SEC_ALLOC))
3266         || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3267       break;
3268   codesecsymend = i;
3269
3270   for (; i < symcount; ++i)
3271     if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3272       break;
3273   secsymend = i;
3274
3275   for (; i < symcount; ++i)
3276     if (strcmp (syms[i]->section->name, ".opd") != 0)
3277       break;
3278   opdsymend = i;
3279
3280   for (; i < symcount; ++i)
3281     if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3282         != (SEC_CODE | SEC_ALLOC))
3283       break;
3284   symcount = i;
3285
3286   count = 0;
3287
3288   if (relocatable)
3289     {
3290       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3291       arelent *r;
3292       size_t size;
3293       long relcount;
3294
3295       if (opdsymend == secsymend)
3296         goto done;
3297
3298       slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3299       relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3300       if (relcount == 0)
3301         goto done;
3302
3303       if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3304         {
3305           count = -1;
3306           goto done;
3307         }
3308
3309       size = 0;
3310       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3311         {
3312           asymbol *sym;
3313
3314           while (r < opd->relocation + relcount
3315                  && r->address < syms[i]->value + opd->vma)
3316             ++r;
3317
3318           if (r == opd->relocation + relcount)
3319             break;
3320
3321           if (r->address != syms[i]->value + opd->vma)
3322             continue;
3323
3324           if (r->howto->type != R_PPC64_ADDR64)
3325             continue;
3326
3327           sym = *r->sym_ptr_ptr;
3328           if (!sym_exists_at (syms, opdsymend, symcount,
3329                               sym->section->id, sym->value + r->addend))
3330             {
3331               ++count;
3332               size += sizeof (asymbol);
3333               size += strlen (syms[i]->name) + 2;
3334             }
3335         }
3336
3337       if (size == 0)
3338         goto done;
3339       s = *ret = bfd_malloc (size);
3340       if (s == NULL)
3341         {
3342           count = -1;
3343           goto done;
3344         }
3345
3346       names = (char *) (s + count);
3347
3348       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3349         {
3350           asymbol *sym;
3351
3352           while (r < opd->relocation + relcount
3353                  && r->address < syms[i]->value + opd->vma)
3354             ++r;
3355
3356           if (r == opd->relocation + relcount)
3357             break;
3358
3359           if (r->address != syms[i]->value + opd->vma)
3360             continue;
3361
3362           if (r->howto->type != R_PPC64_ADDR64)
3363             continue;
3364
3365           sym = *r->sym_ptr_ptr;
3366           if (!sym_exists_at (syms, opdsymend, symcount,
3367                               sym->section->id, sym->value + r->addend))
3368             {
3369               size_t len;
3370
3371               *s = *syms[i];
3372               s->flags |= BSF_SYNTHETIC;
3373               s->section = sym->section;
3374               s->value = sym->value + r->addend;
3375               s->name = names;
3376               *names++ = '.';
3377               len = strlen (syms[i]->name);
3378               memcpy (names, syms[i]->name, len + 1);
3379               names += len + 1;
3380               /* Have udata.p point back to the original symbol this
3381                  synthetic symbol was derived from.  */
3382               s->udata.p = syms[i];
3383               s++;
3384             }
3385         }
3386     }
3387   else
3388     {
3389       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3390       bfd_byte *contents = NULL;
3391       size_t size;
3392       long plt_count = 0;
3393       bfd_vma glink_vma = 0, resolv_vma = 0;
3394       asection *dynamic, *glink = NULL, *relplt = NULL;
3395       arelent *p;
3396
3397       if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3398         {
3399         free_contents_and_exit_err:
3400           count = -1;
3401         free_contents_and_exit:
3402           if (contents)
3403             free (contents);
3404           goto done;
3405         }
3406
3407       size = 0;
3408       for (i = secsymend; i < opdsymend; ++i)
3409         {
3410           bfd_vma ent;
3411
3412           /* Ignore bogus symbols.  */
3413           if (syms[i]->value > opd->size - 8)
3414             continue;
3415
3416           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3417           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3418             {
3419               ++count;
3420               size += sizeof (asymbol);
3421               size += strlen (syms[i]->name) + 2;
3422             }
3423         }
3424
3425       /* Get start of .glink stubs from DT_PPC64_GLINK.  */
3426       if (dyn_count != 0
3427           && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3428         {
3429           bfd_byte *dynbuf, *extdyn, *extdynend;
3430           size_t extdynsize;
3431           void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3432
3433           if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3434             goto free_contents_and_exit_err;
3435
3436           extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3437           swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3438
3439           extdyn = dynbuf;
3440           extdynend = extdyn + dynamic->size;
3441           for (; extdyn < extdynend; extdyn += extdynsize)
3442             {
3443               Elf_Internal_Dyn dyn;
3444               (*swap_dyn_in) (abfd, extdyn, &dyn);
3445
3446               if (dyn.d_tag == DT_NULL)
3447                 break;
3448
3449               if (dyn.d_tag == DT_PPC64_GLINK)
3450                 {
3451                   /* The first glink stub starts at offset 32; see
3452                      comment in ppc64_elf_finish_dynamic_sections. */
3453                   glink_vma = dyn.d_un.d_val + GLINK_CALL_STUB_SIZE - 8 * 4;
3454                   /* The .glink section usually does not survive the final
3455                      link; search for the section (usually .text) where the
3456                      glink stubs now reside.  */
3457                   glink = bfd_sections_find_if (abfd, section_covers_vma,
3458                                                 &glink_vma);
3459                   break;
3460                 }
3461             }
3462
3463           free (dynbuf);
3464         }
3465
3466       if (glink != NULL)
3467         {
3468           /* Determine __glink trampoline by reading the relative branch
3469              from the first glink stub.  */
3470           bfd_byte buf[4];
3471           unsigned int off = 0;
3472
3473           while (bfd_get_section_contents (abfd, glink, buf,
3474                                            glink_vma + off - glink->vma, 4))
3475             {
3476               unsigned int insn = bfd_get_32 (abfd, buf);
3477               insn ^= B_DOT;
3478               if ((insn & ~0x3fffffc) == 0)
3479                 {
3480                   resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3481                   break;
3482                 }
3483               off += 4;
3484               if (off > 4)
3485                 break;
3486             }
3487
3488           if (resolv_vma)
3489             size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3490
3491           relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3492           if (relplt != NULL)
3493             {
3494               slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3495               if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3496                 goto free_contents_and_exit_err;
3497
3498               plt_count = relplt->size / sizeof (Elf64_External_Rela);
3499               size += plt_count * sizeof (asymbol);
3500
3501               p = relplt->relocation;
3502               for (i = 0; i < plt_count; i++, p++)
3503                 {
3504                   size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3505                   if (p->addend != 0)
3506                     size += sizeof ("+0x") - 1 + 16;
3507                 }
3508             }
3509         }
3510
3511       if (size == 0)
3512         goto free_contents_and_exit;
3513       s = *ret = bfd_malloc (size);
3514       if (s == NULL)
3515         goto free_contents_and_exit_err;
3516
3517       names = (char *) (s + count + plt_count + (resolv_vma != 0));
3518
3519       for (i = secsymend; i < opdsymend; ++i)
3520         {
3521           bfd_vma ent;
3522
3523           if (syms[i]->value > opd->size - 8)
3524             continue;
3525
3526           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3527           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3528             {
3529               long lo, hi;
3530               size_t len;
3531               asection *sec = abfd->sections;
3532
3533               *s = *syms[i];
3534               lo = codesecsym;
3535               hi = codesecsymend;
3536               while (lo < hi)
3537                 {
3538                   long mid = (lo + hi) >> 1;
3539                   if (syms[mid]->section->vma < ent)
3540                     lo = mid + 1;
3541                   else if (syms[mid]->section->vma > ent)
3542                     hi = mid;
3543                   else
3544                     {
3545                       sec = syms[mid]->section;
3546                       break;
3547                     }
3548                 }
3549
3550               if (lo >= hi && lo > codesecsym)
3551                 sec = syms[lo - 1]->section;
3552
3553               for (; sec != NULL; sec = sec->next)
3554                 {
3555                   if (sec->vma > ent)
3556                     break;
3557                   /* SEC_LOAD may not be set if SEC is from a separate debug
3558                      info file.  */
3559                   if ((sec->flags & SEC_ALLOC) == 0)
3560                     break;
3561                   if ((sec->flags & SEC_CODE) != 0)
3562                     s->section = sec;
3563                 }
3564               s->flags |= BSF_SYNTHETIC;
3565               s->value = ent - s->section->vma;
3566               s->name = names;
3567               *names++ = '.';
3568               len = strlen (syms[i]->name);
3569               memcpy (names, syms[i]->name, len + 1);
3570               names += len + 1;
3571               /* Have udata.p point back to the original symbol this
3572                  synthetic symbol was derived from.  */
3573               s->udata.p = syms[i];
3574               s++;
3575             }
3576         }
3577       free (contents);
3578
3579       if (glink != NULL && relplt != NULL)
3580         {
3581           if (resolv_vma)
3582             {
3583               /* Add a symbol for the main glink trampoline.  */
3584               memset (s, 0, sizeof *s);
3585               s->the_bfd = abfd;
3586               s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3587               s->section = glink;
3588               s->value = resolv_vma - glink->vma;
3589               s->name = names;
3590               memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3591               names += sizeof ("__glink_PLTresolve");
3592               s++;
3593               count++;
3594             }
3595
3596           /* FIXME: It would be very much nicer to put sym@plt on the
3597              stub rather than on the glink branch table entry.  The
3598              objdump disassembler would then use a sensible symbol
3599              name on plt calls.  The difficulty in doing so is
3600              a) finding the stubs, and,
3601              b) matching stubs against plt entries, and,
3602              c) there can be multiple stubs for a given plt entry.
3603
3604              Solving (a) could be done by code scanning, but older
3605              ppc64 binaries used different stubs to current code.
3606              (b) is the tricky one since you need to known the toc
3607              pointer for at least one function that uses a pic stub to
3608              be able to calculate the plt address referenced.
3609              (c) means gdb would need to set multiple breakpoints (or
3610              find the glink branch itself) when setting breakpoints
3611              for pending shared library loads.  */
3612           p = relplt->relocation;
3613           for (i = 0; i < plt_count; i++, p++)
3614             {
3615               size_t len;
3616
3617               *s = **p->sym_ptr_ptr;
3618               /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
3619                  we are defining a symbol, ensure one of them is set.  */
3620               if ((s->flags & BSF_LOCAL) == 0)
3621                 s->flags |= BSF_GLOBAL;
3622               s->flags |= BSF_SYNTHETIC;
3623               s->section = glink;
3624               s->value = glink_vma - glink->vma;
3625               s->name = names;
3626               s->udata.p = NULL;
3627               len = strlen ((*p->sym_ptr_ptr)->name);
3628               memcpy (names, (*p->sym_ptr_ptr)->name, len);
3629               names += len;
3630               if (p->addend != 0)
3631                 {
3632                   memcpy (names, "+0x", sizeof ("+0x") - 1);
3633                   names += sizeof ("+0x") - 1;
3634                   bfd_sprintf_vma (abfd, names, p->addend);
3635                   names += strlen (names);
3636                 }
3637               memcpy (names, "@plt", sizeof ("@plt"));
3638               names += sizeof ("@plt");
3639               s++;
3640               if (abi < 2)
3641                 {
3642                   glink_vma += 8;
3643                   if (i >= 0x8000)
3644                     glink_vma += 4;
3645                 }
3646               else
3647                 glink_vma += 4;
3648             }
3649           count += plt_count;
3650         }
3651     }
3652
3653  done:
3654   free (syms);
3655   return count;
3656 }
3657 \f
3658 /* The following functions are specific to the ELF linker, while
3659    functions above are used generally.  Those named ppc64_elf_* are
3660    called by the main ELF linker code.  They appear in this file more
3661    or less in the order in which they are called.  eg.
3662    ppc64_elf_check_relocs is called early in the link process,
3663    ppc64_elf_finish_dynamic_sections is one of the last functions
3664    called.
3665
3666    PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3667    functions have both a function code symbol and a function descriptor
3668    symbol.  A call to foo in a relocatable object file looks like:
3669
3670    .            .text
3671    .    x:
3672    .            bl      .foo
3673    .            nop
3674
3675    The function definition in another object file might be:
3676
3677    .            .section .opd
3678    .    foo:    .quad   .foo
3679    .            .quad   .TOC.@tocbase
3680    .            .quad   0
3681    .
3682    .            .text
3683    .    .foo:   blr
3684
3685    When the linker resolves the call during a static link, the branch
3686    unsurprisingly just goes to .foo and the .opd information is unused.
3687    If the function definition is in a shared library, things are a little
3688    different:  The call goes via a plt call stub, the opd information gets
3689    copied to the plt, and the linker patches the nop.
3690
3691    .    x:
3692    .            bl      .foo_stub
3693    .            ld      2,40(1)
3694    .
3695    .
3696    .    .foo_stub:
3697    .            std     2,40(1)                 # in practice, the call stub
3698    .            addis   11,2,Lfoo@toc@ha        # is slightly optimized, but
3699    .            addi    11,11,Lfoo@toc@l        # this is the general idea
3700    .            ld      12,0(11)
3701    .            ld      2,8(11)
3702    .            mtctr   12
3703    .            ld      11,16(11)
3704    .            bctr
3705    .
3706    .            .section .plt
3707    .    Lfoo:   reloc (R_PPC64_JMP_SLOT, foo)
3708
3709    The "reloc ()" notation is supposed to indicate that the linker emits
3710    an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
3711    copying.
3712
3713    What are the difficulties here?  Well, firstly, the relocations
3714    examined by the linker in check_relocs are against the function code
3715    sym .foo, while the dynamic relocation in the plt is emitted against
3716    the function descriptor symbol, foo.  Somewhere along the line, we need
3717    to carefully copy dynamic link information from one symbol to the other.
3718    Secondly, the generic part of the elf linker will make .foo a dynamic
3719    symbol as is normal for most other backends.  We need foo dynamic
3720    instead, at least for an application final link.  However, when
3721    creating a shared library containing foo, we need to have both symbols
3722    dynamic so that references to .foo are satisfied during the early
3723    stages of linking.  Otherwise the linker might decide to pull in a
3724    definition from some other object, eg. a static library.
3725
3726    Update: As of August 2004, we support a new convention.  Function
3727    calls may use the function descriptor symbol, ie. "bl foo".  This
3728    behaves exactly as "bl .foo".  */
3729
3730 /* Of those relocs that might be copied as dynamic relocs, this function
3731    selects those that must be copied when linking a shared library,
3732    even when the symbol is local.  */
3733
3734 static int
3735 must_be_dyn_reloc (struct bfd_link_info *info,
3736                    enum elf_ppc64_reloc_type r_type)
3737 {
3738   switch (r_type)
3739     {
3740     default:
3741       return 1;
3742
3743     case R_PPC64_REL32:
3744     case R_PPC64_REL64:
3745     case R_PPC64_REL30:
3746       return 0;
3747
3748     case R_PPC64_TPREL16:
3749     case R_PPC64_TPREL16_LO:
3750     case R_PPC64_TPREL16_HI:
3751     case R_PPC64_TPREL16_HA:
3752     case R_PPC64_TPREL16_DS:
3753     case R_PPC64_TPREL16_LO_DS:
3754     case R_PPC64_TPREL16_HIGH:
3755     case R_PPC64_TPREL16_HIGHA:
3756     case R_PPC64_TPREL16_HIGHER:
3757     case R_PPC64_TPREL16_HIGHERA:
3758     case R_PPC64_TPREL16_HIGHEST:
3759     case R_PPC64_TPREL16_HIGHESTA:
3760     case R_PPC64_TPREL64:
3761       return !bfd_link_executable (info);
3762     }
3763 }
3764
3765 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3766    copying dynamic variables from a shared lib into an app's dynbss
3767    section, and instead use a dynamic relocation to point into the
3768    shared lib.  With code that gcc generates, it's vital that this be
3769    enabled;  In the PowerPC64 ABI, the address of a function is actually
3770    the address of a function descriptor, which resides in the .opd
3771    section.  gcc uses the descriptor directly rather than going via the
3772    GOT as some other ABI's do, which means that initialized function
3773    pointers must reference the descriptor.  Thus, a function pointer
3774    initialized to the address of a function in a shared library will
3775    either require a copy reloc, or a dynamic reloc.  Using a copy reloc
3776    redefines the function descriptor symbol to point to the copy.  This
3777    presents a problem as a plt entry for that function is also
3778    initialized from the function descriptor symbol and the copy reloc
3779    may not be initialized first.  */
3780 #define ELIMINATE_COPY_RELOCS 1
3781
3782 /* Section name for stubs is the associated section name plus this
3783    string.  */
3784 #define STUB_SUFFIX ".stub"
3785
3786 /* Linker stubs.
3787    ppc_stub_long_branch:
3788    Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3789    destination, but a 24 bit branch in a stub section will reach.
3790    .    b       dest
3791
3792    ppc_stub_plt_branch:
3793    Similar to the above, but a 24 bit branch in the stub section won't
3794    reach its destination.
3795    .    addis   %r11,%r2,xxx@toc@ha
3796    .    ld      %r12,xxx@toc@l(%r11)
3797    .    mtctr   %r12
3798    .    bctr
3799
3800    ppc_stub_plt_call:
3801    Used to call a function in a shared library.  If it so happens that
3802    the plt entry referenced crosses a 64k boundary, then an extra
3803    "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3804    .    std     %r2,40(%r1)
3805    .    addis   %r11,%r2,xxx@toc@ha
3806    .    ld      %r12,xxx+0@toc@l(%r11)
3807    .    mtctr   %r12
3808    .    ld      %r2,xxx+8@toc@l(%r11)
3809    .    ld      %r11,xxx+16@toc@l(%r11)
3810    .    bctr
3811
3812    ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3813    code to adjust the value and save r2 to support multiple toc sections.
3814    A ppc_stub_long_branch with an r2 offset looks like:
3815    .    std     %r2,40(%r1)
3816    .    addis   %r2,%r2,off@ha
3817    .    addi    %r2,%r2,off@l
3818    .    b       dest
3819
3820    A ppc_stub_plt_branch with an r2 offset looks like:
3821    .    std     %r2,40(%r1)
3822    .    addis   %r11,%r2,xxx@toc@ha
3823    .    ld      %r12,xxx@toc@l(%r11)
3824    .    addis   %r2,%r2,off@ha
3825    .    addi    %r2,%r2,off@l
3826    .    mtctr   %r12
3827    .    bctr
3828
3829    In cases where the "addis" instruction would add zero, the "addis" is
3830    omitted and following instructions modified slightly in some cases.
3831 */
3832
3833 enum ppc_stub_type {
3834   ppc_stub_none,
3835   ppc_stub_long_branch,
3836   ppc_stub_long_branch_r2off,
3837   ppc_stub_plt_branch,
3838   ppc_stub_plt_branch_r2off,
3839   ppc_stub_plt_call,
3840   ppc_stub_plt_call_r2save,
3841   ppc_stub_global_entry,
3842   ppc_stub_save_res
3843 };
3844
3845 /* Information on stub grouping.  */
3846 struct map_stub
3847 {
3848   /* The stub section.  */
3849   asection *stub_sec;
3850   /* This is the section to which stubs in the group will be attached.  */
3851   asection *link_sec;
3852   /* Next group.  */
3853   struct map_stub *next;
3854   /* Whether to emit a copy of register save/restore functions in this
3855      group.  */
3856   int needs_save_res;
3857 };
3858
3859 struct ppc_stub_hash_entry {
3860
3861   /* Base hash table entry structure.  */
3862   struct bfd_hash_entry root;
3863
3864   enum ppc_stub_type stub_type;
3865
3866   /* Group information.  */
3867   struct map_stub *group;
3868
3869   /* Offset within stub_sec of the beginning of this stub.  */
3870   bfd_vma stub_offset;
3871
3872   /* Given the symbol's value and its section we can determine its final
3873      value when building the stubs (so the stub knows where to jump.  */
3874   bfd_vma target_value;
3875   asection *target_section;
3876
3877   /* The symbol table entry, if any, that this was derived from.  */
3878   struct ppc_link_hash_entry *h;
3879   struct plt_entry *plt_ent;
3880
3881   /* Symbol st_other.  */
3882   unsigned char other;
3883 };
3884
3885 struct ppc_branch_hash_entry {
3886
3887   /* Base hash table entry structure.  */
3888   struct bfd_hash_entry root;
3889
3890   /* Offset within branch lookup table.  */
3891   unsigned int offset;
3892
3893   /* Generation marker.  */
3894   unsigned int iter;
3895 };
3896
3897 /* Used to track dynamic relocations for local symbols.  */
3898 struct ppc_dyn_relocs
3899 {
3900   struct ppc_dyn_relocs *next;
3901
3902   /* The input section of the reloc.  */
3903   asection *sec;
3904
3905   /* Total number of relocs copied for the input section.  */
3906   unsigned int count : 31;
3907
3908   /* Whether this entry is for STT_GNU_IFUNC symbols.  */
3909   unsigned int ifunc : 1;
3910 };
3911
3912 struct ppc_link_hash_entry
3913 {
3914   struct elf_link_hash_entry elf;
3915
3916   union {
3917     /* A pointer to the most recently used stub hash entry against this
3918        symbol.  */
3919     struct ppc_stub_hash_entry *stub_cache;
3920
3921     /* A pointer to the next symbol starting with a '.'  */
3922     struct ppc_link_hash_entry *next_dot_sym;
3923   } u;
3924
3925   /* Track dynamic relocs copied for this symbol.  */
3926   struct elf_dyn_relocs *dyn_relocs;
3927
3928   /* Link between function code and descriptor symbols.  */
3929   struct ppc_link_hash_entry *oh;
3930
3931   /* Flag function code and descriptor symbols.  */
3932   unsigned int is_func:1;
3933   unsigned int is_func_descriptor:1;
3934   unsigned int fake:1;
3935
3936   /* Whether global opd/toc sym has been adjusted or not.
3937      After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3938      should be set for all globals defined in any opd/toc section.  */
3939   unsigned int adjust_done:1;
3940
3941   /* Set if we twiddled this symbol to weak at some stage.  */
3942   unsigned int was_undefined:1;
3943
3944   /* Set if this is an out-of-line register save/restore function,
3945      with non-standard calling convention.  */
3946   unsigned int save_res:1;
3947
3948   /* Contexts in which symbol is used in the GOT (or TOC).
3949      TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3950      corresponding relocs are encountered during check_relocs.
3951      tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3952      indicate the corresponding GOT entry type is not needed.
3953      tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3954      a TPREL one.  We use a separate flag rather than setting TPREL
3955      just for convenience in distinguishing the two cases.  */
3956 #define TLS_GD           1      /* GD reloc. */
3957 #define TLS_LD           2      /* LD reloc. */
3958 #define TLS_TPREL        4      /* TPREL reloc, => IE. */
3959 #define TLS_DTPREL       8      /* DTPREL reloc, => LD. */
3960 #define TLS_TLS         16      /* Any TLS reloc.  */
3961 #define TLS_EXPLICIT    32      /* Marks TOC section TLS relocs. */
3962 #define TLS_TPRELGD     64      /* TPREL reloc resulting from GD->IE. */
3963 #define PLT_IFUNC      128      /* STT_GNU_IFUNC.  */
3964   unsigned char tls_mask;
3965 };
3966
3967 /* ppc64 ELF linker hash table.  */
3968
3969 struct ppc_link_hash_table
3970 {
3971   struct elf_link_hash_table elf;
3972
3973   /* The stub hash table.  */
3974   struct bfd_hash_table stub_hash_table;
3975
3976   /* Another hash table for plt_branch stubs.  */
3977   struct bfd_hash_table branch_hash_table;
3978
3979   /* Hash table for function prologue tocsave.  */
3980   htab_t tocsave_htab;
3981
3982   /* Various options and other info passed from the linker.  */
3983   struct ppc64_elf_params *params;
3984
3985   /* The size of sec_info below.  */
3986   unsigned int sec_info_arr_size;
3987
3988   /* Per-section array of extra section info.  Done this way rather
3989      than as part of ppc64_elf_section_data so we have the info for
3990      non-ppc64 sections.  */
3991   struct
3992   {
3993     /* Along with elf_gp, specifies the TOC pointer used by this section.  */
3994     bfd_vma toc_off;
3995
3996     union
3997     {
3998       /* The section group that this section belongs to.  */
3999       struct map_stub *group;
4000       /* A temp section list pointer.  */
4001       asection *list;
4002     } u;
4003   } *sec_info;
4004
4005   /* Linked list of groups.  */
4006   struct map_stub *group;
4007
4008   /* Temp used when calculating TOC pointers.  */
4009   bfd_vma toc_curr;
4010   bfd *toc_bfd;
4011   asection *toc_first_sec;
4012
4013   /* Used when adding symbols.  */
4014   struct ppc_link_hash_entry *dot_syms;
4015
4016   /* Shortcuts to get to dynamic linker sections.  */
4017   asection *dynbss;
4018   asection *relbss;
4019   asection *glink;
4020   asection *sfpr;
4021   asection *brlt;
4022   asection *relbrlt;
4023   asection *glink_eh_frame;
4024
4025   /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
4026   struct ppc_link_hash_entry *tls_get_addr;
4027   struct ppc_link_hash_entry *tls_get_addr_fd;
4028
4029   /* The size of reliplt used by got entry relocs.  */
4030   bfd_size_type got_reli_size;
4031
4032   /* Statistics.  */
4033   unsigned long stub_count[ppc_stub_global_entry];
4034
4035   /* Number of stubs against global syms.  */
4036   unsigned long stub_globals;
4037
4038   /* Set if we're linking code with function descriptors.  */
4039   unsigned int opd_abi:1;
4040
4041   /* Support for multiple toc sections.  */
4042   unsigned int do_multi_toc:1;
4043   unsigned int multi_toc_needed:1;
4044   unsigned int second_toc_pass:1;
4045   unsigned int do_toc_opt:1;
4046
4047   /* Set on error.  */
4048   unsigned int stub_error:1;
4049
4050   /* Temp used by ppc64_elf_before_check_relocs.  */
4051   unsigned int twiddled_syms:1;
4052
4053   /* Incremented every time we size stubs.  */
4054   unsigned int stub_iteration;
4055
4056   /* Small local sym cache.  */
4057   struct sym_cache sym_cache;
4058 };
4059
4060 /* Rename some of the generic section flags to better document how they
4061    are used here.  */
4062
4063 /* Nonzero if this section has TLS related relocations.  */
4064 #define has_tls_reloc sec_flg0
4065
4066 /* Nonzero if this section has a call to __tls_get_addr.  */
4067 #define has_tls_get_addr_call sec_flg1
4068
4069 /* Nonzero if this section has any toc or got relocs.  */
4070 #define has_toc_reloc sec_flg2
4071
4072 /* Nonzero if this section has a call to another section that uses
4073    the toc or got.  */
4074 #define makes_toc_func_call sec_flg3
4075
4076 /* Recursion protection when determining above flag.  */
4077 #define call_check_in_progress sec_flg4
4078 #define call_check_done sec_flg5
4079
4080 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
4081
4082 #define ppc_hash_table(p) \
4083   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
4084   == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
4085
4086 #define ppc_stub_hash_lookup(table, string, create, copy) \
4087   ((struct ppc_stub_hash_entry *) \
4088    bfd_hash_lookup ((table), (string), (create), (copy)))
4089
4090 #define ppc_branch_hash_lookup(table, string, create, copy) \
4091   ((struct ppc_branch_hash_entry *) \
4092    bfd_hash_lookup ((table), (string), (create), (copy)))
4093
4094 /* Create an entry in the stub hash table.  */
4095
4096 static struct bfd_hash_entry *
4097 stub_hash_newfunc (struct bfd_hash_entry *entry,
4098                    struct bfd_hash_table *table,
4099                    const char *string)
4100 {
4101   /* Allocate the structure if it has not already been allocated by a
4102      subclass.  */
4103   if (entry == NULL)
4104     {
4105       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4106       if (entry == NULL)
4107         return entry;
4108     }
4109
4110   /* Call the allocation method of the superclass.  */
4111   entry = bfd_hash_newfunc (entry, table, string);
4112   if (entry != NULL)
4113     {
4114       struct ppc_stub_hash_entry *eh;
4115
4116       /* Initialize the local fields.  */
4117       eh = (struct ppc_stub_hash_entry *) entry;
4118       eh->stub_type = ppc_stub_none;
4119       eh->group = NULL;
4120       eh->stub_offset = 0;
4121       eh->target_value = 0;
4122       eh->target_section = NULL;
4123       eh->h = NULL;
4124       eh->plt_ent = NULL;
4125       eh->other = 0;
4126     }
4127
4128   return entry;
4129 }
4130
4131 /* Create an entry in the branch hash table.  */
4132
4133 static struct bfd_hash_entry *
4134 branch_hash_newfunc (struct bfd_hash_entry *entry,
4135                      struct bfd_hash_table *table,
4136                      const char *string)
4137 {
4138   /* Allocate the structure if it has not already been allocated by a
4139      subclass.  */
4140   if (entry == NULL)
4141     {
4142       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4143       if (entry == NULL)
4144         return entry;
4145     }
4146
4147   /* Call the allocation method of the superclass.  */
4148   entry = bfd_hash_newfunc (entry, table, string);
4149   if (entry != NULL)
4150     {
4151       struct ppc_branch_hash_entry *eh;
4152
4153       /* Initialize the local fields.  */
4154       eh = (struct ppc_branch_hash_entry *) entry;
4155       eh->offset = 0;
4156       eh->iter = 0;
4157     }
4158
4159   return entry;
4160 }
4161
4162 /* Create an entry in a ppc64 ELF linker hash table.  */
4163
4164 static struct bfd_hash_entry *
4165 link_hash_newfunc (struct bfd_hash_entry *entry,
4166                    struct bfd_hash_table *table,
4167                    const char *string)
4168 {
4169   /* Allocate the structure if it has not already been allocated by a
4170      subclass.  */
4171   if (entry == NULL)
4172     {
4173       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4174       if (entry == NULL)
4175         return entry;
4176     }
4177
4178   /* Call the allocation method of the superclass.  */
4179   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4180   if (entry != NULL)
4181     {
4182       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4183
4184       memset (&eh->u.stub_cache, 0,
4185               (sizeof (struct ppc_link_hash_entry)
4186                - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4187
4188       /* When making function calls, old ABI code references function entry
4189          points (dot symbols), while new ABI code references the function
4190          descriptor symbol.  We need to make any combination of reference and
4191          definition work together, without breaking archive linking.
4192
4193          For a defined function "foo" and an undefined call to "bar":
4194          An old object defines "foo" and ".foo", references ".bar" (possibly
4195          "bar" too).
4196          A new object defines "foo" and references "bar".
4197
4198          A new object thus has no problem with its undefined symbols being
4199          satisfied by definitions in an old object.  On the other hand, the
4200          old object won't have ".bar" satisfied by a new object.
4201
4202          Keep a list of newly added dot-symbols.  */
4203
4204       if (string[0] == '.')
4205         {
4206           struct ppc_link_hash_table *htab;
4207
4208           htab = (struct ppc_link_hash_table *) table;
4209           eh->u.next_dot_sym = htab->dot_syms;
4210           htab->dot_syms = eh;
4211         }
4212     }
4213
4214   return entry;
4215 }
4216
4217 struct tocsave_entry {
4218   asection *sec;
4219   bfd_vma offset;
4220 };
4221
4222 static hashval_t
4223 tocsave_htab_hash (const void *p)
4224 {
4225   const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4226   return ((bfd_vma)(intptr_t) e->sec ^ e->offset) >> 3;
4227 }
4228
4229 static int
4230 tocsave_htab_eq (const void *p1, const void *p2)
4231 {
4232   const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4233   const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4234   return e1->sec == e2->sec && e1->offset == e2->offset;
4235 }
4236
4237 /* Destroy a ppc64 ELF linker hash table.  */
4238
4239 static void
4240 ppc64_elf_link_hash_table_free (bfd *obfd)
4241 {
4242   struct ppc_link_hash_table *htab;
4243
4244   htab = (struct ppc_link_hash_table *) obfd->link.hash;
4245   if (htab->tocsave_htab)
4246     htab_delete (htab->tocsave_htab);
4247   bfd_hash_table_free (&htab->branch_hash_table);
4248   bfd_hash_table_free (&htab->stub_hash_table);
4249   _bfd_elf_link_hash_table_free (obfd);
4250 }
4251
4252 /* Create a ppc64 ELF linker hash table.  */
4253
4254 static struct bfd_link_hash_table *
4255 ppc64_elf_link_hash_table_create (bfd *abfd)
4256 {
4257   struct ppc_link_hash_table *htab;
4258   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4259
4260   htab = bfd_zmalloc (amt);
4261   if (htab == NULL)
4262     return NULL;
4263
4264   if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4265                                       sizeof (struct ppc_link_hash_entry),
4266                                       PPC64_ELF_DATA))
4267     {
4268       free (htab);
4269       return NULL;
4270     }
4271
4272   /* Init the stub hash table too.  */
4273   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4274                             sizeof (struct ppc_stub_hash_entry)))
4275     {
4276       _bfd_elf_link_hash_table_free (abfd);
4277       return NULL;
4278     }
4279
4280   /* And the branch hash table.  */
4281   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4282                             sizeof (struct ppc_branch_hash_entry)))
4283     {
4284       bfd_hash_table_free (&htab->stub_hash_table);
4285       _bfd_elf_link_hash_table_free (abfd);
4286       return NULL;
4287     }
4288
4289   htab->tocsave_htab = htab_try_create (1024,
4290                                         tocsave_htab_hash,
4291                                         tocsave_htab_eq,
4292                                         NULL);
4293   if (htab->tocsave_htab == NULL)
4294     {
4295       ppc64_elf_link_hash_table_free (abfd);
4296       return NULL;
4297     }
4298   htab->elf.root.hash_table_free = ppc64_elf_link_hash_table_free;
4299
4300   /* Initializing two fields of the union is just cosmetic.  We really
4301      only care about glist, but when compiled on a 32-bit host the
4302      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
4303      debugger inspection of these fields look nicer.  */
4304   htab->elf.init_got_refcount.refcount = 0;
4305   htab->elf.init_got_refcount.glist = NULL;
4306   htab->elf.init_plt_refcount.refcount = 0;
4307   htab->elf.init_plt_refcount.glist = NULL;
4308   htab->elf.init_got_offset.offset = 0;
4309   htab->elf.init_got_offset.glist = NULL;
4310   htab->elf.init_plt_offset.offset = 0;
4311   htab->elf.init_plt_offset.glist = NULL;
4312
4313   return &htab->elf.root;
4314 }
4315
4316 /* Create sections for linker generated code.  */
4317
4318 static bfd_boolean
4319 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4320 {
4321   struct ppc_link_hash_table *htab;
4322   flagword flags;
4323
4324   htab = ppc_hash_table (info);
4325
4326   /* Create .sfpr for code to save and restore fp regs.  */
4327   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4328            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4329   htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4330                                                    flags);
4331   if (htab->sfpr == NULL
4332       || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4333     return FALSE;
4334
4335   /* Create .glink for lazy dynamic linking support.  */
4336   htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4337                                                     flags);
4338   if (htab->glink == NULL
4339       || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4340     return FALSE;
4341
4342   if (!info->no_ld_generated_unwind_info)
4343     {
4344       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4345                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4346       htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4347                                                                  ".eh_frame",
4348                                                                  flags);
4349       if (htab->glink_eh_frame == NULL
4350           || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4351         return FALSE;
4352     }
4353
4354   flags = SEC_ALLOC | SEC_LINKER_CREATED;
4355   htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4356   if (htab->elf.iplt == NULL
4357       || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4358     return FALSE;
4359
4360   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4361            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4362   htab->elf.irelplt
4363     = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4364   if (htab->elf.irelplt == NULL
4365       || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4366     return FALSE;
4367
4368   /* Create branch lookup table for plt_branch stubs.  */
4369   flags = (SEC_ALLOC | SEC_LOAD
4370            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4371   htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4372                                                    flags);
4373   if (htab->brlt == NULL
4374       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4375     return FALSE;
4376
4377   if (!bfd_link_pic (info))
4378     return TRUE;
4379
4380   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4381            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4382   htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4383                                                       ".rela.branch_lt",
4384                                                       flags);
4385   if (htab->relbrlt == NULL
4386       || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4387     return FALSE;
4388
4389   return TRUE;
4390 }
4391
4392 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
4393
4394 bfd_boolean
4395 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4396                          struct ppc64_elf_params *params)
4397 {
4398   struct ppc_link_hash_table *htab;
4399
4400   elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4401
4402 /* Always hook our dynamic sections into the first bfd, which is the
4403    linker created stub bfd.  This ensures that the GOT header is at
4404    the start of the output TOC section.  */
4405   htab = ppc_hash_table (info);
4406   if (htab == NULL)
4407     return FALSE;
4408   htab->elf.dynobj = params->stub_bfd;
4409   htab->params = params;
4410
4411   if (bfd_link_relocatable (info))
4412     return TRUE;
4413
4414   return create_linkage_sections (htab->elf.dynobj, info);
4415 }
4416
4417 /* Build a name for an entry in the stub hash table.  */
4418
4419 static char *
4420 ppc_stub_name (const asection *input_section,
4421                const asection *sym_sec,
4422                const struct ppc_link_hash_entry *h,
4423                const Elf_Internal_Rela *rel)
4424 {
4425   char *stub_name;
4426   ssize_t len;
4427
4428   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4429      offsets from a sym as a branch target?  In fact, we could
4430      probably assume the addend is always zero.  */
4431   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4432
4433   if (h)
4434     {
4435       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4436       stub_name = bfd_malloc (len);
4437       if (stub_name == NULL)
4438         return stub_name;
4439
4440       len = sprintf (stub_name, "%08x.%s+%x",
4441                      input_section->id & 0xffffffff,
4442                      h->elf.root.root.string,
4443                      (int) rel->r_addend & 0xffffffff);
4444     }
4445   else
4446     {
4447       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4448       stub_name = bfd_malloc (len);
4449       if (stub_name == NULL)
4450         return stub_name;
4451
4452       len = sprintf (stub_name, "%08x.%x:%x+%x",
4453                      input_section->id & 0xffffffff,
4454                      sym_sec->id & 0xffffffff,
4455                      (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4456                      (int) rel->r_addend & 0xffffffff);
4457     }
4458   if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4459     stub_name[len - 2] = 0;
4460   return stub_name;
4461 }
4462
4463 /* Look up an entry in the stub hash.  Stub entries are cached because
4464    creating the stub name takes a bit of time.  */
4465
4466 static struct ppc_stub_hash_entry *
4467 ppc_get_stub_entry (const asection *input_section,
4468                     const asection *sym_sec,
4469                     struct ppc_link_hash_entry *h,
4470                     const Elf_Internal_Rela *rel,
4471                     struct ppc_link_hash_table *htab)
4472 {
4473   struct ppc_stub_hash_entry *stub_entry;
4474   struct map_stub *group;
4475
4476   /* If this input section is part of a group of sections sharing one
4477      stub section, then use the id of the first section in the group.
4478      Stub names need to include a section id, as there may well be
4479      more than one stub used to reach say, printf, and we need to
4480      distinguish between them.  */
4481   group = htab->sec_info[input_section->id].u.group;
4482
4483   if (h != NULL && h->u.stub_cache != NULL
4484       && h->u.stub_cache->h == h
4485       && h->u.stub_cache->group == group)
4486     {
4487       stub_entry = h->u.stub_cache;
4488     }
4489   else
4490     {
4491       char *stub_name;
4492
4493       stub_name = ppc_stub_name (group->link_sec, sym_sec, h, rel);
4494       if (stub_name == NULL)
4495         return NULL;
4496
4497       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4498                                          stub_name, FALSE, FALSE);
4499       if (h != NULL)
4500         h->u.stub_cache = stub_entry;
4501
4502       free (stub_name);
4503     }
4504
4505   return stub_entry;
4506 }
4507
4508 /* Add a new stub entry to the stub hash.  Not all fields of the new
4509    stub entry are initialised.  */
4510
4511 static struct ppc_stub_hash_entry *
4512 ppc_add_stub (const char *stub_name,
4513               asection *section,
4514               struct bfd_link_info *info)
4515 {
4516   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4517   struct map_stub *group;
4518   asection *link_sec;
4519   asection *stub_sec;
4520   struct ppc_stub_hash_entry *stub_entry;
4521
4522   group = htab->sec_info[section->id].u.group;
4523   link_sec = group->link_sec;
4524   stub_sec = group->stub_sec;
4525   if (stub_sec == NULL)
4526     {
4527       size_t namelen;
4528       bfd_size_type len;
4529       char *s_name;
4530
4531       namelen = strlen (link_sec->name);
4532       len = namelen + sizeof (STUB_SUFFIX);
4533       s_name = bfd_alloc (htab->params->stub_bfd, len);
4534       if (s_name == NULL)
4535         return NULL;
4536
4537       memcpy (s_name, link_sec->name, namelen);
4538       memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4539       stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4540       if (stub_sec == NULL)
4541         return NULL;
4542       group->stub_sec = stub_sec;
4543     }
4544
4545   /* Enter this entry into the linker stub hash table.  */
4546   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4547                                      TRUE, FALSE);
4548   if (stub_entry == NULL)
4549     {
4550       info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4551                               section->owner, stub_name);
4552       return NULL;
4553     }
4554
4555   stub_entry->group = group;
4556   stub_entry->stub_offset = 0;
4557   return stub_entry;
4558 }
4559
4560 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4561    not already done.  */
4562
4563 static bfd_boolean
4564 create_got_section (bfd *abfd, struct bfd_link_info *info)
4565 {
4566   asection *got, *relgot;
4567   flagword flags;
4568   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4569
4570   if (!is_ppc64_elf (abfd))
4571     return FALSE;
4572   if (htab == NULL)
4573     return FALSE;
4574
4575   if (!htab->elf.sgot
4576       && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4577     return FALSE;
4578
4579   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4580            | SEC_LINKER_CREATED);
4581
4582   got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4583   if (!got
4584       || !bfd_set_section_alignment (abfd, got, 3))
4585     return FALSE;
4586
4587   relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4588                                                flags | SEC_READONLY);
4589   if (!relgot
4590       || ! bfd_set_section_alignment (abfd, relgot, 3))
4591     return FALSE;
4592
4593   ppc64_elf_tdata (abfd)->got = got;
4594   ppc64_elf_tdata (abfd)->relgot = relgot;
4595   return TRUE;
4596 }
4597
4598 /* Create the dynamic sections, and set up shortcuts.  */
4599
4600 static bfd_boolean
4601 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4602 {
4603   struct ppc_link_hash_table *htab;
4604
4605   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4606     return FALSE;
4607
4608   htab = ppc_hash_table (info);
4609   if (htab == NULL)
4610     return FALSE;
4611
4612   htab->dynbss = bfd_get_linker_section (dynobj, ".dynbss");
4613   if (!bfd_link_pic (info))
4614     htab->relbss = bfd_get_linker_section (dynobj, ".rela.bss");
4615
4616   if (!htab->elf.sgot || !htab->elf.splt || !htab->elf.srelplt || !htab->dynbss
4617       || (!bfd_link_pic (info) && !htab->relbss))
4618     abort ();
4619
4620   return TRUE;
4621 }
4622
4623 /* Follow indirect and warning symbol links.  */
4624
4625 static inline struct bfd_link_hash_entry *
4626 follow_link (struct bfd_link_hash_entry *h)
4627 {
4628   while (h->type == bfd_link_hash_indirect
4629          || h->type == bfd_link_hash_warning)
4630     h = h->u.i.link;
4631   return h;
4632 }
4633
4634 static inline struct elf_link_hash_entry *
4635 elf_follow_link (struct elf_link_hash_entry *h)
4636 {
4637   return (struct elf_link_hash_entry *) follow_link (&h->root);
4638 }
4639
4640 static inline struct ppc_link_hash_entry *
4641 ppc_follow_link (struct ppc_link_hash_entry *h)
4642 {
4643   return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4644 }
4645
4646 /* Merge PLT info on FROM with that on TO.  */
4647
4648 static void
4649 move_plt_plist (struct ppc_link_hash_entry *from,
4650                 struct ppc_link_hash_entry *to)
4651 {
4652   if (from->elf.plt.plist != NULL)
4653     {
4654       if (to->elf.plt.plist != NULL)
4655         {
4656           struct plt_entry **entp;
4657           struct plt_entry *ent;
4658
4659           for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4660             {
4661               struct plt_entry *dent;
4662
4663               for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4664                 if (dent->addend == ent->addend)
4665                   {
4666                     dent->plt.refcount += ent->plt.refcount;
4667                     *entp = ent->next;
4668                     break;
4669                   }
4670               if (dent == NULL)
4671                 entp = &ent->next;
4672             }
4673           *entp = to->elf.plt.plist;
4674         }
4675
4676       to->elf.plt.plist = from->elf.plt.plist;
4677       from->elf.plt.plist = NULL;
4678     }
4679 }
4680
4681 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
4682
4683 static void
4684 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4685                                 struct elf_link_hash_entry *dir,
4686                                 struct elf_link_hash_entry *ind)
4687 {
4688   struct ppc_link_hash_entry *edir, *eind;
4689
4690   edir = (struct ppc_link_hash_entry *) dir;
4691   eind = (struct ppc_link_hash_entry *) ind;
4692
4693   edir->is_func |= eind->is_func;
4694   edir->is_func_descriptor |= eind->is_func_descriptor;
4695   edir->tls_mask |= eind->tls_mask;
4696   if (eind->oh != NULL)
4697     edir->oh = ppc_follow_link (eind->oh);
4698
4699   /* If called to transfer flags for a weakdef during processing
4700      of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4701      We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
4702   if (!(ELIMINATE_COPY_RELOCS
4703         && eind->elf.root.type != bfd_link_hash_indirect
4704         && edir->elf.dynamic_adjusted))
4705     edir->elf.non_got_ref |= eind->elf.non_got_ref;
4706
4707   edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4708   edir->elf.ref_regular |= eind->elf.ref_regular;
4709   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4710   edir->elf.needs_plt |= eind->elf.needs_plt;
4711   edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4712
4713   /* Copy over any dynamic relocs we may have on the indirect sym.  */
4714   if (eind->dyn_relocs != NULL)
4715     {
4716       if (edir->dyn_relocs != NULL)
4717         {
4718           struct elf_dyn_relocs **pp;
4719           struct elf_dyn_relocs *p;
4720
4721           /* Add reloc counts against the indirect sym to the direct sym
4722              list.  Merge any entries against the same section.  */
4723           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4724             {
4725               struct elf_dyn_relocs *q;
4726
4727               for (q = edir->dyn_relocs; q != NULL; q = q->next)
4728                 if (q->sec == p->sec)
4729                   {
4730                     q->pc_count += p->pc_count;
4731                     q->count += p->count;
4732                     *pp = p->next;
4733                     break;
4734                   }
4735               if (q == NULL)
4736                 pp = &p->next;
4737             }
4738           *pp = edir->dyn_relocs;
4739         }
4740
4741       edir->dyn_relocs = eind->dyn_relocs;
4742       eind->dyn_relocs = NULL;
4743     }
4744
4745   /* If we were called to copy over info for a weak sym, that's all.
4746      You might think dyn_relocs need not be copied over;  After all,
4747      both syms will be dynamic or both non-dynamic so we're just
4748      moving reloc accounting around.  However, ELIMINATE_COPY_RELOCS
4749      code in ppc64_elf_adjust_dynamic_symbol needs to check for
4750      dyn_relocs in read-only sections, and it does so on what is the
4751      DIR sym here.  */
4752   if (eind->elf.root.type != bfd_link_hash_indirect)
4753     return;
4754
4755   /* Copy over got entries that we may have already seen to the
4756      symbol which just became indirect.  */
4757   if (eind->elf.got.glist != NULL)
4758     {
4759       if (edir->elf.got.glist != NULL)
4760         {
4761           struct got_entry **entp;
4762           struct got_entry *ent;
4763
4764           for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4765             {
4766               struct got_entry *dent;
4767
4768               for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4769                 if (dent->addend == ent->addend
4770                     && dent->owner == ent->owner
4771                     && dent->tls_type == ent->tls_type)
4772                   {
4773                     dent->got.refcount += ent->got.refcount;
4774                     *entp = ent->next;
4775                     break;
4776                   }
4777               if (dent == NULL)
4778                 entp = &ent->next;
4779             }
4780           *entp = edir->elf.got.glist;
4781         }
4782
4783       edir->elf.got.glist = eind->elf.got.glist;
4784       eind->elf.got.glist = NULL;
4785     }
4786
4787   /* And plt entries.  */
4788   move_plt_plist (eind, edir);
4789
4790   if (eind->elf.dynindx != -1)
4791     {
4792       if (edir->elf.dynindx != -1)
4793         _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4794                                 edir->elf.dynstr_index);
4795       edir->elf.dynindx = eind->elf.dynindx;
4796       edir->elf.dynstr_index = eind->elf.dynstr_index;
4797       eind->elf.dynindx = -1;
4798       eind->elf.dynstr_index = 0;
4799     }
4800 }
4801
4802 /* Find the function descriptor hash entry from the given function code
4803    hash entry FH.  Link the entries via their OH fields.  */
4804
4805 static struct ppc_link_hash_entry *
4806 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4807 {
4808   struct ppc_link_hash_entry *fdh = fh->oh;
4809
4810   if (fdh == NULL)
4811     {
4812       const char *fd_name = fh->elf.root.root.string + 1;
4813
4814       fdh = (struct ppc_link_hash_entry *)
4815         elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4816       if (fdh == NULL)
4817         return fdh;
4818
4819       fdh->is_func_descriptor = 1;
4820       fdh->oh = fh;
4821       fh->is_func = 1;
4822       fh->oh = fdh;
4823     }
4824
4825   return ppc_follow_link (fdh);
4826 }
4827
4828 /* Make a fake function descriptor sym for the code sym FH.  */
4829
4830 static struct ppc_link_hash_entry *
4831 make_fdh (struct bfd_link_info *info,
4832           struct ppc_link_hash_entry *fh)
4833 {
4834   bfd *abfd;
4835   asymbol *newsym;
4836   struct bfd_link_hash_entry *bh;
4837   struct ppc_link_hash_entry *fdh;
4838
4839   abfd = fh->elf.root.u.undef.abfd;
4840   newsym = bfd_make_empty_symbol (abfd);
4841   newsym->name = fh->elf.root.root.string + 1;
4842   newsym->section = bfd_und_section_ptr;
4843   newsym->value = 0;
4844   newsym->flags = BSF_WEAK;
4845
4846   bh = NULL;
4847   if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4848                                          newsym->flags, newsym->section,
4849                                          newsym->value, NULL, FALSE, FALSE,
4850                                          &bh))
4851     return NULL;
4852
4853   fdh = (struct ppc_link_hash_entry *) bh;
4854   fdh->elf.non_elf = 0;
4855   fdh->fake = 1;
4856   fdh->is_func_descriptor = 1;
4857   fdh->oh = fh;
4858   fh->is_func = 1;
4859   fh->oh = fdh;
4860   return fdh;
4861 }
4862
4863 /* Fix function descriptor symbols defined in .opd sections to be
4864    function type.  */
4865
4866 static bfd_boolean
4867 ppc64_elf_add_symbol_hook (bfd *ibfd,
4868                            struct bfd_link_info *info,
4869                            Elf_Internal_Sym *isym,
4870                            const char **name,
4871                            flagword *flags ATTRIBUTE_UNUSED,
4872                            asection **sec,
4873                            bfd_vma *value)
4874 {
4875   if ((ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4876        || ELF_ST_BIND (isym->st_info) == STB_GNU_UNIQUE)
4877       && (ibfd->flags & DYNAMIC) == 0
4878       && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
4879     elf_tdata (info->output_bfd)->has_gnu_symbols = elf_gnu_symbol_any;
4880
4881   if (*sec != NULL
4882       && strcmp ((*sec)->name, ".opd") == 0)
4883     {
4884       asection *code_sec;
4885
4886       if (!(ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4887             || ELF_ST_TYPE (isym->st_info) == STT_FUNC))
4888         isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4889
4890       /* If the symbol is a function defined in .opd, and the function
4891          code is in a discarded group, let it appear to be undefined.  */
4892       if (!bfd_link_relocatable (info)
4893           && (*sec)->reloc_count != 0
4894           && opd_entry_value (*sec, *value, &code_sec, NULL,
4895                               FALSE) != (bfd_vma) -1
4896           && discarded_section (code_sec))
4897         {
4898           *sec = bfd_und_section_ptr;
4899           isym->st_shndx = SHN_UNDEF;
4900         }
4901     }
4902   else if (*sec != NULL
4903            && strcmp ((*sec)->name, ".toc") == 0
4904            && ELF_ST_TYPE (isym->st_info) == STT_OBJECT)
4905     {
4906       struct ppc_link_hash_table *htab = ppc_hash_table (info);
4907       if (htab != NULL)
4908         htab->params->object_in_toc = 1;
4909     }
4910
4911   if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4912     {
4913       if (abiversion (ibfd) == 0)
4914         set_abiversion (ibfd, 2);
4915       else if (abiversion (ibfd) == 1)
4916         {
4917           info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other"
4918                                     " for ABI version 1\n"), name);
4919           bfd_set_error (bfd_error_bad_value);
4920           return FALSE;
4921         }
4922     }
4923
4924   return TRUE;
4925 }
4926
4927 /* Merge non-visibility st_other attributes: local entry point.  */
4928
4929 static void
4930 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
4931                                   const Elf_Internal_Sym *isym,
4932                                   bfd_boolean definition,
4933                                   bfd_boolean dynamic)
4934 {
4935   if (definition && !dynamic)
4936     h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
4937                 | ELF_ST_VISIBILITY (h->other));
4938 }
4939
4940 /* This function makes an old ABI object reference to ".bar" cause the
4941    inclusion of a new ABI object archive that defines "bar".
4942    NAME is a symbol defined in an archive.  Return a symbol in the hash
4943    table that might be satisfied by the archive symbols.  */
4944
4945 static struct elf_link_hash_entry *
4946 ppc64_elf_archive_symbol_lookup (bfd *abfd,
4947                                  struct bfd_link_info *info,
4948                                  const char *name)
4949 {
4950   struct elf_link_hash_entry *h;
4951   char *dot_name;
4952   size_t len;
4953
4954   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4955   if (h != NULL
4956       /* Don't return this sym if it is a fake function descriptor
4957          created by add_symbol_adjust.  */
4958       && !(h->root.type == bfd_link_hash_undefweak
4959            && ((struct ppc_link_hash_entry *) h)->fake))
4960     return h;
4961
4962   if (name[0] == '.')
4963     return h;
4964
4965   len = strlen (name);
4966   dot_name = bfd_alloc (abfd, len + 2);
4967   if (dot_name == NULL)
4968     return (struct elf_link_hash_entry *) 0 - 1;
4969   dot_name[0] = '.';
4970   memcpy (dot_name + 1, name, len + 1);
4971   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4972   bfd_release (abfd, dot_name);
4973   return h;
4974 }
4975
4976 /* This function satisfies all old ABI object references to ".bar" if a
4977    new ABI object defines "bar".  Well, at least, undefined dot symbols
4978    are made weak.  This stops later archive searches from including an
4979    object if we already have a function descriptor definition.  It also
4980    prevents the linker complaining about undefined symbols.
4981    We also check and correct mismatched symbol visibility here.  The
4982    most restrictive visibility of the function descriptor and the
4983    function entry symbol is used.  */
4984
4985 static bfd_boolean
4986 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
4987 {
4988   struct ppc_link_hash_table *htab;
4989   struct ppc_link_hash_entry *fdh;
4990
4991   if (eh->elf.root.type == bfd_link_hash_indirect)
4992     return TRUE;
4993
4994   if (eh->elf.root.type == bfd_link_hash_warning)
4995     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
4996
4997   if (eh->elf.root.root.string[0] != '.')
4998     abort ();
4999
5000   htab = ppc_hash_table (info);
5001   if (htab == NULL)
5002     return FALSE;
5003
5004   fdh = lookup_fdh (eh, htab);
5005   if (fdh == NULL)
5006     {
5007       if (!bfd_link_relocatable (info)
5008           && (eh->elf.root.type == bfd_link_hash_undefined
5009               || eh->elf.root.type == bfd_link_hash_undefweak)
5010           && eh->elf.ref_regular)
5011         {
5012           /* Make an undefweak function descriptor sym, which is enough to
5013              pull in an --as-needed shared lib, but won't cause link
5014              errors.  Archives are handled elsewhere.  */
5015           fdh = make_fdh (info, eh);
5016           if (fdh == NULL)
5017             return FALSE;
5018           fdh->elf.ref_regular = 1;
5019         }
5020     }
5021   else
5022     {
5023       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
5024       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
5025       if (entry_vis < descr_vis)
5026         fdh->elf.other += entry_vis - descr_vis;
5027       else if (entry_vis > descr_vis)
5028         eh->elf.other += descr_vis - entry_vis;
5029
5030       if ((fdh->elf.root.type == bfd_link_hash_defined
5031            || fdh->elf.root.type == bfd_link_hash_defweak)
5032           && eh->elf.root.type == bfd_link_hash_undefined)
5033         {
5034           eh->elf.root.type = bfd_link_hash_undefweak;
5035           eh->was_undefined = 1;
5036           htab->twiddled_syms = 1;
5037         }
5038     }
5039
5040   return TRUE;
5041 }
5042
5043 /* Set up opd section info and abiversion for IBFD, and process list
5044    of dot-symbols we made in link_hash_newfunc.  */
5045
5046 static bfd_boolean
5047 ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
5048 {
5049   struct ppc_link_hash_table *htab;
5050   struct ppc_link_hash_entry **p, *eh;
5051   asection *opd = bfd_get_section_by_name (ibfd, ".opd");
5052
5053   if (opd != NULL && opd->size != 0)
5054     {
5055       if (abiversion (ibfd) == 0)
5056         set_abiversion (ibfd, 1);
5057       else if (abiversion (ibfd) == 2)
5058         {
5059           info->callbacks->einfo (_("%P: %B .opd not allowed in ABI"
5060                                     " version %d\n"),
5061                                   ibfd, abiversion (ibfd));
5062           bfd_set_error (bfd_error_bad_value);
5063           return FALSE;
5064         }
5065
5066       if ((ibfd->flags & DYNAMIC) == 0
5067           && (opd->flags & SEC_RELOC) != 0
5068           && opd->reloc_count != 0
5069           && !bfd_is_abs_section (opd->output_section))
5070         {
5071           /* Garbage collection needs some extra help with .opd sections.
5072              We don't want to necessarily keep everything referenced by
5073              relocs in .opd, as that would keep all functions.  Instead,
5074              if we reference an .opd symbol (a function descriptor), we
5075              want to keep the function code symbol's section.  This is
5076              easy for global symbols, but for local syms we need to keep
5077              information about the associated function section.  */
5078           bfd_size_type amt;
5079           asection **opd_sym_map;
5080
5081           amt = OPD_NDX (opd->size) * sizeof (*opd_sym_map);
5082           opd_sym_map = bfd_zalloc (ibfd, amt);
5083           if (opd_sym_map == NULL)
5084             return FALSE;
5085           ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
5086           BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
5087           ppc64_elf_section_data (opd)->sec_type = sec_opd;
5088         }
5089     }
5090
5091   if (!is_ppc64_elf (info->output_bfd))
5092     return TRUE;
5093   htab = ppc_hash_table (info);
5094   if (htab == NULL)
5095     return FALSE;
5096
5097   /* For input files without an explicit abiversion in e_flags
5098      we should have flagged any with symbol st_other bits set
5099      as ELFv1 and above flagged those with .opd as ELFv2.
5100      Set the output abiversion if not yet set, and for any input
5101      still ambiguous, take its abiversion from the output.
5102      Differences in ABI are reported later.  */
5103   if (abiversion (info->output_bfd) == 0)
5104     set_abiversion (info->output_bfd, abiversion (ibfd));
5105   else if (abiversion (ibfd) == 0)
5106     set_abiversion (ibfd, abiversion (info->output_bfd));
5107
5108   p = &htab->dot_syms;
5109   while ((eh = *p) != NULL)
5110     {
5111       *p = NULL;
5112       if (&eh->elf == htab->elf.hgot)
5113         ;
5114       else if (htab->elf.hgot == NULL
5115                && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
5116         htab->elf.hgot = &eh->elf;
5117       else if (!add_symbol_adjust (eh, info))
5118         return FALSE;
5119       p = &eh->u.next_dot_sym;
5120     }
5121
5122   /* Clear the list for non-ppc64 input files.  */
5123   p = &htab->dot_syms;
5124   while ((eh = *p) != NULL)
5125     {
5126       *p = NULL;
5127       p = &eh->u.next_dot_sym;
5128     }
5129
5130   /* We need to fix the undefs list for any syms we have twiddled to
5131      undef_weak.  */
5132   if (htab->twiddled_syms)
5133     {
5134       bfd_link_repair_undef_list (&htab->elf.root);
5135       htab->twiddled_syms = 0;
5136     }
5137   return TRUE;
5138 }
5139
5140 /* Undo hash table changes when an --as-needed input file is determined
5141    not to be needed.  */
5142
5143 static bfd_boolean
5144 ppc64_elf_notice_as_needed (bfd *ibfd,
5145                             struct bfd_link_info *info,
5146                             enum notice_asneeded_action act)
5147 {
5148   if (act == notice_not_needed)
5149     {
5150       struct ppc_link_hash_table *htab = ppc_hash_table (info);
5151
5152       if (htab == NULL)
5153         return FALSE;
5154
5155       htab->dot_syms = NULL;
5156     }
5157   return _bfd_elf_notice_as_needed (ibfd, info, act);
5158 }
5159
5160 /* If --just-symbols against a final linked binary, then assume we need
5161    toc adjusting stubs when calling functions defined there.  */
5162
5163 static void
5164 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5165 {
5166   if ((sec->flags & SEC_CODE) != 0
5167       && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5168       && is_ppc64_elf (sec->owner))
5169     {
5170       if (abiversion (sec->owner) >= 2
5171           || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5172         sec->has_toc_reloc = 1;
5173     }
5174   _bfd_elf_link_just_syms (sec, info);
5175 }
5176
5177 static struct plt_entry **
5178 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5179                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5180 {
5181   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5182   struct plt_entry **local_plt;
5183   unsigned char *local_got_tls_masks;
5184
5185   if (local_got_ents == NULL)
5186     {
5187       bfd_size_type size = symtab_hdr->sh_info;
5188
5189       size *= (sizeof (*local_got_ents)
5190                + sizeof (*local_plt)
5191                + sizeof (*local_got_tls_masks));
5192       local_got_ents = bfd_zalloc (abfd, size);
5193       if (local_got_ents == NULL)
5194         return NULL;
5195       elf_local_got_ents (abfd) = local_got_ents;
5196     }
5197
5198   if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
5199     {
5200       struct got_entry *ent;
5201
5202       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5203         if (ent->addend == r_addend
5204             && ent->owner == abfd
5205             && ent->tls_type == tls_type)
5206           break;
5207       if (ent == NULL)
5208         {
5209           bfd_size_type amt = sizeof (*ent);
5210           ent = bfd_alloc (abfd, amt);
5211           if (ent == NULL)
5212             return FALSE;
5213           ent->next = local_got_ents[r_symndx];
5214           ent->addend = r_addend;
5215           ent->owner = abfd;
5216           ent->tls_type = tls_type;
5217           ent->is_indirect = FALSE;
5218           ent->got.refcount = 0;
5219           local_got_ents[r_symndx] = ent;
5220         }
5221       ent->got.refcount += 1;
5222     }
5223
5224   local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5225   local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5226   local_got_tls_masks[r_symndx] |= tls_type;
5227
5228   return local_plt + r_symndx;
5229 }
5230
5231 static bfd_boolean
5232 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5233 {
5234   struct plt_entry *ent;
5235
5236   for (ent = *plist; ent != NULL; ent = ent->next)
5237     if (ent->addend == addend)
5238       break;
5239   if (ent == NULL)
5240     {
5241       bfd_size_type amt = sizeof (*ent);
5242       ent = bfd_alloc (abfd, amt);
5243       if (ent == NULL)
5244         return FALSE;
5245       ent->next = *plist;
5246       ent->addend = addend;
5247       ent->plt.refcount = 0;
5248       *plist = ent;
5249     }
5250   ent->plt.refcount += 1;
5251   return TRUE;
5252 }
5253
5254 static bfd_boolean
5255 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5256 {
5257   return (r_type == R_PPC64_REL24
5258           || r_type == R_PPC64_REL14
5259           || r_type == R_PPC64_REL14_BRTAKEN
5260           || r_type == R_PPC64_REL14_BRNTAKEN
5261           || r_type == R_PPC64_ADDR24
5262           || r_type == R_PPC64_ADDR14
5263           || r_type == R_PPC64_ADDR14_BRTAKEN
5264           || r_type == R_PPC64_ADDR14_BRNTAKEN);
5265 }
5266
5267 /* Look through the relocs for a section during the first phase, and
5268    calculate needed space in the global offset table, procedure
5269    linkage table, and dynamic reloc sections.  */
5270
5271 static bfd_boolean
5272 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5273                         asection *sec, const Elf_Internal_Rela *relocs)
5274 {
5275   struct ppc_link_hash_table *htab;
5276   Elf_Internal_Shdr *symtab_hdr;
5277   struct elf_link_hash_entry **sym_hashes;
5278   const Elf_Internal_Rela *rel;
5279   const Elf_Internal_Rela *rel_end;
5280   asection *sreloc;
5281   asection **opd_sym_map;
5282   struct elf_link_hash_entry *tga, *dottga;
5283
5284   if (bfd_link_relocatable (info))
5285     return TRUE;
5286
5287   /* Don't do anything special with non-loaded, non-alloced sections.
5288      In particular, any relocs in such sections should not affect GOT
5289      and PLT reference counting (ie. we don't allow them to create GOT
5290      or PLT entries), there's no possibility or desire to optimize TLS
5291      relocs, and there's not much point in propagating relocs to shared
5292      libs that the dynamic linker won't relocate.  */
5293   if ((sec->flags & SEC_ALLOC) == 0)
5294     return TRUE;
5295
5296   BFD_ASSERT (is_ppc64_elf (abfd));
5297
5298   htab = ppc_hash_table (info);
5299   if (htab == NULL)
5300     return FALSE;
5301
5302   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5303                               FALSE, FALSE, TRUE);
5304   dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5305                                  FALSE, FALSE, TRUE);
5306   symtab_hdr = &elf_symtab_hdr (abfd);
5307   sym_hashes = elf_sym_hashes (abfd);
5308   sreloc = NULL;
5309   opd_sym_map = NULL;
5310   if (ppc64_elf_section_data (sec) != NULL
5311       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
5312     opd_sym_map = ppc64_elf_section_data (sec)->u.opd.func_sec;
5313
5314   rel_end = relocs + sec->reloc_count;
5315   for (rel = relocs; rel < rel_end; rel++)
5316     {
5317       unsigned long r_symndx;
5318       struct elf_link_hash_entry *h;
5319       enum elf_ppc64_reloc_type r_type;
5320       int tls_type;
5321       struct _ppc64_elf_section_data *ppc64_sec;
5322       struct plt_entry **ifunc;
5323
5324       r_symndx = ELF64_R_SYM (rel->r_info);
5325       if (r_symndx < symtab_hdr->sh_info)
5326         h = NULL;
5327       else
5328         {
5329           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5330           h = elf_follow_link (h);
5331
5332           /* PR15323, ref flags aren't set for references in the same
5333              object.  */
5334           h->root.non_ir_ref = 1;
5335
5336           if (h == htab->elf.hgot)
5337             sec->has_toc_reloc = 1;
5338         }
5339
5340       tls_type = 0;
5341       ifunc = NULL;
5342       if (h != NULL)
5343         {
5344           if (h->type == STT_GNU_IFUNC)
5345             {
5346               h->needs_plt = 1;
5347               ifunc = &h->plt.plist;
5348             }
5349         }
5350       else
5351         {
5352           Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5353                                                           abfd, r_symndx);
5354           if (isym == NULL)
5355             return FALSE;
5356
5357           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5358             {
5359               ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5360                                              rel->r_addend, PLT_IFUNC);
5361               if (ifunc == NULL)
5362                 return FALSE;
5363             }
5364         }
5365       r_type = ELF64_R_TYPE (rel->r_info);
5366       if (is_branch_reloc (r_type))
5367         {
5368           if (h != NULL && (h == tga || h == dottga))
5369             {
5370               if (rel != relocs
5371                   && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5372                       || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5373                 /* We have a new-style __tls_get_addr call with a marker
5374                    reloc.  */
5375                 ;
5376               else
5377                 /* Mark this section as having an old-style call.  */
5378                 sec->has_tls_get_addr_call = 1;
5379             }
5380
5381           /* STT_GNU_IFUNC symbols must have a PLT entry.  */
5382           if (ifunc != NULL
5383               && !update_plt_info (abfd, ifunc, rel->r_addend))
5384             return FALSE;
5385         }
5386
5387       switch (r_type)
5388         {
5389         case R_PPC64_TLSGD:
5390         case R_PPC64_TLSLD:
5391           /* These special tls relocs tie a call to __tls_get_addr with
5392              its parameter symbol.  */
5393           break;
5394
5395         case R_PPC64_GOT_TLSLD16:
5396         case R_PPC64_GOT_TLSLD16_LO:
5397         case R_PPC64_GOT_TLSLD16_HI:
5398         case R_PPC64_GOT_TLSLD16_HA:
5399           tls_type = TLS_TLS | TLS_LD;
5400           goto dogottls;
5401
5402         case R_PPC64_GOT_TLSGD16:
5403         case R_PPC64_GOT_TLSGD16_LO:
5404         case R_PPC64_GOT_TLSGD16_HI:
5405         case R_PPC64_GOT_TLSGD16_HA:
5406           tls_type = TLS_TLS | TLS_GD;
5407           goto dogottls;
5408
5409         case R_PPC64_GOT_TPREL16_DS:
5410         case R_PPC64_GOT_TPREL16_LO_DS:
5411         case R_PPC64_GOT_TPREL16_HI:
5412         case R_PPC64_GOT_TPREL16_HA:
5413           if (bfd_link_pic (info))
5414             info->flags |= DF_STATIC_TLS;
5415           tls_type = TLS_TLS | TLS_TPREL;
5416           goto dogottls;
5417
5418         case R_PPC64_GOT_DTPREL16_DS:
5419         case R_PPC64_GOT_DTPREL16_LO_DS:
5420         case R_PPC64_GOT_DTPREL16_HI:
5421         case R_PPC64_GOT_DTPREL16_HA:
5422           tls_type = TLS_TLS | TLS_DTPREL;
5423         dogottls:
5424           sec->has_tls_reloc = 1;
5425           /* Fall thru */
5426
5427         case R_PPC64_GOT16:
5428         case R_PPC64_GOT16_DS:
5429         case R_PPC64_GOT16_HA:
5430         case R_PPC64_GOT16_HI:
5431         case R_PPC64_GOT16_LO:
5432         case R_PPC64_GOT16_LO_DS:
5433           /* This symbol requires a global offset table entry.  */
5434           sec->has_toc_reloc = 1;
5435           if (r_type == R_PPC64_GOT_TLSLD16
5436               || r_type == R_PPC64_GOT_TLSGD16
5437               || r_type == R_PPC64_GOT_TPREL16_DS
5438               || r_type == R_PPC64_GOT_DTPREL16_DS
5439               || r_type == R_PPC64_GOT16
5440               || r_type == R_PPC64_GOT16_DS)
5441             {
5442               htab->do_multi_toc = 1;
5443               ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5444             }
5445
5446           if (ppc64_elf_tdata (abfd)->got == NULL
5447               && !create_got_section (abfd, info))
5448             return FALSE;
5449
5450           if (h != NULL)
5451             {
5452               struct ppc_link_hash_entry *eh;
5453               struct got_entry *ent;
5454
5455               eh = (struct ppc_link_hash_entry *) h;
5456               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5457                 if (ent->addend == rel->r_addend
5458                     && ent->owner == abfd
5459                     && ent->tls_type == tls_type)
5460                   break;
5461               if (ent == NULL)
5462                 {
5463                   bfd_size_type amt = sizeof (*ent);
5464                   ent = bfd_alloc (abfd, amt);
5465                   if (ent == NULL)
5466                     return FALSE;
5467                   ent->next = eh->elf.got.glist;
5468                   ent->addend = rel->r_addend;
5469                   ent->owner = abfd;
5470                   ent->tls_type = tls_type;
5471                   ent->is_indirect = FALSE;
5472                   ent->got.refcount = 0;
5473                   eh->elf.got.glist = ent;
5474                 }
5475               ent->got.refcount += 1;
5476               eh->tls_mask |= tls_type;
5477             }
5478           else
5479             /* This is a global offset table entry for a local symbol.  */
5480             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5481                                         rel->r_addend, tls_type))
5482               return FALSE;
5483
5484           /* We may also need a plt entry if the symbol turns out to be
5485              an ifunc.  */
5486           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1)
5487             {
5488               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5489                 return FALSE;
5490             }
5491           break;
5492
5493         case R_PPC64_PLT16_HA:
5494         case R_PPC64_PLT16_HI:
5495         case R_PPC64_PLT16_LO:
5496         case R_PPC64_PLT32:
5497         case R_PPC64_PLT64:
5498           /* This symbol requires a procedure linkage table entry.  We
5499              actually build the entry in adjust_dynamic_symbol,
5500              because this might be a case of linking PIC code without
5501              linking in any dynamic objects, in which case we don't
5502              need to generate a procedure linkage table after all.  */
5503           if (h == NULL)
5504             {
5505               /* It does not make sense to have a procedure linkage
5506                  table entry for a local symbol.  */
5507               bfd_set_error (bfd_error_bad_value);
5508               return FALSE;
5509             }
5510           else
5511             {
5512               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5513                 return FALSE;
5514               h->needs_plt = 1;
5515               if (h->root.root.string[0] == '.'
5516                   && h->root.root.string[1] != '\0')
5517                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5518             }
5519           break;
5520
5521           /* The following relocations don't need to propagate the
5522              relocation if linking a shared object since they are
5523              section relative.  */
5524         case R_PPC64_SECTOFF:
5525         case R_PPC64_SECTOFF_LO:
5526         case R_PPC64_SECTOFF_HI:
5527         case R_PPC64_SECTOFF_HA:
5528         case R_PPC64_SECTOFF_DS:
5529         case R_PPC64_SECTOFF_LO_DS:
5530         case R_PPC64_DTPREL16:
5531         case R_PPC64_DTPREL16_LO:
5532         case R_PPC64_DTPREL16_HI:
5533         case R_PPC64_DTPREL16_HA:
5534         case R_PPC64_DTPREL16_DS:
5535         case R_PPC64_DTPREL16_LO_DS:
5536         case R_PPC64_DTPREL16_HIGH:
5537         case R_PPC64_DTPREL16_HIGHA:
5538         case R_PPC64_DTPREL16_HIGHER:
5539         case R_PPC64_DTPREL16_HIGHERA:
5540         case R_PPC64_DTPREL16_HIGHEST:
5541         case R_PPC64_DTPREL16_HIGHESTA:
5542           break;
5543
5544           /* Nor do these.  */
5545         case R_PPC64_REL16:
5546         case R_PPC64_REL16_LO:
5547         case R_PPC64_REL16_HI:
5548         case R_PPC64_REL16_HA:
5549         case R_PPC64_REL16DX_HA:
5550           break;
5551
5552           /* Not supported as a dynamic relocation.  */
5553         case R_PPC64_ADDR64_LOCAL:
5554           if (bfd_link_pic (info))
5555             {
5556               if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5557                 ppc_howto_init ();
5558               info->callbacks->einfo (_("%P: %H: %s reloc unsupported "
5559                                         "in shared libraries and PIEs.\n"),
5560                                       abfd, sec, rel->r_offset,
5561                                       ppc64_elf_howto_table[r_type]->name);
5562               bfd_set_error (bfd_error_bad_value);
5563               return FALSE;
5564             }
5565           break;
5566
5567         case R_PPC64_TOC16:
5568         case R_PPC64_TOC16_DS:
5569           htab->do_multi_toc = 1;
5570           ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5571         case R_PPC64_TOC16_LO:
5572         case R_PPC64_TOC16_HI:
5573         case R_PPC64_TOC16_HA:
5574         case R_PPC64_TOC16_LO_DS:
5575           sec->has_toc_reloc = 1;
5576           break;
5577
5578           /* This relocation describes the C++ object vtable hierarchy.
5579              Reconstruct it for later use during GC.  */
5580         case R_PPC64_GNU_VTINHERIT:
5581           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5582             return FALSE;
5583           break;
5584
5585           /* This relocation describes which C++ vtable entries are actually
5586              used.  Record for later use during GC.  */
5587         case R_PPC64_GNU_VTENTRY:
5588           BFD_ASSERT (h != NULL);
5589           if (h != NULL
5590               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5591             return FALSE;
5592           break;
5593
5594         case R_PPC64_REL14:
5595         case R_PPC64_REL14_BRTAKEN:
5596         case R_PPC64_REL14_BRNTAKEN:
5597           {
5598             asection *dest = NULL;
5599
5600             /* Heuristic: If jumping outside our section, chances are
5601                we are going to need a stub.  */
5602             if (h != NULL)
5603               {
5604                 /* If the sym is weak it may be overridden later, so
5605                    don't assume we know where a weak sym lives.  */
5606                 if (h->root.type == bfd_link_hash_defined)
5607                   dest = h->root.u.def.section;
5608               }
5609             else
5610               {
5611                 Elf_Internal_Sym *isym;
5612
5613                 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5614                                               abfd, r_symndx);
5615                 if (isym == NULL)
5616                   return FALSE;
5617
5618                 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5619               }
5620
5621             if (dest != sec)
5622               ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5623           }
5624           /* Fall through.  */
5625
5626         case R_PPC64_REL24:
5627           if (h != NULL && ifunc == NULL)
5628             {
5629               /* We may need a .plt entry if the function this reloc
5630                  refers to is in a shared lib.  */
5631               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5632                 return FALSE;
5633               h->needs_plt = 1;
5634               if (h->root.root.string[0] == '.'
5635                   && h->root.root.string[1] != '\0')
5636                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5637               if (h == tga || h == dottga)
5638                 sec->has_tls_reloc = 1;
5639             }
5640           break;
5641
5642         case R_PPC64_TPREL64:
5643           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5644           if (bfd_link_pic (info))
5645             info->flags |= DF_STATIC_TLS;
5646           goto dotlstoc;
5647
5648         case R_PPC64_DTPMOD64:
5649           if (rel + 1 < rel_end
5650               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5651               && rel[1].r_offset == rel->r_offset + 8)
5652             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5653           else
5654             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5655           goto dotlstoc;
5656
5657         case R_PPC64_DTPREL64:
5658           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5659           if (rel != relocs
5660               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5661               && rel[-1].r_offset == rel->r_offset - 8)
5662             /* This is the second reloc of a dtpmod, dtprel pair.
5663                Don't mark with TLS_DTPREL.  */
5664             goto dodyn;
5665
5666         dotlstoc:
5667           sec->has_tls_reloc = 1;
5668           if (h != NULL)
5669             {
5670               struct ppc_link_hash_entry *eh;
5671               eh = (struct ppc_link_hash_entry *) h;
5672               eh->tls_mask |= tls_type;
5673             }
5674           else
5675             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5676                                         rel->r_addend, tls_type))
5677               return FALSE;
5678
5679           ppc64_sec = ppc64_elf_section_data (sec);
5680           if (ppc64_sec->sec_type != sec_toc)
5681             {
5682               bfd_size_type amt;
5683
5684               /* One extra to simplify get_tls_mask.  */
5685               amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5686               ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5687               if (ppc64_sec->u.toc.symndx == NULL)
5688                 return FALSE;
5689               amt = sec->size * sizeof (bfd_vma) / 8;
5690               ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5691               if (ppc64_sec->u.toc.add == NULL)
5692                 return FALSE;
5693               BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5694               ppc64_sec->sec_type = sec_toc;
5695             }
5696           BFD_ASSERT (rel->r_offset % 8 == 0);
5697           ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5698           ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5699
5700           /* Mark the second slot of a GD or LD entry.
5701              -1 to indicate GD and -2 to indicate LD.  */
5702           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5703             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5704           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5705             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5706           goto dodyn;
5707
5708         case R_PPC64_TPREL16:
5709         case R_PPC64_TPREL16_LO:
5710         case R_PPC64_TPREL16_HI:
5711         case R_PPC64_TPREL16_HA:
5712         case R_PPC64_TPREL16_DS:
5713         case R_PPC64_TPREL16_LO_DS:
5714         case R_PPC64_TPREL16_HIGH:
5715         case R_PPC64_TPREL16_HIGHA:
5716         case R_PPC64_TPREL16_HIGHER:
5717         case R_PPC64_TPREL16_HIGHERA:
5718         case R_PPC64_TPREL16_HIGHEST:
5719         case R_PPC64_TPREL16_HIGHESTA:
5720           if (bfd_link_pic (info))
5721             {
5722               info->flags |= DF_STATIC_TLS;
5723               goto dodyn;
5724             }
5725           break;
5726
5727         case R_PPC64_ADDR64:
5728           if (opd_sym_map != NULL
5729               && rel + 1 < rel_end
5730               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5731             {
5732               if (h != NULL)
5733                 {
5734                   if (h->root.root.string[0] == '.'
5735                       && h->root.root.string[1] != 0
5736                       && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
5737                     ;
5738                   else
5739                     ((struct ppc_link_hash_entry *) h)->is_func = 1;
5740                 }
5741               else
5742                 {
5743                   asection *s;
5744                   Elf_Internal_Sym *isym;
5745
5746                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5747                                                 abfd, r_symndx);
5748                   if (isym == NULL)
5749                     return FALSE;
5750
5751                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5752                   if (s != NULL && s != sec)
5753                     opd_sym_map[OPD_NDX (rel->r_offset)] = s;
5754                 }
5755             }
5756           /* Fall through.  */
5757
5758         case R_PPC64_ADDR16:
5759         case R_PPC64_ADDR16_DS:
5760         case R_PPC64_ADDR16_HA:
5761         case R_PPC64_ADDR16_HI:
5762         case R_PPC64_ADDR16_HIGH:
5763         case R_PPC64_ADDR16_HIGHA:
5764         case R_PPC64_ADDR16_HIGHER:
5765         case R_PPC64_ADDR16_HIGHERA:
5766         case R_PPC64_ADDR16_HIGHEST:
5767         case R_PPC64_ADDR16_HIGHESTA:
5768         case R_PPC64_ADDR16_LO:
5769         case R_PPC64_ADDR16_LO_DS:
5770           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1
5771               && rel->r_addend == 0)
5772             {
5773               /* We may need a .plt entry if this reloc refers to a
5774                  function in a shared lib.  */
5775               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5776                 return FALSE;
5777               h->pointer_equality_needed = 1;
5778             }
5779           /* Fall through.  */
5780
5781         case R_PPC64_REL30:
5782         case R_PPC64_REL32:
5783         case R_PPC64_REL64:
5784         case R_PPC64_ADDR14:
5785         case R_PPC64_ADDR14_BRNTAKEN:
5786         case R_PPC64_ADDR14_BRTAKEN:
5787         case R_PPC64_ADDR24:
5788         case R_PPC64_ADDR32:
5789         case R_PPC64_UADDR16:
5790         case R_PPC64_UADDR32:
5791         case R_PPC64_UADDR64:
5792         case R_PPC64_TOC:
5793           if (h != NULL && !bfd_link_pic (info))
5794             /* We may need a copy reloc.  */
5795             h->non_got_ref = 1;
5796
5797           /* Don't propagate .opd relocs.  */
5798           if (NO_OPD_RELOCS && opd_sym_map != NULL)
5799             break;
5800
5801           /* If we are creating a shared library, and this is a reloc
5802              against a global symbol, or a non PC relative reloc
5803              against a local symbol, then we need to copy the reloc
5804              into the shared library.  However, if we are linking with
5805              -Bsymbolic, we do not need to copy a reloc against a
5806              global symbol which is defined in an object we are
5807              including in the link (i.e., DEF_REGULAR is set).  At
5808              this point we have not seen all the input files, so it is
5809              possible that DEF_REGULAR is not set now but will be set
5810              later (it is never cleared).  In case of a weak definition,
5811              DEF_REGULAR may be cleared later by a strong definition in
5812              a shared library.  We account for that possibility below by
5813              storing information in the dyn_relocs field of the hash
5814              table entry.  A similar situation occurs when creating
5815              shared libraries and symbol visibility changes render the
5816              symbol local.
5817
5818              If on the other hand, we are creating an executable, we
5819              may need to keep relocations for symbols satisfied by a
5820              dynamic library if we manage to avoid copy relocs for the
5821              symbol.  */
5822         dodyn:
5823           if ((bfd_link_pic (info)
5824                && (must_be_dyn_reloc (info, r_type)
5825                    || (h != NULL
5826                        && (!SYMBOLIC_BIND (info, h)
5827                            || h->root.type == bfd_link_hash_defweak
5828                            || !h->def_regular))))
5829               || (ELIMINATE_COPY_RELOCS
5830                   && !bfd_link_pic (info)
5831                   && h != NULL
5832                   && (h->root.type == bfd_link_hash_defweak
5833                       || !h->def_regular))
5834               || (!bfd_link_pic (info)
5835                   && ifunc != NULL))
5836             {
5837               /* We must copy these reloc types into the output file.
5838                  Create a reloc section in dynobj and make room for
5839                  this reloc.  */
5840               if (sreloc == NULL)
5841                 {
5842                   sreloc = _bfd_elf_make_dynamic_reloc_section
5843                     (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5844
5845                   if (sreloc == NULL)
5846                     return FALSE;
5847                 }
5848
5849               /* If this is a global symbol, we count the number of
5850                  relocations we need for this symbol.  */
5851               if (h != NULL)
5852                 {
5853                   struct elf_dyn_relocs *p;
5854                   struct elf_dyn_relocs **head;
5855
5856                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5857                   p = *head;
5858                   if (p == NULL || p->sec != sec)
5859                     {
5860                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5861                       if (p == NULL)
5862                         return FALSE;
5863                       p->next = *head;
5864                       *head = p;
5865                       p->sec = sec;
5866                       p->count = 0;
5867                       p->pc_count = 0;
5868                     }
5869                   p->count += 1;
5870                   if (!must_be_dyn_reloc (info, r_type))
5871                     p->pc_count += 1;
5872                 }
5873               else
5874                 {
5875                   /* Track dynamic relocs needed for local syms too.
5876                      We really need local syms available to do this
5877                      easily.  Oh well.  */
5878                   struct ppc_dyn_relocs *p;
5879                   struct ppc_dyn_relocs **head;
5880                   bfd_boolean is_ifunc;
5881                   asection *s;
5882                   void *vpp;
5883                   Elf_Internal_Sym *isym;
5884
5885                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5886                                                 abfd, r_symndx);
5887                   if (isym == NULL)
5888                     return FALSE;
5889
5890                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5891                   if (s == NULL)
5892                     s = sec;
5893
5894                   vpp = &elf_section_data (s)->local_dynrel;
5895                   head = (struct ppc_dyn_relocs **) vpp;
5896                   is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5897                   p = *head;
5898                   if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5899                     p = p->next;
5900                   if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5901                     {
5902                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5903                       if (p == NULL)
5904                         return FALSE;
5905                       p->next = *head;
5906                       *head = p;
5907                       p->sec = sec;
5908                       p->ifunc = is_ifunc;
5909                       p->count = 0;
5910                     }
5911                   p->count += 1;
5912                 }
5913             }
5914           break;
5915
5916         default:
5917           break;
5918         }
5919     }
5920
5921   return TRUE;
5922 }
5923
5924 /* Merge backend specific data from an object file to the output
5925    object file when linking.  */
5926
5927 static bfd_boolean
5928 ppc64_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
5929 {
5930   unsigned long iflags, oflags;
5931
5932   if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
5933     return TRUE;
5934
5935   if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
5936     return TRUE;
5937
5938   if (!_bfd_generic_verify_endian_match (ibfd, obfd))
5939     return FALSE;
5940
5941   iflags = elf_elfheader (ibfd)->e_flags;
5942   oflags = elf_elfheader (obfd)->e_flags;
5943
5944   if (iflags & ~EF_PPC64_ABI)
5945     {
5946       (*_bfd_error_handler)
5947         (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
5948       bfd_set_error (bfd_error_bad_value);
5949       return FALSE;
5950     }
5951   else if (iflags != oflags && iflags != 0)
5952     {
5953       (*_bfd_error_handler)
5954         (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
5955          ibfd, iflags, oflags);
5956       bfd_set_error (bfd_error_bad_value);
5957       return FALSE;
5958     }
5959
5960   /* Merge Tag_compatibility attributes and any common GNU ones.  */
5961   _bfd_elf_merge_object_attributes (ibfd, obfd);
5962
5963   return TRUE;
5964 }
5965
5966 static bfd_boolean
5967 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
5968 {
5969   /* Print normal ELF private data.  */
5970   _bfd_elf_print_private_bfd_data (abfd, ptr);
5971
5972   if (elf_elfheader (abfd)->e_flags != 0)
5973     {
5974       FILE *file = ptr;
5975
5976       /* xgettext:c-format */
5977       fprintf (file, _("private flags = 0x%lx:"),
5978                elf_elfheader (abfd)->e_flags);
5979
5980       if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
5981         fprintf (file, _(" [abiv%ld]"),
5982                  elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
5983       fputc ('\n', file);
5984     }
5985
5986   return TRUE;
5987 }
5988
5989 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
5990    of the code entry point, and its section, which must be in the same
5991    object as OPD_SEC.  Returns (bfd_vma) -1 on error.  */
5992
5993 static bfd_vma
5994 opd_entry_value (asection *opd_sec,
5995                  bfd_vma offset,
5996                  asection **code_sec,
5997                  bfd_vma *code_off,
5998                  bfd_boolean in_code_sec)
5999 {
6000   bfd *opd_bfd = opd_sec->owner;
6001   Elf_Internal_Rela *relocs;
6002   Elf_Internal_Rela *lo, *hi, *look;
6003   bfd_vma val;
6004
6005   /* No relocs implies we are linking a --just-symbols object, or looking
6006      at a final linked executable with addr2line or somesuch.  */
6007   if (opd_sec->reloc_count == 0)
6008     {
6009       bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
6010
6011       if (contents == NULL)
6012         {
6013           if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
6014             return (bfd_vma) -1;
6015           ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
6016         }
6017
6018       /* PR 17512: file: 64b9dfbb.  */
6019       if (offset + 7 >= opd_sec->size || offset + 7 < offset)
6020         return (bfd_vma) -1;
6021
6022       val = bfd_get_64 (opd_bfd, contents + offset);
6023       if (code_sec != NULL)
6024         {
6025           asection *sec, *likely = NULL;
6026
6027           if (in_code_sec)
6028             {
6029               sec = *code_sec;
6030               if (sec->vma <= val
6031                   && val < sec->vma + sec->size)
6032                 likely = sec;
6033               else
6034                 val = -1;
6035             }
6036           else
6037             for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
6038               if (sec->vma <= val
6039                   && (sec->flags & SEC_LOAD) != 0
6040                   && (sec->flags & SEC_ALLOC) != 0)
6041                 likely = sec;
6042           if (likely != NULL)
6043             {
6044               *code_sec = likely;
6045               if (code_off != NULL)
6046                 *code_off = val - likely->vma;
6047             }
6048         }
6049       return val;
6050     }
6051
6052   BFD_ASSERT (is_ppc64_elf (opd_bfd));
6053
6054   relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
6055   if (relocs == NULL)
6056     relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
6057   /* PR 17512: file: df8e1fd6.  */
6058   if (relocs == NULL)
6059     return (bfd_vma) -1;
6060
6061   /* Go find the opd reloc at the sym address.  */
6062   lo = relocs;
6063   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
6064   val = (bfd_vma) -1;
6065   while (lo < hi)
6066     {
6067       look = lo + (hi - lo) / 2;
6068       if (look->r_offset < offset)
6069         lo = look + 1;
6070       else if (look->r_offset > offset)
6071         hi = look;
6072       else
6073         {
6074           Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
6075
6076           if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
6077               && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
6078             {
6079               unsigned long symndx = ELF64_R_SYM (look->r_info);
6080               asection *sec = NULL;
6081
6082               if (symndx >= symtab_hdr->sh_info
6083                   && elf_sym_hashes (opd_bfd) != NULL)
6084                 {
6085                   struct elf_link_hash_entry **sym_hashes;
6086                   struct elf_link_hash_entry *rh;
6087
6088                   sym_hashes = elf_sym_hashes (opd_bfd);
6089                   rh = sym_hashes[symndx - symtab_hdr->sh_info];
6090                   if (rh != NULL)
6091                     {
6092                       rh = elf_follow_link (rh);
6093                       if (rh->root.type != bfd_link_hash_defined
6094                           && rh->root.type != bfd_link_hash_defweak)
6095                         break;
6096                       if (rh->root.u.def.section->owner == opd_bfd)
6097                         {
6098                           val = rh->root.u.def.value;
6099                           sec = rh->root.u.def.section;
6100                         }
6101                     }
6102                 }
6103
6104               if (sec == NULL)
6105                 {
6106                   Elf_Internal_Sym *sym;
6107
6108                   if (symndx < symtab_hdr->sh_info)
6109                     {
6110                       sym = (Elf_Internal_Sym *) symtab_hdr->contents;
6111                       if (sym == NULL)
6112                         {
6113                           size_t symcnt = symtab_hdr->sh_info;
6114                           sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6115                                                       symcnt, 0,
6116                                                       NULL, NULL, NULL);
6117                           if (sym == NULL)
6118                             break;
6119                           symtab_hdr->contents = (bfd_byte *) sym;
6120                         }
6121                       sym += symndx;
6122                     }
6123                   else
6124                     {
6125                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6126                                                   1, symndx,
6127                                                   NULL, NULL, NULL);
6128                       if (sym == NULL)
6129                         break;
6130                     }
6131                   sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6132                   if (sec == NULL)
6133                     break;
6134                   BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
6135                   val = sym->st_value;
6136                 }
6137
6138               val += look->r_addend;
6139               if (code_off != NULL)
6140                 *code_off = val;
6141               if (code_sec != NULL)
6142                 {
6143                   if (in_code_sec && *code_sec != sec)
6144                     return -1;
6145                   else
6146                     *code_sec = sec;
6147                 }
6148               if (sec->output_section != NULL)
6149                 val += sec->output_section->vma + sec->output_offset;
6150             }
6151           break;
6152         }
6153     }
6154
6155   return val;
6156 }
6157
6158 /* If the ELF symbol SYM might be a function in SEC, return the
6159    function size and set *CODE_OFF to the function's entry point,
6160    otherwise return zero.  */
6161
6162 static bfd_size_type
6163 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6164                               bfd_vma *code_off)
6165 {
6166   bfd_size_type size;
6167
6168   if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6169                      | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6170     return 0;
6171
6172   size = 0;
6173   if (!(sym->flags & BSF_SYNTHETIC))
6174     size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6175
6176   if (strcmp (sym->section->name, ".opd") == 0)
6177     {
6178       struct _opd_sec_data *opd = get_opd_info (sym->section);
6179       bfd_vma symval = sym->value;
6180
6181       if (opd != NULL
6182           && opd->adjust != NULL
6183           && elf_section_data (sym->section)->relocs != NULL)
6184         {
6185           /* opd_entry_value will use cached relocs that have been
6186              adjusted, but with raw symbols.  That means both local
6187              and global symbols need adjusting.  */
6188           long adjust = opd->adjust[OPD_NDX (symval)];
6189           if (adjust == -1)
6190             return 0;
6191           symval += adjust;
6192         }
6193
6194       if (opd_entry_value (sym->section, symval,
6195                            &sec, code_off, TRUE) == (bfd_vma) -1)
6196         return 0;
6197       /* An old ABI binary with dot-syms has a size of 24 on the .opd
6198          symbol.  This size has nothing to do with the code size of the
6199          function, which is what we're supposed to return, but the
6200          code size isn't available without looking up the dot-sym.
6201          However, doing that would be a waste of time particularly
6202          since elf_find_function will look at the dot-sym anyway.
6203          Now, elf_find_function will keep the largest size of any
6204          function sym found at the code address of interest, so return
6205          1 here to avoid it incorrectly caching a larger function size
6206          for a small function.  This does mean we return the wrong
6207          size for a new-ABI function of size 24, but all that does is
6208          disable caching for such functions.  */
6209       if (size == 24)
6210         size = 1;
6211     }
6212   else
6213     {
6214       if (sym->section != sec)
6215         return 0;
6216       *code_off = sym->value;
6217     }
6218   if (size == 0)
6219     size = 1;
6220   return size;
6221 }
6222
6223 /* Return true if symbol is defined in a regular object file.  */
6224
6225 static bfd_boolean
6226 is_static_defined (struct elf_link_hash_entry *h)
6227 {
6228   return ((h->root.type == bfd_link_hash_defined
6229            || h->root.type == bfd_link_hash_defweak)
6230           && h->root.u.def.section != NULL
6231           && h->root.u.def.section->output_section != NULL);
6232 }
6233
6234 /* If FDH is a function descriptor symbol, return the associated code
6235    entry symbol if it is defined.  Return NULL otherwise.  */
6236
6237 static struct ppc_link_hash_entry *
6238 defined_code_entry (struct ppc_link_hash_entry *fdh)
6239 {
6240   if (fdh->is_func_descriptor)
6241     {
6242       struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6243       if (fh->elf.root.type == bfd_link_hash_defined
6244           || fh->elf.root.type == bfd_link_hash_defweak)
6245         return fh;
6246     }
6247   return NULL;
6248 }
6249
6250 /* If FH is a function code entry symbol, return the associated
6251    function descriptor symbol if it is defined.  Return NULL otherwise.  */
6252
6253 static struct ppc_link_hash_entry *
6254 defined_func_desc (struct ppc_link_hash_entry *fh)
6255 {
6256   if (fh->oh != NULL
6257       && fh->oh->is_func_descriptor)
6258     {
6259       struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6260       if (fdh->elf.root.type == bfd_link_hash_defined
6261           || fdh->elf.root.type == bfd_link_hash_defweak)
6262         return fdh;
6263     }
6264   return NULL;
6265 }
6266
6267 /* Mark all our entry sym sections, both opd and code section.  */
6268
6269 static void
6270 ppc64_elf_gc_keep (struct bfd_link_info *info)
6271 {
6272   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6273   struct bfd_sym_chain *sym;
6274
6275   if (htab == NULL)
6276     return;
6277
6278   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6279     {
6280       struct ppc_link_hash_entry *eh, *fh;
6281       asection *sec;
6282
6283       eh = (struct ppc_link_hash_entry *)
6284         elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6285       if (eh == NULL)
6286         continue;
6287       if (eh->elf.root.type != bfd_link_hash_defined
6288           && eh->elf.root.type != bfd_link_hash_defweak)
6289         continue;
6290
6291       fh = defined_code_entry (eh);
6292       if (fh != NULL)
6293         {
6294           sec = fh->elf.root.u.def.section;
6295           sec->flags |= SEC_KEEP;
6296         }
6297       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6298                && opd_entry_value (eh->elf.root.u.def.section,
6299                                    eh->elf.root.u.def.value,
6300                                    &sec, NULL, FALSE) != (bfd_vma) -1)
6301         sec->flags |= SEC_KEEP;
6302
6303       sec = eh->elf.root.u.def.section;
6304       sec->flags |= SEC_KEEP;
6305     }
6306 }
6307
6308 /* Mark sections containing dynamically referenced symbols.  When
6309    building shared libraries, we must assume that any visible symbol is
6310    referenced.  */
6311
6312 static bfd_boolean
6313 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6314 {
6315   struct bfd_link_info *info = (struct bfd_link_info *) inf;
6316   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6317   struct ppc_link_hash_entry *fdh;
6318   struct bfd_elf_dynamic_list *d = info->dynamic_list;
6319
6320   /* Dynamic linking info is on the func descriptor sym.  */
6321   fdh = defined_func_desc (eh);
6322   if (fdh != NULL)
6323     eh = fdh;
6324
6325   if ((eh->elf.root.type == bfd_link_hash_defined
6326        || eh->elf.root.type == bfd_link_hash_defweak)
6327       && (eh->elf.ref_dynamic
6328           || ((eh->elf.def_regular || ELF_COMMON_DEF_P (&eh->elf))
6329               && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6330               && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6331               && (!bfd_link_executable (info)
6332                   || info->export_dynamic
6333                   || (eh->elf.dynamic
6334                       && d != NULL
6335                       && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
6336               && (strchr (eh->elf.root.root.string, ELF_VER_CHR) != NULL
6337                   || !bfd_hide_sym_by_version (info->version_info,
6338                                                eh->elf.root.root.string)))))
6339     {
6340       asection *code_sec;
6341       struct ppc_link_hash_entry *fh;
6342
6343       eh->elf.root.u.def.section->flags |= SEC_KEEP;
6344
6345       /* Function descriptor syms cause the associated
6346          function code sym section to be marked.  */
6347       fh = defined_code_entry (eh);
6348       if (fh != NULL)
6349         {
6350           code_sec = fh->elf.root.u.def.section;
6351           code_sec->flags |= SEC_KEEP;
6352         }
6353       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6354                && opd_entry_value (eh->elf.root.u.def.section,
6355                                    eh->elf.root.u.def.value,
6356                                    &code_sec, NULL, FALSE) != (bfd_vma) -1)
6357         code_sec->flags |= SEC_KEEP;
6358     }
6359
6360   return TRUE;
6361 }
6362
6363 /* Return the section that should be marked against GC for a given
6364    relocation.  */
6365
6366 static asection *
6367 ppc64_elf_gc_mark_hook (asection *sec,
6368                         struct bfd_link_info *info,
6369                         Elf_Internal_Rela *rel,
6370                         struct elf_link_hash_entry *h,
6371                         Elf_Internal_Sym *sym)
6372 {
6373   asection *rsec;
6374
6375   /* Syms return NULL if we're marking .opd, so we avoid marking all
6376      function sections, as all functions are referenced in .opd.  */
6377   rsec = NULL;
6378   if (get_opd_info (sec) != NULL)
6379     return rsec;
6380
6381   if (h != NULL)
6382     {
6383       enum elf_ppc64_reloc_type r_type;
6384       struct ppc_link_hash_entry *eh, *fh, *fdh;
6385
6386       r_type = ELF64_R_TYPE (rel->r_info);
6387       switch (r_type)
6388         {
6389         case R_PPC64_GNU_VTINHERIT:
6390         case R_PPC64_GNU_VTENTRY:
6391           break;
6392
6393         default:
6394           switch (h->root.type)
6395             {
6396             case bfd_link_hash_defined:
6397             case bfd_link_hash_defweak:
6398               eh = (struct ppc_link_hash_entry *) h;
6399               fdh = defined_func_desc (eh);
6400               if (fdh != NULL)
6401                 eh = fdh;
6402
6403               /* Function descriptor syms cause the associated
6404                  function code sym section to be marked.  */
6405               fh = defined_code_entry (eh);
6406               if (fh != NULL)
6407                 {
6408                   /* They also mark their opd section.  */
6409                   eh->elf.root.u.def.section->gc_mark = 1;
6410
6411                   rsec = fh->elf.root.u.def.section;
6412                 }
6413               else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6414                        && opd_entry_value (eh->elf.root.u.def.section,
6415                                            eh->elf.root.u.def.value,
6416                                            &rsec, NULL, FALSE) != (bfd_vma) -1)
6417                 eh->elf.root.u.def.section->gc_mark = 1;
6418               else
6419                 rsec = h->root.u.def.section;
6420               break;
6421
6422             case bfd_link_hash_common:
6423               rsec = h->root.u.c.p->section;
6424               break;
6425
6426             default:
6427               return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6428             }
6429         }
6430     }
6431   else
6432     {
6433       struct _opd_sec_data *opd;
6434
6435       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6436       opd = get_opd_info (rsec);
6437       if (opd != NULL && opd->func_sec != NULL)
6438         {
6439           rsec->gc_mark = 1;
6440
6441           rsec = opd->func_sec[OPD_NDX (sym->st_value + rel->r_addend)];
6442         }
6443     }
6444
6445   return rsec;
6446 }
6447
6448 /* Update the .got, .plt. and dynamic reloc reference counts for the
6449    section being removed.  */
6450
6451 static bfd_boolean
6452 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
6453                          asection *sec, const Elf_Internal_Rela *relocs)
6454 {
6455   struct ppc_link_hash_table *htab;
6456   Elf_Internal_Shdr *symtab_hdr;
6457   struct elf_link_hash_entry **sym_hashes;
6458   struct got_entry **local_got_ents;
6459   const Elf_Internal_Rela *rel, *relend;
6460
6461   if (bfd_link_relocatable (info))
6462     return TRUE;
6463
6464   if ((sec->flags & SEC_ALLOC) == 0)
6465     return TRUE;
6466
6467   elf_section_data (sec)->local_dynrel = NULL;
6468
6469   htab = ppc_hash_table (info);
6470   if (htab == NULL)
6471     return FALSE;
6472
6473   symtab_hdr = &elf_symtab_hdr (abfd);
6474   sym_hashes = elf_sym_hashes (abfd);
6475   local_got_ents = elf_local_got_ents (abfd);
6476
6477   relend = relocs + sec->reloc_count;
6478   for (rel = relocs; rel < relend; rel++)
6479     {
6480       unsigned long r_symndx;
6481       enum elf_ppc64_reloc_type r_type;
6482       struct elf_link_hash_entry *h = NULL;
6483       unsigned char tls_type = 0;
6484
6485       r_symndx = ELF64_R_SYM (rel->r_info);
6486       r_type = ELF64_R_TYPE (rel->r_info);
6487       if (r_symndx >= symtab_hdr->sh_info)
6488         {
6489           struct ppc_link_hash_entry *eh;
6490           struct elf_dyn_relocs **pp;
6491           struct elf_dyn_relocs *p;
6492
6493           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6494           h = elf_follow_link (h);
6495           eh = (struct ppc_link_hash_entry *) h;
6496
6497           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6498             if (p->sec == sec)
6499               {
6500                 /* Everything must go for SEC.  */
6501                 *pp = p->next;
6502                 break;
6503               }
6504         }
6505
6506       if (is_branch_reloc (r_type))
6507         {
6508           struct plt_entry **ifunc = NULL;
6509           if (h != NULL)
6510             {
6511               if (h->type == STT_GNU_IFUNC)
6512                 ifunc = &h->plt.plist;
6513             }
6514           else if (local_got_ents != NULL)
6515             {
6516               struct plt_entry **local_plt = (struct plt_entry **)
6517                 (local_got_ents + symtab_hdr->sh_info);
6518               unsigned char *local_got_tls_masks = (unsigned char *)
6519                 (local_plt + symtab_hdr->sh_info);
6520               if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6521                 ifunc = local_plt + r_symndx;
6522             }
6523           if (ifunc != NULL)
6524             {
6525               struct plt_entry *ent;
6526
6527               for (ent = *ifunc; ent != NULL; ent = ent->next)
6528                 if (ent->addend == rel->r_addend)
6529                   break;
6530               if (ent == NULL)
6531                 abort ();
6532               if (ent->plt.refcount > 0)
6533                 ent->plt.refcount -= 1;
6534               continue;
6535             }
6536         }
6537
6538       switch (r_type)
6539         {
6540         case R_PPC64_GOT_TLSLD16:
6541         case R_PPC64_GOT_TLSLD16_LO:
6542         case R_PPC64_GOT_TLSLD16_HI:
6543         case R_PPC64_GOT_TLSLD16_HA:
6544           tls_type = TLS_TLS | TLS_LD;
6545           goto dogot;
6546
6547         case R_PPC64_GOT_TLSGD16:
6548         case R_PPC64_GOT_TLSGD16_LO:
6549         case R_PPC64_GOT_TLSGD16_HI:
6550         case R_PPC64_GOT_TLSGD16_HA:
6551           tls_type = TLS_TLS | TLS_GD;
6552           goto dogot;
6553
6554         case R_PPC64_GOT_TPREL16_DS:
6555         case R_PPC64_GOT_TPREL16_LO_DS:
6556         case R_PPC64_GOT_TPREL16_HI:
6557         case R_PPC64_GOT_TPREL16_HA:
6558           tls_type = TLS_TLS | TLS_TPREL;
6559           goto dogot;
6560
6561         case R_PPC64_GOT_DTPREL16_DS:
6562         case R_PPC64_GOT_DTPREL16_LO_DS:
6563         case R_PPC64_GOT_DTPREL16_HI:
6564         case R_PPC64_GOT_DTPREL16_HA:
6565           tls_type = TLS_TLS | TLS_DTPREL;
6566           goto dogot;
6567
6568         case R_PPC64_GOT16:
6569         case R_PPC64_GOT16_DS:
6570         case R_PPC64_GOT16_HA:
6571         case R_PPC64_GOT16_HI:
6572         case R_PPC64_GOT16_LO:
6573         case R_PPC64_GOT16_LO_DS:
6574         dogot:
6575           {
6576             struct got_entry *ent;
6577
6578             if (h != NULL)
6579               ent = h->got.glist;
6580             else
6581               ent = local_got_ents[r_symndx];
6582
6583             for (; ent != NULL; ent = ent->next)
6584               if (ent->addend == rel->r_addend
6585                   && ent->owner == abfd
6586                   && ent->tls_type == tls_type)
6587                 break;
6588             if (ent == NULL)
6589               abort ();
6590             if (ent->got.refcount > 0)
6591               ent->got.refcount -= 1;
6592           }
6593           break;
6594
6595         case R_PPC64_PLT16_HA:
6596         case R_PPC64_PLT16_HI:
6597         case R_PPC64_PLT16_LO:
6598         case R_PPC64_PLT32:
6599         case R_PPC64_PLT64:
6600         case R_PPC64_REL14:
6601         case R_PPC64_REL14_BRNTAKEN:
6602         case R_PPC64_REL14_BRTAKEN:
6603         case R_PPC64_REL24:
6604           if (h != NULL)
6605             {
6606               struct plt_entry *ent;
6607
6608               for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6609                 if (ent->addend == rel->r_addend)
6610                   break;
6611               if (ent != NULL && ent->plt.refcount > 0)
6612                 ent->plt.refcount -= 1;
6613             }
6614           break;
6615
6616         default:
6617           break;
6618         }
6619     }
6620   return TRUE;
6621 }
6622
6623 /* The maximum size of .sfpr.  */
6624 #define SFPR_MAX (218*4)
6625
6626 struct sfpr_def_parms
6627 {
6628   const char name[12];
6629   unsigned char lo, hi;
6630   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6631   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6632 };
6633
6634 /* Auto-generate _save*, _rest* functions in .sfpr.
6635    If STUB_SEC is non-null, define alias symbols in STUB_SEC
6636    instead.  */
6637
6638 static bfd_boolean
6639 sfpr_define (struct bfd_link_info *info,
6640              const struct sfpr_def_parms *parm,
6641              asection *stub_sec)
6642 {
6643   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6644   unsigned int i;
6645   size_t len = strlen (parm->name);
6646   bfd_boolean writing = FALSE;
6647   char sym[16];
6648
6649   if (htab == NULL)
6650     return FALSE;
6651
6652   memcpy (sym, parm->name, len);
6653   sym[len + 2] = 0;
6654
6655   for (i = parm->lo; i <= parm->hi; i++)
6656     {
6657       struct ppc_link_hash_entry *h;
6658
6659       sym[len + 0] = i / 10 + '0';
6660       sym[len + 1] = i % 10 + '0';
6661       h = (struct ppc_link_hash_entry *)
6662         elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE);
6663       if (stub_sec != NULL)
6664         {
6665           if (h != NULL
6666               && h->elf.root.type == bfd_link_hash_defined
6667               && h->elf.root.u.def.section == htab->sfpr)
6668             {
6669               struct elf_link_hash_entry *s;
6670               char buf[32];
6671               sprintf (buf, "%08x.%s", stub_sec->id & 0xffffffff, sym);
6672               s = elf_link_hash_lookup (&htab->elf, buf, TRUE, TRUE, FALSE);
6673               if (s == NULL)
6674                 return FALSE;
6675               if (s->root.type == bfd_link_hash_new
6676                   || (s->root.type = bfd_link_hash_defined
6677                       && s->root.u.def.section == stub_sec))
6678                 {
6679                   s->root.type = bfd_link_hash_defined;
6680                   s->root.u.def.section = stub_sec;
6681                   s->root.u.def.value = (stub_sec->size
6682                                          + h->elf.root.u.def.value);
6683                   s->ref_regular = 1;
6684                   s->def_regular = 1;
6685                   s->ref_regular_nonweak = 1;
6686                   s->forced_local = 1;
6687                   s->non_elf = 0;
6688                   s->root.linker_def = 1;
6689                 }
6690             }
6691           continue;
6692         }
6693       if (h != NULL)
6694         {
6695           h->save_res = 1;
6696           if (!h->elf.def_regular)
6697             {
6698               h->elf.root.type = bfd_link_hash_defined;
6699               h->elf.root.u.def.section = htab->sfpr;
6700               h->elf.root.u.def.value = htab->sfpr->size;
6701               h->elf.type = STT_FUNC;
6702               h->elf.def_regular = 1;
6703               _bfd_elf_link_hash_hide_symbol (info, &h->elf, TRUE);
6704               writing = TRUE;
6705               if (htab->sfpr->contents == NULL)
6706                 {
6707                   htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6708                   if (htab->sfpr->contents == NULL)
6709                     return FALSE;
6710                 }
6711             }
6712         }
6713       if (writing)
6714         {
6715           bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6716           if (i != parm->hi)
6717             p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6718           else
6719             p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6720           htab->sfpr->size = p - htab->sfpr->contents;
6721         }
6722     }
6723
6724   return TRUE;
6725 }
6726
6727 static bfd_byte *
6728 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6729 {
6730   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6731   return p + 4;
6732 }
6733
6734 static bfd_byte *
6735 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6736 {
6737   p = savegpr0 (abfd, p, r);
6738   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6739   p = p + 4;
6740   bfd_put_32 (abfd, BLR, p);
6741   return p + 4;
6742 }
6743
6744 static bfd_byte *
6745 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6746 {
6747   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6748   return p + 4;
6749 }
6750
6751 static bfd_byte *
6752 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6753 {
6754   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6755   p = p + 4;
6756   p = restgpr0 (abfd, p, r);
6757   bfd_put_32 (abfd, MTLR_R0, p);
6758   p = p + 4;
6759   if (r == 29)
6760     {
6761       p = restgpr0 (abfd, p, 30);
6762       p = restgpr0 (abfd, p, 31);
6763     }
6764   bfd_put_32 (abfd, BLR, p);
6765   return p + 4;
6766 }
6767
6768 static bfd_byte *
6769 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6770 {
6771   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6772   return p + 4;
6773 }
6774
6775 static bfd_byte *
6776 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6777 {
6778   p = savegpr1 (abfd, p, r);
6779   bfd_put_32 (abfd, BLR, p);
6780   return p + 4;
6781 }
6782
6783 static bfd_byte *
6784 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6785 {
6786   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6787   return p + 4;
6788 }
6789
6790 static bfd_byte *
6791 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6792 {
6793   p = restgpr1 (abfd, p, r);
6794   bfd_put_32 (abfd, BLR, p);
6795   return p + 4;
6796 }
6797
6798 static bfd_byte *
6799 savefpr (bfd *abfd, bfd_byte *p, int r)
6800 {
6801   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6802   return p + 4;
6803 }
6804
6805 static bfd_byte *
6806 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6807 {
6808   p = savefpr (abfd, p, r);
6809   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6810   p = p + 4;
6811   bfd_put_32 (abfd, BLR, p);
6812   return p + 4;
6813 }
6814
6815 static bfd_byte *
6816 restfpr (bfd *abfd, bfd_byte *p, int r)
6817 {
6818   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6819   return p + 4;
6820 }
6821
6822 static bfd_byte *
6823 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6824 {
6825   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6826   p = p + 4;
6827   p = restfpr (abfd, p, r);
6828   bfd_put_32 (abfd, MTLR_R0, p);
6829   p = p + 4;
6830   if (r == 29)
6831     {
6832       p = restfpr (abfd, p, 30);
6833       p = restfpr (abfd, p, 31);
6834     }
6835   bfd_put_32 (abfd, BLR, p);
6836   return p + 4;
6837 }
6838
6839 static bfd_byte *
6840 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6841 {
6842   p = savefpr (abfd, p, r);
6843   bfd_put_32 (abfd, BLR, p);
6844   return p + 4;
6845 }
6846
6847 static bfd_byte *
6848 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6849 {
6850   p = restfpr (abfd, p, r);
6851   bfd_put_32 (abfd, BLR, p);
6852   return p + 4;
6853 }
6854
6855 static bfd_byte *
6856 savevr (bfd *abfd, bfd_byte *p, int r)
6857 {
6858   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6859   p = p + 4;
6860   bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6861   return p + 4;
6862 }
6863
6864 static bfd_byte *
6865 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6866 {
6867   p = savevr (abfd, p, r);
6868   bfd_put_32 (abfd, BLR, p);
6869   return p + 4;
6870 }
6871
6872 static bfd_byte *
6873 restvr (bfd *abfd, bfd_byte *p, int r)
6874 {
6875   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6876   p = p + 4;
6877   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6878   return p + 4;
6879 }
6880
6881 static bfd_byte *
6882 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6883 {
6884   p = restvr (abfd, p, r);
6885   bfd_put_32 (abfd, BLR, p);
6886   return p + 4;
6887 }
6888
6889 /* Called via elf_link_hash_traverse to transfer dynamic linking
6890    information on function code symbol entries to their corresponding
6891    function descriptor symbol entries.  */
6892
6893 static bfd_boolean
6894 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6895 {
6896   struct bfd_link_info *info;
6897   struct ppc_link_hash_table *htab;
6898   struct plt_entry *ent;
6899   struct ppc_link_hash_entry *fh;
6900   struct ppc_link_hash_entry *fdh;
6901   bfd_boolean force_local;
6902
6903   fh = (struct ppc_link_hash_entry *) h;
6904   if (fh->elf.root.type == bfd_link_hash_indirect)
6905     return TRUE;
6906
6907   info = inf;
6908   htab = ppc_hash_table (info);
6909   if (htab == NULL)
6910     return FALSE;
6911
6912   /* Resolve undefined references to dot-symbols as the value
6913      in the function descriptor, if we have one in a regular object.
6914      This is to satisfy cases like ".quad .foo".  Calls to functions
6915      in dynamic objects are handled elsewhere.  */
6916   if (fh->elf.root.type == bfd_link_hash_undefweak
6917       && fh->was_undefined
6918       && (fdh = defined_func_desc (fh)) != NULL
6919       && get_opd_info (fdh->elf.root.u.def.section) != NULL
6920       && opd_entry_value (fdh->elf.root.u.def.section,
6921                           fdh->elf.root.u.def.value,
6922                           &fh->elf.root.u.def.section,
6923                           &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
6924     {
6925       fh->elf.root.type = fdh->elf.root.type;
6926       fh->elf.forced_local = 1;
6927       fh->elf.def_regular = fdh->elf.def_regular;
6928       fh->elf.def_dynamic = fdh->elf.def_dynamic;
6929     }
6930
6931   /* If this is a function code symbol, transfer dynamic linking
6932      information to the function descriptor symbol.  */
6933   if (!fh->is_func)
6934     return TRUE;
6935
6936   for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6937     if (ent->plt.refcount > 0)
6938       break;
6939   if (ent == NULL
6940       || fh->elf.root.root.string[0] != '.'
6941       || fh->elf.root.root.string[1] == '\0')
6942     return TRUE;
6943
6944   /* Find the corresponding function descriptor symbol.  Create it
6945      as undefined if necessary.  */
6946
6947   fdh = lookup_fdh (fh, htab);
6948   if (fdh == NULL
6949       && !bfd_link_executable (info)
6950       && (fh->elf.root.type == bfd_link_hash_undefined
6951           || fh->elf.root.type == bfd_link_hash_undefweak))
6952     {
6953       fdh = make_fdh (info, fh);
6954       if (fdh == NULL)
6955         return FALSE;
6956     }
6957
6958   /* Fake function descriptors are made undefweak.  If the function
6959      code symbol is strong undefined, make the fake sym the same.
6960      If the function code symbol is defined, then force the fake
6961      descriptor local;  We can't support overriding of symbols in a
6962      shared library on a fake descriptor.  */
6963
6964   if (fdh != NULL
6965       && fdh->fake
6966       && fdh->elf.root.type == bfd_link_hash_undefweak)
6967     {
6968       if (fh->elf.root.type == bfd_link_hash_undefined)
6969         {
6970           fdh->elf.root.type = bfd_link_hash_undefined;
6971           bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
6972         }
6973       else if (fh->elf.root.type == bfd_link_hash_defined
6974                || fh->elf.root.type == bfd_link_hash_defweak)
6975         {
6976           _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6977         }
6978     }
6979
6980   if (fdh != NULL
6981       && !fdh->elf.forced_local
6982       && (!bfd_link_executable (info)
6983           || fdh->elf.def_dynamic
6984           || fdh->elf.ref_dynamic
6985           || (fdh->elf.root.type == bfd_link_hash_undefweak
6986               && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
6987     {
6988       if (fdh->elf.dynindx == -1)
6989         if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
6990           return FALSE;
6991       fdh->elf.ref_regular |= fh->elf.ref_regular;
6992       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
6993       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
6994       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
6995       if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
6996         {
6997           move_plt_plist (fh, fdh);
6998           fdh->elf.needs_plt = 1;
6999         }
7000       fdh->is_func_descriptor = 1;
7001       fdh->oh = fh;
7002       fh->oh = fdh;
7003     }
7004
7005   /* Now that the info is on the function descriptor, clear the
7006      function code sym info.  Any function code syms for which we
7007      don't have a definition in a regular file, we force local.
7008      This prevents a shared library from exporting syms that have
7009      been imported from another library.  Function code syms that
7010      are really in the library we must leave global to prevent the
7011      linker dragging in a definition from a static library.  */
7012   force_local = (!fh->elf.def_regular
7013                  || fdh == NULL
7014                  || !fdh->elf.def_regular
7015                  || fdh->elf.forced_local);
7016   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7017
7018   return TRUE;
7019 }
7020
7021 static const struct sfpr_def_parms save_res_funcs[] =
7022   {
7023     { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
7024     { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
7025     { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
7026     { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
7027     { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
7028     { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
7029     { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
7030     { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
7031     { "._savef", 14, 31, savefpr, savefpr1_tail },
7032     { "._restf", 14, 31, restfpr, restfpr1_tail },
7033     { "_savevr_", 20, 31, savevr, savevr_tail },
7034     { "_restvr_", 20, 31, restvr, restvr_tail }
7035   };
7036
7037 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
7038    this hook to a) provide some gcc support functions, and b) transfer
7039    dynamic linking information gathered so far on function code symbol
7040    entries, to their corresponding function descriptor symbol entries.  */
7041
7042 static bfd_boolean
7043 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
7044                             struct bfd_link_info *info)
7045 {
7046   struct ppc_link_hash_table *htab;
7047   unsigned int i;
7048
7049   htab = ppc_hash_table (info);
7050   if (htab == NULL)
7051     return FALSE;
7052
7053   if (!bfd_link_relocatable (info)
7054       && htab->elf.hgot != NULL)
7055     {
7056       _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
7057       /* Make .TOC. defined so as to prevent it being made dynamic.
7058          The wrong value here is fixed later in ppc64_elf_set_toc.  */
7059       if (!htab->elf.hgot->def_regular
7060           || htab->elf.hgot->root.type != bfd_link_hash_defined)
7061         {
7062           htab->elf.hgot->root.type = bfd_link_hash_defined;
7063           htab->elf.hgot->root.u.def.value = 0;
7064           htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
7065           htab->elf.hgot->def_regular = 1;
7066           htab->elf.hgot->root.linker_def = 1;
7067         }
7068       htab->elf.hgot->type = STT_OBJECT;
7069       htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
7070                                | STV_HIDDEN);
7071     }
7072
7073   if (htab->sfpr == NULL)
7074     /* We don't have any relocs.  */
7075     return TRUE;
7076
7077   /* Provide any missing _save* and _rest* functions.  */
7078   htab->sfpr->size = 0;
7079   if (htab->params->save_restore_funcs)
7080     for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
7081       if (!sfpr_define (info, &save_res_funcs[i], NULL))
7082         return FALSE;
7083
7084   elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
7085
7086   if (htab->sfpr->size == 0)
7087     htab->sfpr->flags |= SEC_EXCLUDE;
7088
7089   return TRUE;
7090 }
7091
7092 /* Return true if we have dynamic relocs that apply to read-only sections.  */
7093
7094 static bfd_boolean
7095 readonly_dynrelocs (struct elf_link_hash_entry *h)
7096 {
7097   struct ppc_link_hash_entry *eh;
7098   struct elf_dyn_relocs *p;
7099
7100   eh = (struct ppc_link_hash_entry *) h;
7101   for (p = eh->dyn_relocs; p != NULL; p = p->next)
7102     {
7103       asection *s = p->sec->output_section;
7104
7105       if (s != NULL && (s->flags & SEC_READONLY) != 0)
7106         return TRUE;
7107     }
7108   return FALSE;
7109 }
7110
7111 /* Adjust a symbol defined by a dynamic object and referenced by a
7112    regular object.  The current definition is in some section of the
7113    dynamic object, but we're not including those sections.  We have to
7114    change the definition to something the rest of the link can
7115    understand.  */
7116
7117 static bfd_boolean
7118 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
7119                                  struct elf_link_hash_entry *h)
7120 {
7121   struct ppc_link_hash_table *htab;
7122   asection *s;
7123
7124   htab = ppc_hash_table (info);
7125   if (htab == NULL)
7126     return FALSE;
7127
7128   /* Deal with function syms.  */
7129   if (h->type == STT_FUNC
7130       || h->type == STT_GNU_IFUNC
7131       || h->needs_plt)
7132     {
7133       /* Clear procedure linkage table information for any symbol that
7134          won't need a .plt entry.  */
7135       struct plt_entry *ent;
7136       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
7137         if (ent->plt.refcount > 0)
7138           break;
7139       if (ent == NULL
7140           || (h->type != STT_GNU_IFUNC
7141               && (SYMBOL_CALLS_LOCAL (info, h)
7142                   || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
7143                       && h->root.type == bfd_link_hash_undefweak)))
7144           || ((struct ppc_link_hash_entry *) h)->save_res)
7145         {
7146           h->plt.plist = NULL;
7147           h->needs_plt = 0;
7148           h->pointer_equality_needed = 0;
7149         }
7150       else if (abiversion (info->output_bfd) == 2)
7151         {
7152           /* Taking a function's address in a read/write section
7153              doesn't require us to define the function symbol in the
7154              executable on a global entry stub.  A dynamic reloc can
7155              be used instead.  */
7156           if (h->pointer_equality_needed
7157               && h->type != STT_GNU_IFUNC
7158               && !readonly_dynrelocs (h))
7159             {
7160               h->pointer_equality_needed = 0;
7161               h->non_got_ref = 0;
7162             }
7163
7164           /* After adjust_dynamic_symbol, non_got_ref set in the
7165              non-shared case means that we have allocated space in
7166              .dynbss for the symbol and thus dyn_relocs for this
7167              symbol should be discarded.
7168              If we get here we know we are making a PLT entry for this
7169              symbol, and in an executable we'd normally resolve
7170              relocations against this symbol to the PLT entry.  Allow
7171              dynamic relocs if the reference is weak, and the dynamic
7172              relocs will not cause text relocation.  */
7173           else if (!h->ref_regular_nonweak
7174                    && h->non_got_ref
7175                    && h->type != STT_GNU_IFUNC
7176                    && !readonly_dynrelocs (h))
7177             h->non_got_ref = 0;
7178
7179           /* If making a plt entry, then we don't need copy relocs.  */
7180           return TRUE;
7181         }
7182     }
7183   else
7184     h->plt.plist = NULL;
7185
7186   /* If this is a weak symbol, and there is a real definition, the
7187      processor independent code will have arranged for us to see the
7188      real definition first, and we can just use the same value.  */
7189   if (h->u.weakdef != NULL)
7190     {
7191       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
7192                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
7193       h->root.u.def.section = h->u.weakdef->root.u.def.section;
7194       h->root.u.def.value = h->u.weakdef->root.u.def.value;
7195       if (ELIMINATE_COPY_RELOCS)
7196         h->non_got_ref = h->u.weakdef->non_got_ref;
7197       return TRUE;
7198     }
7199
7200   /* If we are creating a shared library, we must presume that the
7201      only references to the symbol are via the global offset table.
7202      For such cases we need not do anything here; the relocations will
7203      be handled correctly by relocate_section.  */
7204   if (bfd_link_pic (info))
7205     return TRUE;
7206
7207   /* If there are no references to this symbol that do not use the
7208      GOT, we don't need to generate a copy reloc.  */
7209   if (!h->non_got_ref)
7210     return TRUE;
7211
7212   /* Don't generate a copy reloc for symbols defined in the executable.  */
7213   if (!h->def_dynamic || !h->ref_regular || h->def_regular)
7214     return TRUE;
7215
7216   /* If -z nocopyreloc was given, don't generate them either.  */
7217   if (info->nocopyreloc)
7218     {
7219       h->non_got_ref = 0;
7220       return TRUE;
7221     }
7222
7223   /* If we didn't find any dynamic relocs in read-only sections, then
7224      we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
7225   if (ELIMINATE_COPY_RELOCS && !readonly_dynrelocs (h))
7226     {
7227       h->non_got_ref = 0;
7228       return TRUE;
7229     }
7230
7231   /* Protected variables do not work with .dynbss.  The copy in
7232      .dynbss won't be used by the shared library with the protected
7233      definition for the variable.  Text relocations are preferable
7234      to an incorrect program.  */
7235   if (h->protected_def)
7236     {
7237       h->non_got_ref = 0;
7238       return TRUE;
7239     }
7240
7241   if (h->plt.plist != NULL)
7242     {
7243       /* We should never get here, but unfortunately there are versions
7244          of gcc out there that improperly (for this ABI) put initialized
7245          function pointers, vtable refs and suchlike in read-only
7246          sections.  Allow them to proceed, but warn that this might
7247          break at runtime.  */
7248       info->callbacks->einfo
7249         (_("%P: copy reloc against `%T' requires lazy plt linking; "
7250            "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7251          h->root.root.string);
7252     }
7253
7254   /* This is a reference to a symbol defined by a dynamic object which
7255      is not a function.  */
7256
7257   /* We must allocate the symbol in our .dynbss section, which will
7258      become part of the .bss section of the executable.  There will be
7259      an entry for this symbol in the .dynsym section.  The dynamic
7260      object will contain position independent code, so all references
7261      from the dynamic object to this symbol will go through the global
7262      offset table.  The dynamic linker will use the .dynsym entry to
7263      determine the address it must put in the global offset table, so
7264      both the dynamic object and the regular object will refer to the
7265      same memory location for the variable.  */
7266
7267   /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
7268      to copy the initial value out of the dynamic object and into the
7269      runtime process image.  We need to remember the offset into the
7270      .rela.bss section we are going to use.  */
7271   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7272     {
7273       htab->relbss->size += sizeof (Elf64_External_Rela);
7274       h->needs_copy = 1;
7275     }
7276
7277   s = htab->dynbss;
7278
7279   return _bfd_elf_adjust_dynamic_copy (info, h, s);
7280 }
7281
7282 /* If given a function descriptor symbol, hide both the function code
7283    sym and the descriptor.  */
7284 static void
7285 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7286                        struct elf_link_hash_entry *h,
7287                        bfd_boolean force_local)
7288 {
7289   struct ppc_link_hash_entry *eh;
7290   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7291
7292   eh = (struct ppc_link_hash_entry *) h;
7293   if (eh->is_func_descriptor)
7294     {
7295       struct ppc_link_hash_entry *fh = eh->oh;
7296
7297       if (fh == NULL)
7298         {
7299           const char *p, *q;
7300           struct ppc_link_hash_table *htab;
7301           char save;
7302
7303           /* We aren't supposed to use alloca in BFD because on
7304              systems which do not have alloca the version in libiberty
7305              calls xmalloc, which might cause the program to crash
7306              when it runs out of memory.  This function doesn't have a
7307              return status, so there's no way to gracefully return an
7308              error.  So cheat.  We know that string[-1] can be safely
7309              accessed;  It's either a string in an ELF string table,
7310              or allocated in an objalloc structure.  */
7311
7312           p = eh->elf.root.root.string - 1;
7313           save = *p;
7314           *(char *) p = '.';
7315           htab = ppc_hash_table (info);
7316           if (htab == NULL)
7317             return;
7318
7319           fh = (struct ppc_link_hash_entry *)
7320             elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7321           *(char *) p = save;
7322
7323           /* Unfortunately, if it so happens that the string we were
7324              looking for was allocated immediately before this string,
7325              then we overwrote the string terminator.  That's the only
7326              reason the lookup should fail.  */
7327           if (fh == NULL)
7328             {
7329               q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7330               while (q >= eh->elf.root.root.string && *q == *p)
7331                 --q, --p;
7332               if (q < eh->elf.root.root.string && *p == '.')
7333                 fh = (struct ppc_link_hash_entry *)
7334                   elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7335             }
7336           if (fh != NULL)
7337             {
7338               eh->oh = fh;
7339               fh->oh = eh;
7340             }
7341         }
7342       if (fh != NULL)
7343         _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7344     }
7345 }
7346
7347 static bfd_boolean
7348 get_sym_h (struct elf_link_hash_entry **hp,
7349            Elf_Internal_Sym **symp,
7350            asection **symsecp,
7351            unsigned char **tls_maskp,
7352            Elf_Internal_Sym **locsymsp,
7353            unsigned long r_symndx,
7354            bfd *ibfd)
7355 {
7356   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7357
7358   if (r_symndx >= symtab_hdr->sh_info)
7359     {
7360       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7361       struct elf_link_hash_entry *h;
7362
7363       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7364       h = elf_follow_link (h);
7365
7366       if (hp != NULL)
7367         *hp = h;
7368
7369       if (symp != NULL)
7370         *symp = NULL;
7371
7372       if (symsecp != NULL)
7373         {
7374           asection *symsec = NULL;
7375           if (h->root.type == bfd_link_hash_defined
7376               || h->root.type == bfd_link_hash_defweak)
7377             symsec = h->root.u.def.section;
7378           *symsecp = symsec;
7379         }
7380
7381       if (tls_maskp != NULL)
7382         {
7383           struct ppc_link_hash_entry *eh;
7384
7385           eh = (struct ppc_link_hash_entry *) h;
7386           *tls_maskp = &eh->tls_mask;
7387         }
7388     }
7389   else
7390     {
7391       Elf_Internal_Sym *sym;
7392       Elf_Internal_Sym *locsyms = *locsymsp;
7393
7394       if (locsyms == NULL)
7395         {
7396           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7397           if (locsyms == NULL)
7398             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7399                                             symtab_hdr->sh_info,
7400                                             0, NULL, NULL, NULL);
7401           if (locsyms == NULL)
7402             return FALSE;
7403           *locsymsp = locsyms;
7404         }
7405       sym = locsyms + r_symndx;
7406
7407       if (hp != NULL)
7408         *hp = NULL;
7409
7410       if (symp != NULL)
7411         *symp = sym;
7412
7413       if (symsecp != NULL)
7414         *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7415
7416       if (tls_maskp != NULL)
7417         {
7418           struct got_entry **lgot_ents;
7419           unsigned char *tls_mask;
7420
7421           tls_mask = NULL;
7422           lgot_ents = elf_local_got_ents (ibfd);
7423           if (lgot_ents != NULL)
7424             {
7425               struct plt_entry **local_plt = (struct plt_entry **)
7426                 (lgot_ents + symtab_hdr->sh_info);
7427               unsigned char *lgot_masks = (unsigned char *)
7428                 (local_plt + symtab_hdr->sh_info);
7429               tls_mask = &lgot_masks[r_symndx];
7430             }
7431           *tls_maskp = tls_mask;
7432         }
7433     }
7434   return TRUE;
7435 }
7436
7437 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
7438    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7439    type suitable for optimization, and 1 otherwise.  */
7440
7441 static int
7442 get_tls_mask (unsigned char **tls_maskp,
7443               unsigned long *toc_symndx,
7444               bfd_vma *toc_addend,
7445               Elf_Internal_Sym **locsymsp,
7446               const Elf_Internal_Rela *rel,
7447               bfd *ibfd)
7448 {
7449   unsigned long r_symndx;
7450   int next_r;
7451   struct elf_link_hash_entry *h;
7452   Elf_Internal_Sym *sym;
7453   asection *sec;
7454   bfd_vma off;
7455
7456   r_symndx = ELF64_R_SYM (rel->r_info);
7457   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7458     return 0;
7459
7460   if ((*tls_maskp != NULL && **tls_maskp != 0)
7461       || sec == NULL
7462       || ppc64_elf_section_data (sec) == NULL
7463       || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7464     return 1;
7465
7466   /* Look inside a TOC section too.  */
7467   if (h != NULL)
7468     {
7469       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7470       off = h->root.u.def.value;
7471     }
7472   else
7473     off = sym->st_value;
7474   off += rel->r_addend;
7475   BFD_ASSERT (off % 8 == 0);
7476   r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7477   next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7478   if (toc_symndx != NULL)
7479     *toc_symndx = r_symndx;
7480   if (toc_addend != NULL)
7481     *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7482   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7483     return 0;
7484   if ((h == NULL || is_static_defined (h))
7485       && (next_r == -1 || next_r == -2))
7486     return 1 - next_r;
7487   return 1;
7488 }
7489
7490 /* Find (or create) an entry in the tocsave hash table.  */
7491
7492 static struct tocsave_entry *
7493 tocsave_find (struct ppc_link_hash_table *htab,
7494               enum insert_option insert,
7495               Elf_Internal_Sym **local_syms,
7496               const Elf_Internal_Rela *irela,
7497               bfd *ibfd)
7498 {
7499   unsigned long r_indx;
7500   struct elf_link_hash_entry *h;
7501   Elf_Internal_Sym *sym;
7502   struct tocsave_entry ent, *p;
7503   hashval_t hash;
7504   struct tocsave_entry **slot;
7505
7506   r_indx = ELF64_R_SYM (irela->r_info);
7507   if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7508     return NULL;
7509   if (ent.sec == NULL || ent.sec->output_section == NULL)
7510     {
7511       (*_bfd_error_handler)
7512         (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"));
7513       return NULL;
7514     }
7515
7516   if (h != NULL)
7517     ent.offset = h->root.u.def.value;
7518   else
7519     ent.offset = sym->st_value;
7520   ent.offset += irela->r_addend;
7521
7522   hash = tocsave_htab_hash (&ent);
7523   slot = ((struct tocsave_entry **)
7524           htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7525   if (slot == NULL)
7526     return NULL;
7527
7528   if (*slot == NULL)
7529     {
7530       p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7531       if (p == NULL)
7532         return NULL;
7533       *p = ent;
7534       *slot = p;
7535     }
7536   return *slot;
7537 }
7538
7539 /* Adjust all global syms defined in opd sections.  In gcc generated
7540    code for the old ABI, these will already have been done.  */
7541
7542 static bfd_boolean
7543 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7544 {
7545   struct ppc_link_hash_entry *eh;
7546   asection *sym_sec;
7547   struct _opd_sec_data *opd;
7548
7549   if (h->root.type == bfd_link_hash_indirect)
7550     return TRUE;
7551
7552   if (h->root.type != bfd_link_hash_defined
7553       && h->root.type != bfd_link_hash_defweak)
7554     return TRUE;
7555
7556   eh = (struct ppc_link_hash_entry *) h;
7557   if (eh->adjust_done)
7558     return TRUE;
7559
7560   sym_sec = eh->elf.root.u.def.section;
7561   opd = get_opd_info (sym_sec);
7562   if (opd != NULL && opd->adjust != NULL)
7563     {
7564       long adjust = opd->adjust[OPD_NDX (eh->elf.root.u.def.value)];
7565       if (adjust == -1)
7566         {
7567           /* This entry has been deleted.  */
7568           asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7569           if (dsec == NULL)
7570             {
7571               for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7572                 if (discarded_section (dsec))
7573                   {
7574                     ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7575                     break;
7576                   }
7577             }
7578           eh->elf.root.u.def.value = 0;
7579           eh->elf.root.u.def.section = dsec;
7580         }
7581       else
7582         eh->elf.root.u.def.value += adjust;
7583       eh->adjust_done = 1;
7584     }
7585   return TRUE;
7586 }
7587
7588 /* Handles decrementing dynamic reloc counts for the reloc specified by
7589    R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM
7590    have already been determined.  */
7591
7592 static bfd_boolean
7593 dec_dynrel_count (bfd_vma r_info,
7594                   asection *sec,
7595                   struct bfd_link_info *info,
7596                   Elf_Internal_Sym **local_syms,
7597                   struct elf_link_hash_entry *h,
7598                   Elf_Internal_Sym *sym)
7599 {
7600   enum elf_ppc64_reloc_type r_type;
7601   asection *sym_sec = NULL;
7602
7603   /* Can this reloc be dynamic?  This switch, and later tests here
7604      should be kept in sync with the code in check_relocs.  */
7605   r_type = ELF64_R_TYPE (r_info);
7606   switch (r_type)
7607     {
7608     default:
7609       return TRUE;
7610
7611     case R_PPC64_TPREL16:
7612     case R_PPC64_TPREL16_LO:
7613     case R_PPC64_TPREL16_HI:
7614     case R_PPC64_TPREL16_HA:
7615     case R_PPC64_TPREL16_DS:
7616     case R_PPC64_TPREL16_LO_DS:
7617     case R_PPC64_TPREL16_HIGH:
7618     case R_PPC64_TPREL16_HIGHA:
7619     case R_PPC64_TPREL16_HIGHER:
7620     case R_PPC64_TPREL16_HIGHERA:
7621     case R_PPC64_TPREL16_HIGHEST:
7622     case R_PPC64_TPREL16_HIGHESTA:
7623       if (!bfd_link_pic (info))
7624         return TRUE;
7625
7626     case R_PPC64_TPREL64:
7627     case R_PPC64_DTPMOD64:
7628     case R_PPC64_DTPREL64:
7629     case R_PPC64_ADDR64:
7630     case R_PPC64_REL30:
7631     case R_PPC64_REL32:
7632     case R_PPC64_REL64:
7633     case R_PPC64_ADDR14:
7634     case R_PPC64_ADDR14_BRNTAKEN:
7635     case R_PPC64_ADDR14_BRTAKEN:
7636     case R_PPC64_ADDR16:
7637     case R_PPC64_ADDR16_DS:
7638     case R_PPC64_ADDR16_HA:
7639     case R_PPC64_ADDR16_HI:
7640     case R_PPC64_ADDR16_HIGH:
7641     case R_PPC64_ADDR16_HIGHA:
7642     case R_PPC64_ADDR16_HIGHER:
7643     case R_PPC64_ADDR16_HIGHERA:
7644     case R_PPC64_ADDR16_HIGHEST:
7645     case R_PPC64_ADDR16_HIGHESTA:
7646     case R_PPC64_ADDR16_LO:
7647     case R_PPC64_ADDR16_LO_DS:
7648     case R_PPC64_ADDR24:
7649     case R_PPC64_ADDR32:
7650     case R_PPC64_UADDR16:
7651     case R_PPC64_UADDR32:
7652     case R_PPC64_UADDR64:
7653     case R_PPC64_TOC:
7654       break;
7655     }
7656
7657   if (local_syms != NULL)
7658     {
7659       unsigned long r_symndx;
7660       bfd *ibfd = sec->owner;
7661
7662       r_symndx = ELF64_R_SYM (r_info);
7663       if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7664         return FALSE;
7665     }
7666
7667   if ((bfd_link_pic (info)
7668        && (must_be_dyn_reloc (info, r_type)
7669            || (h != NULL
7670                && (!SYMBOLIC_BIND (info, h)
7671                    || h->root.type == bfd_link_hash_defweak
7672                    || !h->def_regular))))
7673       || (ELIMINATE_COPY_RELOCS
7674           && !bfd_link_pic (info)
7675           && h != NULL
7676           && (h->root.type == bfd_link_hash_defweak
7677               || !h->def_regular)))
7678     ;
7679   else
7680     return TRUE;
7681
7682   if (h != NULL)
7683     {
7684       struct elf_dyn_relocs *p;
7685       struct elf_dyn_relocs **pp;
7686       pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7687
7688       /* elf_gc_sweep may have already removed all dyn relocs associated
7689          with local syms for a given section.  Also, symbol flags are
7690          changed by elf_gc_sweep_symbol, confusing the test above.  Don't
7691          report a dynreloc miscount.  */
7692       if (*pp == NULL && info->gc_sections)
7693         return TRUE;
7694
7695       while ((p = *pp) != NULL)
7696         {
7697           if (p->sec == sec)
7698             {
7699               if (!must_be_dyn_reloc (info, r_type))
7700                 p->pc_count -= 1;
7701               p->count -= 1;
7702               if (p->count == 0)
7703                 *pp = p->next;
7704               return TRUE;
7705             }
7706           pp = &p->next;
7707         }
7708     }
7709   else
7710     {
7711       struct ppc_dyn_relocs *p;
7712       struct ppc_dyn_relocs **pp;
7713       void *vpp;
7714       bfd_boolean is_ifunc;
7715
7716       if (local_syms == NULL)
7717         sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7718       if (sym_sec == NULL)
7719         sym_sec = sec;
7720
7721       vpp = &elf_section_data (sym_sec)->local_dynrel;
7722       pp = (struct ppc_dyn_relocs **) vpp;
7723
7724       if (*pp == NULL && info->gc_sections)
7725         return TRUE;
7726
7727       is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7728       while ((p = *pp) != NULL)
7729         {
7730           if (p->sec == sec && p->ifunc == is_ifunc)
7731             {
7732               p->count -= 1;
7733               if (p->count == 0)
7734                 *pp = p->next;
7735               return TRUE;
7736             }
7737           pp = &p->next;
7738         }
7739     }
7740
7741   info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7742                           sec->owner, sec);
7743   bfd_set_error (bfd_error_bad_value);
7744   return FALSE;
7745 }
7746
7747 /* Remove unused Official Procedure Descriptor entries.  Currently we
7748    only remove those associated with functions in discarded link-once
7749    sections, or weakly defined functions that have been overridden.  It
7750    would be possible to remove many more entries for statically linked
7751    applications.  */
7752
7753 bfd_boolean
7754 ppc64_elf_edit_opd (struct bfd_link_info *info)
7755 {
7756   bfd *ibfd;
7757   bfd_boolean some_edited = FALSE;
7758   asection *need_pad = NULL;
7759   struct ppc_link_hash_table *htab;
7760
7761   htab = ppc_hash_table (info);
7762   if (htab == NULL)
7763     return FALSE;
7764
7765   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
7766     {
7767       asection *sec;
7768       Elf_Internal_Rela *relstart, *rel, *relend;
7769       Elf_Internal_Shdr *symtab_hdr;
7770       Elf_Internal_Sym *local_syms;
7771       struct _opd_sec_data *opd;
7772       bfd_boolean need_edit, add_aux_fields, broken;
7773       bfd_size_type cnt_16b = 0;
7774
7775       if (!is_ppc64_elf (ibfd))
7776         continue;
7777
7778       sec = bfd_get_section_by_name (ibfd, ".opd");
7779       if (sec == NULL || sec->size == 0)
7780         continue;
7781
7782       if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7783         continue;
7784
7785       if (sec->output_section == bfd_abs_section_ptr)
7786         continue;
7787
7788       /* Look through the section relocs.  */
7789       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7790         continue;
7791
7792       local_syms = NULL;
7793       symtab_hdr = &elf_symtab_hdr (ibfd);
7794
7795       /* Read the relocations.  */
7796       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7797                                             info->keep_memory);
7798       if (relstart == NULL)
7799         return FALSE;
7800
7801       /* First run through the relocs to check they are sane, and to
7802          determine whether we need to edit this opd section.  */
7803       need_edit = FALSE;
7804       broken = FALSE;
7805       need_pad = sec;
7806       relend = relstart + sec->reloc_count;
7807       for (rel = relstart; rel < relend; )
7808         {
7809           enum elf_ppc64_reloc_type r_type;
7810           unsigned long r_symndx;
7811           asection *sym_sec;
7812           struct elf_link_hash_entry *h;
7813           Elf_Internal_Sym *sym;
7814           bfd_vma offset;
7815
7816           /* .opd contains an array of 16 or 24 byte entries.  We're
7817              only interested in the reloc pointing to a function entry
7818              point.  */
7819           offset = rel->r_offset;
7820           if (rel + 1 == relend
7821               || rel[1].r_offset != offset + 8)
7822             {
7823               /* If someone messes with .opd alignment then after a
7824                  "ld -r" we might have padding in the middle of .opd.
7825                  Also, there's nothing to prevent someone putting
7826                  something silly in .opd with the assembler.  No .opd
7827                  optimization for them!  */
7828             broken_opd:
7829               (*_bfd_error_handler)
7830                 (_("%B: .opd is not a regular array of opd entries"), ibfd);
7831               broken = TRUE;
7832               break;
7833             }
7834
7835           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7836               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7837             {
7838               (*_bfd_error_handler)
7839                 (_("%B: unexpected reloc type %u in .opd section"),
7840                  ibfd, r_type);
7841               broken = TRUE;
7842               break;
7843             }
7844
7845           r_symndx = ELF64_R_SYM (rel->r_info);
7846           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7847                           r_symndx, ibfd))
7848             goto error_ret;
7849
7850           if (sym_sec == NULL || sym_sec->owner == NULL)
7851             {
7852               const char *sym_name;
7853               if (h != NULL)
7854                 sym_name = h->root.root.string;
7855               else
7856                 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7857                                              sym_sec);
7858
7859               (*_bfd_error_handler)
7860                 (_("%B: undefined sym `%s' in .opd section"),
7861                  ibfd, sym_name);
7862               broken = TRUE;
7863               break;
7864             }
7865
7866           /* opd entries are always for functions defined in the
7867              current input bfd.  If the symbol isn't defined in the
7868              input bfd, then we won't be using the function in this
7869              bfd;  It must be defined in a linkonce section in another
7870              bfd, or is weak.  It's also possible that we are
7871              discarding the function due to a linker script /DISCARD/,
7872              which we test for via the output_section.  */
7873           if (sym_sec->owner != ibfd
7874               || sym_sec->output_section == bfd_abs_section_ptr)
7875             need_edit = TRUE;
7876
7877           rel += 2;
7878           if (rel + 1 == relend
7879               || (rel + 2 < relend
7880                   && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC))
7881             ++rel;
7882
7883           if (rel == relend)
7884             {
7885               if (sec->size == offset + 24)
7886                 {
7887                   need_pad = NULL;
7888                   break;
7889                 }
7890               if (sec->size == offset + 16)
7891                 {
7892                   cnt_16b++;
7893                   break;
7894                 }
7895               goto broken_opd;
7896             }
7897           else if (rel + 1 < relend
7898                    && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7899                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7900             {
7901               if (rel[0].r_offset == offset + 16)
7902                 cnt_16b++;
7903               else if (rel[0].r_offset != offset + 24)
7904                 goto broken_opd;
7905             }
7906           else
7907             goto broken_opd;
7908         }
7909
7910       add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
7911
7912       if (!broken && (need_edit || add_aux_fields))
7913         {
7914           Elf_Internal_Rela *write_rel;
7915           Elf_Internal_Shdr *rel_hdr;
7916           bfd_byte *rptr, *wptr;
7917           bfd_byte *new_contents;
7918           bfd_size_type amt;
7919
7920           new_contents = NULL;
7921           amt = OPD_NDX (sec->size) * sizeof (long);
7922           opd = &ppc64_elf_section_data (sec)->u.opd;
7923           opd->adjust = bfd_zalloc (sec->owner, amt);
7924           if (opd->adjust == NULL)
7925             return FALSE;
7926           ppc64_elf_section_data (sec)->sec_type = sec_opd;
7927
7928           /* This seems a waste of time as input .opd sections are all
7929              zeros as generated by gcc, but I suppose there's no reason
7930              this will always be so.  We might start putting something in
7931              the third word of .opd entries.  */
7932           if ((sec->flags & SEC_IN_MEMORY) == 0)
7933             {
7934               bfd_byte *loc;
7935               if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7936                 {
7937                   if (loc != NULL)
7938                     free (loc);
7939                 error_ret:
7940                   if (local_syms != NULL
7941                       && symtab_hdr->contents != (unsigned char *) local_syms)
7942                     free (local_syms);
7943                   if (elf_section_data (sec)->relocs != relstart)
7944                     free (relstart);
7945                   return FALSE;
7946                 }
7947               sec->contents = loc;
7948               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7949             }
7950
7951           elf_section_data (sec)->relocs = relstart;
7952
7953           new_contents = sec->contents;
7954           if (add_aux_fields)
7955             {
7956               new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7957               if (new_contents == NULL)
7958                 return FALSE;
7959               need_pad = NULL;
7960             }
7961           wptr = new_contents;
7962           rptr = sec->contents;
7963           write_rel = relstart;
7964           for (rel = relstart; rel < relend; )
7965             {
7966               unsigned long r_symndx;
7967               asection *sym_sec;
7968               struct elf_link_hash_entry *h;
7969               struct ppc_link_hash_entry *fdh = NULL;
7970               Elf_Internal_Sym *sym;
7971               long opd_ent_size;
7972               Elf_Internal_Rela *next_rel;
7973               bfd_boolean skip;
7974
7975               r_symndx = ELF64_R_SYM (rel->r_info);
7976               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7977                               r_symndx, ibfd))
7978                 goto error_ret;
7979
7980               next_rel = rel + 2;
7981               if (next_rel + 1 == relend
7982                   || (next_rel + 2 < relend
7983                       && ELF64_R_TYPE (next_rel[2].r_info) == R_PPC64_TOC))
7984                 ++next_rel;
7985
7986               /* See if the .opd entry is full 24 byte or
7987                  16 byte (with fd_aux entry overlapped with next
7988                  fd_func).  */
7989               opd_ent_size = 24;
7990               if (next_rel == relend)
7991                 {
7992                   if (sec->size == rel->r_offset + 16)
7993                     opd_ent_size = 16;
7994                 }
7995               else if (next_rel->r_offset == rel->r_offset + 16)
7996                 opd_ent_size = 16;
7997
7998               if (h != NULL
7999                   && h->root.root.string[0] == '.')
8000                 {
8001                   fdh = lookup_fdh ((struct ppc_link_hash_entry *) h, htab);
8002                   if (fdh != NULL
8003                       && fdh->elf.root.type != bfd_link_hash_defined
8004                       && fdh->elf.root.type != bfd_link_hash_defweak)
8005                     fdh = NULL;
8006                 }
8007
8008               skip = (sym_sec->owner != ibfd
8009                       || sym_sec->output_section == bfd_abs_section_ptr);
8010               if (skip)
8011                 {
8012                   if (fdh != NULL && sym_sec->owner == ibfd)
8013                     {
8014                       /* Arrange for the function descriptor sym
8015                          to be dropped.  */
8016                       fdh->elf.root.u.def.value = 0;
8017                       fdh->elf.root.u.def.section = sym_sec;
8018                     }
8019                   opd->adjust[OPD_NDX (rel->r_offset)] = -1;
8020
8021                   if (NO_OPD_RELOCS || bfd_link_relocatable (info))
8022                     rel = next_rel;
8023                   else
8024                     while (1)
8025                       {
8026                         if (!dec_dynrel_count (rel->r_info, sec, info,
8027                                                NULL, h, sym))
8028                           goto error_ret;
8029
8030                         if (++rel == next_rel)
8031                           break;
8032
8033                         r_symndx = ELF64_R_SYM (rel->r_info);
8034                         if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8035                                         r_symndx, ibfd))
8036                           goto error_ret;
8037                       }
8038                 }
8039               else
8040                 {
8041                   /* We'll be keeping this opd entry.  */
8042                   long adjust;
8043
8044                   if (fdh != NULL)
8045                     {
8046                       /* Redefine the function descriptor symbol to
8047                          this location in the opd section.  It is
8048                          necessary to update the value here rather
8049                          than using an array of adjustments as we do
8050                          for local symbols, because various places
8051                          in the generic ELF code use the value
8052                          stored in u.def.value.  */
8053                       fdh->elf.root.u.def.value = wptr - new_contents;
8054                       fdh->adjust_done = 1;
8055                     }
8056
8057                   /* Local syms are a bit tricky.  We could
8058                      tweak them as they can be cached, but
8059                      we'd need to look through the local syms
8060                      for the function descriptor sym which we
8061                      don't have at the moment.  So keep an
8062                      array of adjustments.  */
8063                   adjust = (wptr - new_contents) - (rptr - sec->contents);
8064                   opd->adjust[OPD_NDX (rel->r_offset)] = adjust;
8065
8066                   if (wptr != rptr)
8067                     memcpy (wptr, rptr, opd_ent_size);
8068                   wptr += opd_ent_size;
8069                   if (add_aux_fields && opd_ent_size == 16)
8070                     {
8071                       memset (wptr, '\0', 8);
8072                       wptr += 8;
8073                     }
8074
8075                   /* We need to adjust any reloc offsets to point to the
8076                      new opd entries.  */
8077                   for ( ; rel != next_rel; ++rel)
8078                     {
8079                       rel->r_offset += adjust;
8080                       if (write_rel != rel)
8081                         memcpy (write_rel, rel, sizeof (*rel));
8082                       ++write_rel;
8083                     }
8084                 }
8085
8086               rptr += opd_ent_size;
8087             }
8088
8089           sec->size = wptr - new_contents;
8090           sec->reloc_count = write_rel - relstart;
8091           if (add_aux_fields)
8092             {
8093               free (sec->contents);
8094               sec->contents = new_contents;
8095             }
8096
8097           /* Fudge the header size too, as this is used later in
8098              elf_bfd_final_link if we are emitting relocs.  */
8099           rel_hdr = _bfd_elf_single_rel_hdr (sec);
8100           rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
8101           some_edited = TRUE;
8102         }
8103       else if (elf_section_data (sec)->relocs != relstart)
8104         free (relstart);
8105
8106       if (local_syms != NULL
8107           && symtab_hdr->contents != (unsigned char *) local_syms)
8108         {
8109           if (!info->keep_memory)
8110             free (local_syms);
8111           else
8112             symtab_hdr->contents = (unsigned char *) local_syms;
8113         }
8114     }
8115
8116   if (some_edited)
8117     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
8118
8119   /* If we are doing a final link and the last .opd entry is just 16 byte
8120      long, add a 8 byte padding after it.  */
8121   if (need_pad != NULL && !bfd_link_relocatable (info))
8122     {
8123       bfd_byte *p;
8124
8125       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
8126         {
8127           BFD_ASSERT (need_pad->size > 0);
8128
8129           p = bfd_malloc (need_pad->size + 8);
8130           if (p == NULL)
8131             return FALSE;
8132
8133           if (! bfd_get_section_contents (need_pad->owner, need_pad,
8134                                           p, 0, need_pad->size))
8135             return FALSE;
8136
8137           need_pad->contents = p;
8138           need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8139         }
8140       else
8141         {
8142           p = bfd_realloc (need_pad->contents, need_pad->size + 8);
8143           if (p == NULL)
8144             return FALSE;
8145
8146           need_pad->contents = p;
8147         }
8148
8149       memset (need_pad->contents + need_pad->size, 0, 8);
8150       need_pad->size += 8;
8151     }
8152
8153   return TRUE;
8154 }
8155
8156 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
8157
8158 asection *
8159 ppc64_elf_tls_setup (struct bfd_link_info *info)
8160 {
8161   struct ppc_link_hash_table *htab;
8162
8163   htab = ppc_hash_table (info);
8164   if (htab == NULL)
8165     return NULL;
8166
8167   if (abiversion (info->output_bfd) == 1)
8168     htab->opd_abi = 1;
8169
8170   if (htab->params->no_multi_toc)
8171     htab->do_multi_toc = 0;
8172   else if (!htab->do_multi_toc)
8173     htab->params->no_multi_toc = 1;
8174
8175   htab->tls_get_addr = ((struct ppc_link_hash_entry *)
8176                         elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
8177                                               FALSE, FALSE, TRUE));
8178   /* Move dynamic linking info to the function descriptor sym.  */
8179   if (htab->tls_get_addr != NULL)
8180     func_desc_adjust (&htab->tls_get_addr->elf, info);
8181   htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
8182                            elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
8183                                                  FALSE, FALSE, TRUE));
8184   if (htab->params->tls_get_addr_opt)
8185     {
8186       struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
8187
8188       opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
8189                                   FALSE, FALSE, TRUE);
8190       if (opt != NULL)
8191         func_desc_adjust (opt, info);
8192       opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
8193                                      FALSE, FALSE, TRUE);
8194       if (opt_fd != NULL
8195           && (opt_fd->root.type == bfd_link_hash_defined
8196               || opt_fd->root.type == bfd_link_hash_defweak))
8197         {
8198           /* If glibc supports an optimized __tls_get_addr call stub,
8199              signalled by the presence of __tls_get_addr_opt, and we'll
8200              be calling __tls_get_addr via a plt call stub, then
8201              make __tls_get_addr point to __tls_get_addr_opt.  */
8202           tga_fd = &htab->tls_get_addr_fd->elf;
8203           if (htab->elf.dynamic_sections_created
8204               && tga_fd != NULL
8205               && (tga_fd->type == STT_FUNC
8206                   || tga_fd->needs_plt)
8207               && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
8208                    || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
8209                        && tga_fd->root.type == bfd_link_hash_undefweak)))
8210             {
8211               struct plt_entry *ent;
8212
8213               for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
8214                 if (ent->plt.refcount > 0)
8215                   break;
8216               if (ent != NULL)
8217                 {
8218                   tga_fd->root.type = bfd_link_hash_indirect;
8219                   tga_fd->root.u.i.link = &opt_fd->root;
8220                   ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
8221                   if (opt_fd->dynindx != -1)
8222                     {
8223                       /* Use __tls_get_addr_opt in dynamic relocations.  */
8224                       opt_fd->dynindx = -1;
8225                       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8226                                               opt_fd->dynstr_index);
8227                       if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8228                         return NULL;
8229                     }
8230                   htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8231                   tga = &htab->tls_get_addr->elf;
8232                   if (opt != NULL && tga != NULL)
8233                     {
8234                       tga->root.type = bfd_link_hash_indirect;
8235                       tga->root.u.i.link = &opt->root;
8236                       ppc64_elf_copy_indirect_symbol (info, opt, tga);
8237                       _bfd_elf_link_hash_hide_symbol (info, opt,
8238                                                       tga->forced_local);
8239                       htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8240                     }
8241                   htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8242                   htab->tls_get_addr_fd->is_func_descriptor = 1;
8243                   if (htab->tls_get_addr != NULL)
8244                     {
8245                       htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8246                       htab->tls_get_addr->is_func = 1;
8247                     }
8248                 }
8249             }
8250         }
8251       else if (htab->params->tls_get_addr_opt < 0)
8252         htab->params->tls_get_addr_opt = 0;
8253     }
8254   return _bfd_elf_tls_setup (info->output_bfd, info);
8255 }
8256
8257 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8258    HASH1 or HASH2.  */
8259
8260 static bfd_boolean
8261 branch_reloc_hash_match (const bfd *ibfd,
8262                          const Elf_Internal_Rela *rel,
8263                          const struct ppc_link_hash_entry *hash1,
8264                          const struct ppc_link_hash_entry *hash2)
8265 {
8266   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8267   enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8268   unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8269
8270   if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8271     {
8272       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8273       struct elf_link_hash_entry *h;
8274
8275       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8276       h = elf_follow_link (h);
8277       if (h == &hash1->elf || h == &hash2->elf)
8278         return TRUE;
8279     }
8280   return FALSE;
8281 }
8282
8283 /* Run through all the TLS relocs looking for optimization
8284    opportunities.  The linker has been hacked (see ppc64elf.em) to do
8285    a preliminary section layout so that we know the TLS segment
8286    offsets.  We can't optimize earlier because some optimizations need
8287    to know the tp offset, and we need to optimize before allocating
8288    dynamic relocations.  */
8289
8290 bfd_boolean
8291 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8292 {
8293   bfd *ibfd;
8294   asection *sec;
8295   struct ppc_link_hash_table *htab;
8296   unsigned char *toc_ref;
8297   int pass;
8298
8299   if (!bfd_link_executable (info))
8300     return TRUE;
8301
8302   htab = ppc_hash_table (info);
8303   if (htab == NULL)
8304     return FALSE;
8305
8306   /* Make two passes over the relocs.  On the first pass, mark toc
8307      entries involved with tls relocs, and check that tls relocs
8308      involved in setting up a tls_get_addr call are indeed followed by
8309      such a call.  If they are not, we can't do any tls optimization.
8310      On the second pass twiddle tls_mask flags to notify
8311      relocate_section that optimization can be done, and adjust got
8312      and plt refcounts.  */
8313   toc_ref = NULL;
8314   for (pass = 0; pass < 2; ++pass)
8315     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8316       {
8317         Elf_Internal_Sym *locsyms = NULL;
8318         asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8319
8320         for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8321           if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8322             {
8323               Elf_Internal_Rela *relstart, *rel, *relend;
8324               bfd_boolean found_tls_get_addr_arg = 0;
8325
8326               /* Read the relocations.  */
8327               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8328                                                     info->keep_memory);
8329               if (relstart == NULL)
8330                 {
8331                   free (toc_ref);
8332                   return FALSE;
8333                 }
8334
8335               relend = relstart + sec->reloc_count;
8336               for (rel = relstart; rel < relend; rel++)
8337                 {
8338                   enum elf_ppc64_reloc_type r_type;
8339                   unsigned long r_symndx;
8340                   struct elf_link_hash_entry *h;
8341                   Elf_Internal_Sym *sym;
8342                   asection *sym_sec;
8343                   unsigned char *tls_mask;
8344                   unsigned char tls_set, tls_clear, tls_type = 0;
8345                   bfd_vma value;
8346                   bfd_boolean ok_tprel, is_local;
8347                   long toc_ref_index = 0;
8348                   int expecting_tls_get_addr = 0;
8349                   bfd_boolean ret = FALSE;
8350
8351                   r_symndx = ELF64_R_SYM (rel->r_info);
8352                   if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8353                                   r_symndx, ibfd))
8354                     {
8355                     err_free_rel:
8356                       if (elf_section_data (sec)->relocs != relstart)
8357                         free (relstart);
8358                       if (toc_ref != NULL)
8359                         free (toc_ref);
8360                       if (locsyms != NULL
8361                           && (elf_symtab_hdr (ibfd).contents
8362                               != (unsigned char *) locsyms))
8363                         free (locsyms);
8364                       return ret;
8365                     }
8366
8367                   if (h != NULL)
8368                     {
8369                       if (h->root.type == bfd_link_hash_defined
8370                           || h->root.type == bfd_link_hash_defweak)
8371                         value = h->root.u.def.value;
8372                       else if (h->root.type == bfd_link_hash_undefweak)
8373                         value = 0;
8374                       else
8375                         {
8376                           found_tls_get_addr_arg = 0;
8377                           continue;
8378                         }
8379                     }
8380                   else
8381                     /* Symbols referenced by TLS relocs must be of type
8382                        STT_TLS.  So no need for .opd local sym adjust.  */
8383                     value = sym->st_value;
8384
8385                   ok_tprel = FALSE;
8386                   is_local = FALSE;
8387                   if (h == NULL
8388                       || !h->def_dynamic)
8389                     {
8390                       is_local = TRUE;
8391                       if (h != NULL
8392                           && h->root.type == bfd_link_hash_undefweak)
8393                         ok_tprel = TRUE;
8394                       else if (sym_sec != NULL
8395                                && sym_sec->output_section != NULL)
8396                         {
8397                           value += sym_sec->output_offset;
8398                           value += sym_sec->output_section->vma;
8399                           value -= htab->elf.tls_sec->vma;
8400                           ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8401                                       < (bfd_vma) 1 << 32);
8402                         }
8403                     }
8404
8405                   r_type = ELF64_R_TYPE (rel->r_info);
8406                   /* If this section has old-style __tls_get_addr calls
8407                      without marker relocs, then check that each
8408                      __tls_get_addr call reloc is preceded by a reloc
8409                      that conceivably belongs to the __tls_get_addr arg
8410                      setup insn.  If we don't find matching arg setup
8411                      relocs, don't do any tls optimization.  */
8412                   if (pass == 0
8413                       && sec->has_tls_get_addr_call
8414                       && h != NULL
8415                       && (h == &htab->tls_get_addr->elf
8416                           || h == &htab->tls_get_addr_fd->elf)
8417                       && !found_tls_get_addr_arg
8418                       && is_branch_reloc (r_type))
8419                     {
8420                       info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8421                                                 "TLS optimization disabled\n"),
8422                                               ibfd, sec, rel->r_offset);
8423                       ret = TRUE;
8424                       goto err_free_rel;
8425                     }
8426
8427                   found_tls_get_addr_arg = 0;
8428                   switch (r_type)
8429                     {
8430                     case R_PPC64_GOT_TLSLD16:
8431                     case R_PPC64_GOT_TLSLD16_LO:
8432                       expecting_tls_get_addr = 1;
8433                       found_tls_get_addr_arg = 1;
8434                       /* Fall thru */
8435
8436                     case R_PPC64_GOT_TLSLD16_HI:
8437                     case R_PPC64_GOT_TLSLD16_HA:
8438                       /* These relocs should never be against a symbol
8439                          defined in a shared lib.  Leave them alone if
8440                          that turns out to be the case.  */
8441                       if (!is_local)
8442                         continue;
8443
8444                       /* LD -> LE */
8445                       tls_set = 0;
8446                       tls_clear = TLS_LD;
8447                       tls_type = TLS_TLS | TLS_LD;
8448                       break;
8449
8450                     case R_PPC64_GOT_TLSGD16:
8451                     case R_PPC64_GOT_TLSGD16_LO:
8452                       expecting_tls_get_addr = 1;
8453                       found_tls_get_addr_arg = 1;
8454                       /* Fall thru */
8455
8456                     case R_PPC64_GOT_TLSGD16_HI:
8457                     case R_PPC64_GOT_TLSGD16_HA:
8458                       if (ok_tprel)
8459                         /* GD -> LE */
8460                         tls_set = 0;
8461                       else
8462                         /* GD -> IE */
8463                         tls_set = TLS_TLS | TLS_TPRELGD;
8464                       tls_clear = TLS_GD;
8465                       tls_type = TLS_TLS | TLS_GD;
8466                       break;
8467
8468                     case R_PPC64_GOT_TPREL16_DS:
8469                     case R_PPC64_GOT_TPREL16_LO_DS:
8470                     case R_PPC64_GOT_TPREL16_HI:
8471                     case R_PPC64_GOT_TPREL16_HA:
8472                       if (ok_tprel)
8473                         {
8474                           /* IE -> LE */
8475                           tls_set = 0;
8476                           tls_clear = TLS_TPREL;
8477                           tls_type = TLS_TLS | TLS_TPREL;
8478                           break;
8479                         }
8480                       continue;
8481
8482                     case R_PPC64_TLSGD:
8483                     case R_PPC64_TLSLD:
8484                       found_tls_get_addr_arg = 1;
8485                       /* Fall thru */
8486
8487                     case R_PPC64_TLS:
8488                     case R_PPC64_TOC16:
8489                     case R_PPC64_TOC16_LO:
8490                       if (sym_sec == NULL || sym_sec != toc)
8491                         continue;
8492
8493                       /* Mark this toc entry as referenced by a TLS
8494                          code sequence.  We can do that now in the
8495                          case of R_PPC64_TLS, and after checking for
8496                          tls_get_addr for the TOC16 relocs.  */
8497                       if (toc_ref == NULL)
8498                         toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8499                       if (toc_ref == NULL)
8500                         goto err_free_rel;
8501
8502                       if (h != NULL)
8503                         value = h->root.u.def.value;
8504                       else
8505                         value = sym->st_value;
8506                       value += rel->r_addend;
8507                       if (value % 8 != 0)
8508                         continue;
8509                       BFD_ASSERT (value < toc->size
8510                                   && toc->output_offset % 8 == 0);
8511                       toc_ref_index = (value + toc->output_offset) / 8;
8512                       if (r_type == R_PPC64_TLS
8513                           || r_type == R_PPC64_TLSGD
8514                           || r_type == R_PPC64_TLSLD)
8515                         {
8516                           toc_ref[toc_ref_index] = 1;
8517                           continue;
8518                         }
8519
8520                       if (pass != 0 && toc_ref[toc_ref_index] == 0)
8521                         continue;
8522
8523                       tls_set = 0;
8524                       tls_clear = 0;
8525                       expecting_tls_get_addr = 2;
8526                       break;
8527
8528                     case R_PPC64_TPREL64:
8529                       if (pass == 0
8530                           || sec != toc
8531                           || toc_ref == NULL
8532                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8533                         continue;
8534                       if (ok_tprel)
8535                         {
8536                           /* IE -> LE */
8537                           tls_set = TLS_EXPLICIT;
8538                           tls_clear = TLS_TPREL;
8539                           break;
8540                         }
8541                       continue;
8542
8543                     case R_PPC64_DTPMOD64:
8544                       if (pass == 0
8545                           || sec != toc
8546                           || toc_ref == NULL
8547                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8548                         continue;
8549                       if (rel + 1 < relend
8550                           && (rel[1].r_info
8551                               == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8552                           && rel[1].r_offset == rel->r_offset + 8)
8553                         {
8554                           if (ok_tprel)
8555                             /* GD -> LE */
8556                             tls_set = TLS_EXPLICIT | TLS_GD;
8557                           else
8558                             /* GD -> IE */
8559                             tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8560                           tls_clear = TLS_GD;
8561                         }
8562                       else
8563                         {
8564                           if (!is_local)
8565                             continue;
8566
8567                           /* LD -> LE */
8568                           tls_set = TLS_EXPLICIT;
8569                           tls_clear = TLS_LD;
8570                         }
8571                       break;
8572
8573                     default:
8574                       continue;
8575                     }
8576
8577                   if (pass == 0)
8578                     {
8579                       if (!expecting_tls_get_addr
8580                           || !sec->has_tls_get_addr_call)
8581                         continue;
8582
8583                       if (rel + 1 < relend
8584                           && branch_reloc_hash_match (ibfd, rel + 1,
8585                                                       htab->tls_get_addr,
8586                                                       htab->tls_get_addr_fd))
8587                         {
8588                           if (expecting_tls_get_addr == 2)
8589                             {
8590                               /* Check for toc tls entries.  */
8591                               unsigned char *toc_tls;
8592                               int retval;
8593
8594                               retval = get_tls_mask (&toc_tls, NULL, NULL,
8595                                                      &locsyms,
8596                                                      rel, ibfd);
8597                               if (retval == 0)
8598                                 goto err_free_rel;
8599                               if (toc_tls != NULL)
8600                                 {
8601                                   if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8602                                     found_tls_get_addr_arg = 1;
8603                                   if (retval > 1)
8604                                     toc_ref[toc_ref_index] = 1;
8605                                 }
8606                             }
8607                           continue;
8608                         }
8609
8610                       if (expecting_tls_get_addr != 1)
8611                         continue;
8612
8613                       /* Uh oh, we didn't find the expected call.  We
8614                          could just mark this symbol to exclude it
8615                          from tls optimization but it's safer to skip
8616                          the entire optimization.  */
8617                       info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8618                                                 "TLS optimization disabled\n"),
8619                                               ibfd, sec, rel->r_offset);
8620                       ret = TRUE;
8621                       goto err_free_rel;
8622                     }
8623
8624                   if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8625                     {
8626                       struct plt_entry *ent;
8627                       for (ent = htab->tls_get_addr->elf.plt.plist;
8628                            ent != NULL;
8629                            ent = ent->next)
8630                         if (ent->addend == 0)
8631                           {
8632                             if (ent->plt.refcount > 0)
8633                               {
8634                                 ent->plt.refcount -= 1;
8635                                 expecting_tls_get_addr = 0;
8636                               }
8637                             break;
8638                           }
8639                     }
8640
8641                   if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8642                     {
8643                       struct plt_entry *ent;
8644                       for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8645                            ent != NULL;
8646                            ent = ent->next)
8647                         if (ent->addend == 0)
8648                           {
8649                             if (ent->plt.refcount > 0)
8650                               ent->plt.refcount -= 1;
8651                             break;
8652                           }
8653                     }
8654
8655                   if (tls_clear == 0)
8656                     continue;
8657
8658                   if ((tls_set & TLS_EXPLICIT) == 0)
8659                     {
8660                       struct got_entry *ent;
8661
8662                       /* Adjust got entry for this reloc.  */
8663                       if (h != NULL)
8664                         ent = h->got.glist;
8665                       else
8666                         ent = elf_local_got_ents (ibfd)[r_symndx];
8667
8668                       for (; ent != NULL; ent = ent->next)
8669                         if (ent->addend == rel->r_addend
8670                             && ent->owner == ibfd
8671                             && ent->tls_type == tls_type)
8672                           break;
8673                       if (ent == NULL)
8674                         abort ();
8675
8676                       if (tls_set == 0)
8677                         {
8678                           /* We managed to get rid of a got entry.  */
8679                           if (ent->got.refcount > 0)
8680                             ent->got.refcount -= 1;
8681                         }
8682                     }
8683                   else
8684                     {
8685                       /* If we got rid of a DTPMOD/DTPREL reloc pair then
8686                          we'll lose one or two dyn relocs.  */
8687                       if (!dec_dynrel_count (rel->r_info, sec, info,
8688                                              NULL, h, sym))
8689                         return FALSE;
8690
8691                       if (tls_set == (TLS_EXPLICIT | TLS_GD))
8692                         {
8693                           if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8694                                                  NULL, h, sym))
8695                             return FALSE;
8696                         }
8697                     }
8698
8699                   *tls_mask |= tls_set;
8700                   *tls_mask &= ~tls_clear;
8701                 }
8702
8703               if (elf_section_data (sec)->relocs != relstart)
8704                 free (relstart);
8705             }
8706
8707         if (locsyms != NULL
8708             && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8709           {
8710             if (!info->keep_memory)
8711               free (locsyms);
8712             else
8713               elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8714           }
8715       }
8716
8717   if (toc_ref != NULL)
8718     free (toc_ref);
8719   return TRUE;
8720 }
8721
8722 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8723    the values of any global symbols in a toc section that has been
8724    edited.  Globals in toc sections should be a rarity, so this function
8725    sets a flag if any are found in toc sections other than the one just
8726    edited, so that futher hash table traversals can be avoided.  */
8727
8728 struct adjust_toc_info
8729 {
8730   asection *toc;
8731   unsigned long *skip;
8732   bfd_boolean global_toc_syms;
8733 };
8734
8735 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8736
8737 static bfd_boolean
8738 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8739 {
8740   struct ppc_link_hash_entry *eh;
8741   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8742   unsigned long i;
8743
8744   if (h->root.type != bfd_link_hash_defined
8745       && h->root.type != bfd_link_hash_defweak)
8746     return TRUE;
8747
8748   eh = (struct ppc_link_hash_entry *) h;
8749   if (eh->adjust_done)
8750     return TRUE;
8751
8752   if (eh->elf.root.u.def.section == toc_inf->toc)
8753     {
8754       if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8755         i = toc_inf->toc->rawsize >> 3;
8756       else
8757         i = eh->elf.root.u.def.value >> 3;
8758
8759       if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8760         {
8761           (*_bfd_error_handler)
8762             (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8763           do
8764             ++i;
8765           while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8766           eh->elf.root.u.def.value = (bfd_vma) i << 3;
8767         }
8768
8769       eh->elf.root.u.def.value -= toc_inf->skip[i];
8770       eh->adjust_done = 1;
8771     }
8772   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8773     toc_inf->global_toc_syms = TRUE;
8774
8775   return TRUE;
8776 }
8777
8778 /* Return TRUE iff INSN is one we expect on a _LO variety toc/got reloc.  */
8779
8780 static bfd_boolean
8781 ok_lo_toc_insn (unsigned int insn)
8782 {
8783   return ((insn & (0x3f << 26)) == 14u << 26 /* addi */
8784           || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8785           || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8786           || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8787           || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8788           || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8789           || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8790           || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8791           || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8792           || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8793           || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8794           || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8795           || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8796           || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8797           || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
8798               && (insn & 3) != 1)
8799           || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
8800               && ((insn & 3) == 0 || (insn & 3) == 3))
8801           || (insn & (0x3f << 26)) == 12u << 26 /* addic */);
8802 }
8803
8804 /* Examine all relocs referencing .toc sections in order to remove
8805    unused .toc entries.  */
8806
8807 bfd_boolean
8808 ppc64_elf_edit_toc (struct bfd_link_info *info)
8809 {
8810   bfd *ibfd;
8811   struct adjust_toc_info toc_inf;
8812   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8813
8814   htab->do_toc_opt = 1;
8815   toc_inf.global_toc_syms = TRUE;
8816   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8817     {
8818       asection *toc, *sec;
8819       Elf_Internal_Shdr *symtab_hdr;
8820       Elf_Internal_Sym *local_syms;
8821       Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8822       unsigned long *skip, *drop;
8823       unsigned char *used;
8824       unsigned char *keep, last, some_unused;
8825
8826       if (!is_ppc64_elf (ibfd))
8827         continue;
8828
8829       toc = bfd_get_section_by_name (ibfd, ".toc");
8830       if (toc == NULL
8831           || toc->size == 0
8832           || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8833           || discarded_section (toc))
8834         continue;
8835
8836       toc_relocs = NULL;
8837       local_syms = NULL;
8838       symtab_hdr = &elf_symtab_hdr (ibfd);
8839
8840       /* Look at sections dropped from the final link.  */
8841       skip = NULL;
8842       relstart = NULL;
8843       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8844         {
8845           if (sec->reloc_count == 0
8846               || !discarded_section (sec)
8847               || get_opd_info (sec)
8848               || (sec->flags & SEC_ALLOC) == 0
8849               || (sec->flags & SEC_DEBUGGING) != 0)
8850             continue;
8851
8852           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8853           if (relstart == NULL)
8854             goto error_ret;
8855
8856           /* Run through the relocs to see which toc entries might be
8857              unused.  */
8858           for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8859             {
8860               enum elf_ppc64_reloc_type r_type;
8861               unsigned long r_symndx;
8862               asection *sym_sec;
8863               struct elf_link_hash_entry *h;
8864               Elf_Internal_Sym *sym;
8865               bfd_vma val;
8866
8867               r_type = ELF64_R_TYPE (rel->r_info);
8868               switch (r_type)
8869                 {
8870                 default:
8871                   continue;
8872
8873                 case R_PPC64_TOC16:
8874                 case R_PPC64_TOC16_LO:
8875                 case R_PPC64_TOC16_HI:
8876                 case R_PPC64_TOC16_HA:
8877                 case R_PPC64_TOC16_DS:
8878                 case R_PPC64_TOC16_LO_DS:
8879                   break;
8880                 }
8881
8882               r_symndx = ELF64_R_SYM (rel->r_info);
8883               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8884                               r_symndx, ibfd))
8885                 goto error_ret;
8886
8887               if (sym_sec != toc)
8888                 continue;
8889
8890               if (h != NULL)
8891                 val = h->root.u.def.value;
8892               else
8893                 val = sym->st_value;
8894               val += rel->r_addend;
8895
8896               if (val >= toc->size)
8897                 continue;
8898
8899               /* Anything in the toc ought to be aligned to 8 bytes.
8900                  If not, don't mark as unused.  */
8901               if (val & 7)
8902                 continue;
8903
8904               if (skip == NULL)
8905                 {
8906                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8907                   if (skip == NULL)
8908                     goto error_ret;
8909                 }
8910
8911               skip[val >> 3] = ref_from_discarded;
8912             }
8913
8914           if (elf_section_data (sec)->relocs != relstart)
8915             free (relstart);
8916         }
8917
8918       /* For largetoc loads of address constants, we can convert
8919          .  addis rx,2,addr@got@ha
8920          .  ld ry,addr@got@l(rx)
8921          to
8922          .  addis rx,2,addr@toc@ha
8923          .  addi ry,rx,addr@toc@l
8924          when addr is within 2G of the toc pointer.  This then means
8925          that the word storing "addr" in the toc is no longer needed.  */
8926
8927       if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
8928           && toc->output_section->rawsize < (bfd_vma) 1 << 31
8929           && toc->reloc_count != 0)
8930         {
8931           /* Read toc relocs.  */
8932           toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8933                                                   info->keep_memory);
8934           if (toc_relocs == NULL)
8935             goto error_ret;
8936
8937           for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8938             {
8939               enum elf_ppc64_reloc_type r_type;
8940               unsigned long r_symndx;
8941               asection *sym_sec;
8942               struct elf_link_hash_entry *h;
8943               Elf_Internal_Sym *sym;
8944               bfd_vma val, addr;
8945
8946               r_type = ELF64_R_TYPE (rel->r_info);
8947               if (r_type != R_PPC64_ADDR64)
8948                 continue;
8949
8950               r_symndx = ELF64_R_SYM (rel->r_info);
8951               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8952                               r_symndx, ibfd))
8953                 goto error_ret;
8954
8955               if (sym_sec == NULL
8956                   || sym_sec->output_section == NULL
8957                   || discarded_section (sym_sec))
8958                 continue;
8959
8960               if (!SYMBOL_REFERENCES_LOCAL (info, h))
8961                 continue;
8962
8963               if (h != NULL)
8964                 {
8965                   if (h->type == STT_GNU_IFUNC)
8966                     continue;
8967                   val = h->root.u.def.value;
8968                 }
8969               else
8970                 {
8971                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
8972                     continue;
8973                   val = sym->st_value;
8974                 }
8975               val += rel->r_addend;
8976               val += sym_sec->output_section->vma + sym_sec->output_offset;
8977
8978               /* We don't yet know the exact toc pointer value, but we
8979                  know it will be somewhere in the toc section.  Don't
8980                  optimize if the difference from any possible toc
8981                  pointer is outside [ff..f80008000, 7fff7fff].  */
8982               addr = toc->output_section->vma + TOC_BASE_OFF;
8983               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8984                 continue;
8985
8986               addr = toc->output_section->vma + toc->output_section->rawsize;
8987               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8988                 continue;
8989
8990               if (skip == NULL)
8991                 {
8992                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8993                   if (skip == NULL)
8994                     goto error_ret;
8995                 }
8996
8997               skip[rel->r_offset >> 3]
8998                 |= can_optimize | ((rel - toc_relocs) << 2);
8999             }
9000         }
9001
9002       if (skip == NULL)
9003         continue;
9004
9005       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
9006       if (used == NULL)
9007         {
9008         error_ret:
9009           if (local_syms != NULL
9010               && symtab_hdr->contents != (unsigned char *) local_syms)
9011             free (local_syms);
9012           if (sec != NULL
9013               && relstart != NULL
9014               && elf_section_data (sec)->relocs != relstart)
9015             free (relstart);
9016           if (toc_relocs != NULL
9017               && elf_section_data (toc)->relocs != toc_relocs)
9018             free (toc_relocs);
9019           if (skip != NULL)
9020             free (skip);
9021           return FALSE;
9022         }
9023
9024       /* Now check all kept sections that might reference the toc.
9025          Check the toc itself last.  */
9026       for (sec = (ibfd->sections == toc && toc->next ? toc->next
9027                   : ibfd->sections);
9028            sec != NULL;
9029            sec = (sec == toc ? NULL
9030                   : sec->next == NULL ? toc
9031                   : sec->next == toc && toc->next ? toc->next
9032                   : sec->next))
9033         {
9034           int repeat;
9035
9036           if (sec->reloc_count == 0
9037               || discarded_section (sec)
9038               || get_opd_info (sec)
9039               || (sec->flags & SEC_ALLOC) == 0
9040               || (sec->flags & SEC_DEBUGGING) != 0)
9041             continue;
9042
9043           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9044                                                 info->keep_memory);
9045           if (relstart == NULL)
9046             {
9047               free (used);
9048               goto error_ret;
9049             }
9050
9051           /* Mark toc entries referenced as used.  */
9052           do
9053             {
9054               repeat = 0;
9055               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9056                 {
9057                   enum elf_ppc64_reloc_type r_type;
9058                   unsigned long r_symndx;
9059                   asection *sym_sec;
9060                   struct elf_link_hash_entry *h;
9061                   Elf_Internal_Sym *sym;
9062                   bfd_vma val;
9063                   enum {no_check, check_lo, check_ha} insn_check;
9064
9065                   r_type = ELF64_R_TYPE (rel->r_info);
9066                   switch (r_type)
9067                     {
9068                     default:
9069                       insn_check = no_check;
9070                       break;
9071
9072                     case R_PPC64_GOT_TLSLD16_HA:
9073                     case R_PPC64_GOT_TLSGD16_HA:
9074                     case R_PPC64_GOT_TPREL16_HA:
9075                     case R_PPC64_GOT_DTPREL16_HA:
9076                     case R_PPC64_GOT16_HA:
9077                     case R_PPC64_TOC16_HA:
9078                       insn_check = check_ha;
9079                       break;
9080
9081                     case R_PPC64_GOT_TLSLD16_LO:
9082                     case R_PPC64_GOT_TLSGD16_LO:
9083                     case R_PPC64_GOT_TPREL16_LO_DS:
9084                     case R_PPC64_GOT_DTPREL16_LO_DS:
9085                     case R_PPC64_GOT16_LO:
9086                     case R_PPC64_GOT16_LO_DS:
9087                     case R_PPC64_TOC16_LO:
9088                     case R_PPC64_TOC16_LO_DS:
9089                       insn_check = check_lo;
9090                       break;
9091                     }
9092
9093                   if (insn_check != no_check)
9094                     {
9095                       bfd_vma off = rel->r_offset & ~3;
9096                       unsigned char buf[4];
9097                       unsigned int insn;
9098
9099                       if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
9100                         {
9101                           free (used);
9102                           goto error_ret;
9103                         }
9104                       insn = bfd_get_32 (ibfd, buf);
9105                       if (insn_check == check_lo
9106                           ? !ok_lo_toc_insn (insn)
9107                           : ((insn & ((0x3f << 26) | 0x1f << 16))
9108                              != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9109                         {
9110                           char str[12];
9111
9112                           ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
9113                           sprintf (str, "%#08x", insn);
9114                           info->callbacks->einfo
9115                             (_("%P: %H: toc optimization is not supported for"
9116                                " %s instruction.\n"),
9117                              ibfd, sec, rel->r_offset & ~3, str);
9118                         }
9119                     }
9120
9121                   switch (r_type)
9122                     {
9123                     case R_PPC64_TOC16:
9124                     case R_PPC64_TOC16_LO:
9125                     case R_PPC64_TOC16_HI:
9126                     case R_PPC64_TOC16_HA:
9127                     case R_PPC64_TOC16_DS:
9128                     case R_PPC64_TOC16_LO_DS:
9129                       /* In case we're taking addresses of toc entries.  */
9130                     case R_PPC64_ADDR64:
9131                       break;
9132
9133                     default:
9134                       continue;
9135                     }
9136
9137                   r_symndx = ELF64_R_SYM (rel->r_info);
9138                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9139                                   r_symndx, ibfd))
9140                     {
9141                       free (used);
9142                       goto error_ret;
9143                     }
9144
9145                   if (sym_sec != toc)
9146                     continue;
9147
9148                   if (h != NULL)
9149                     val = h->root.u.def.value;
9150                   else
9151                     val = sym->st_value;
9152                   val += rel->r_addend;
9153
9154                   if (val >= toc->size)
9155                     continue;
9156
9157                   if ((skip[val >> 3] & can_optimize) != 0)
9158                     {
9159                       bfd_vma off;
9160                       unsigned char opc;
9161
9162                       switch (r_type)
9163                         {
9164                         case R_PPC64_TOC16_HA:
9165                           break;
9166
9167                         case R_PPC64_TOC16_LO_DS:
9168                           off = rel->r_offset;
9169                           off += (bfd_big_endian (ibfd) ? -2 : 3);
9170                           if (!bfd_get_section_contents (ibfd, sec, &opc,
9171                                                          off, 1))
9172                             {
9173                               free (used);
9174                               goto error_ret;
9175                             }
9176                           if ((opc & (0x3f << 2)) == (58u << 2))
9177                             break;
9178                           /* Fall thru */
9179
9180                         default:
9181                           /* Wrong sort of reloc, or not a ld.  We may
9182                              as well clear ref_from_discarded too.  */
9183                           skip[val >> 3] = 0;
9184                         }
9185                     }
9186
9187                   if (sec != toc)
9188                     used[val >> 3] = 1;
9189                   /* For the toc section, we only mark as used if this
9190                      entry itself isn't unused.  */
9191                   else if ((used[rel->r_offset >> 3]
9192                             || !(skip[rel->r_offset >> 3] & ref_from_discarded))
9193                            && !used[val >> 3])
9194                     {
9195                       /* Do all the relocs again, to catch reference
9196                          chains.  */
9197                       repeat = 1;
9198                       used[val >> 3] = 1;
9199                     }
9200                 }
9201             }
9202           while (repeat);
9203
9204           if (elf_section_data (sec)->relocs != relstart)
9205             free (relstart);
9206         }
9207
9208       /* Merge the used and skip arrays.  Assume that TOC
9209          doublewords not appearing as either used or unused belong
9210          to to an entry more than one doubleword in size.  */
9211       for (drop = skip, keep = used, last = 0, some_unused = 0;
9212            drop < skip + (toc->size + 7) / 8;
9213            ++drop, ++keep)
9214         {
9215           if (*keep)
9216             {
9217               *drop &= ~ref_from_discarded;
9218               if ((*drop & can_optimize) != 0)
9219                 some_unused = 1;
9220               last = 0;
9221             }
9222           else if ((*drop & ref_from_discarded) != 0)
9223             {
9224               some_unused = 1;
9225               last = ref_from_discarded;
9226             }
9227           else
9228             *drop = last;
9229         }
9230
9231       free (used);
9232
9233       if (some_unused)
9234         {
9235           bfd_byte *contents, *src;
9236           unsigned long off;
9237           Elf_Internal_Sym *sym;
9238           bfd_boolean local_toc_syms = FALSE;
9239
9240           /* Shuffle the toc contents, and at the same time convert the
9241              skip array from booleans into offsets.  */
9242           if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9243             goto error_ret;
9244
9245           elf_section_data (toc)->this_hdr.contents = contents;
9246
9247           for (src = contents, off = 0, drop = skip;
9248                src < contents + toc->size;
9249                src += 8, ++drop)
9250             {
9251               if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9252                 off += 8;
9253               else if (off != 0)
9254                 {
9255                   *drop = off;
9256                   memcpy (src - off, src, 8);
9257                 }
9258             }
9259           *drop = off;
9260           toc->rawsize = toc->size;
9261           toc->size = src - contents - off;
9262
9263           /* Adjust addends for relocs against the toc section sym,
9264              and optimize any accesses we can.  */
9265           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9266             {
9267               if (sec->reloc_count == 0
9268                   || discarded_section (sec))
9269                 continue;
9270
9271               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9272                                                     info->keep_memory);
9273               if (relstart == NULL)
9274                 goto error_ret;
9275
9276               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9277                 {
9278                   enum elf_ppc64_reloc_type r_type;
9279                   unsigned long r_symndx;
9280                   asection *sym_sec;
9281                   struct elf_link_hash_entry *h;
9282                   bfd_vma val;
9283
9284                   r_type = ELF64_R_TYPE (rel->r_info);
9285                   switch (r_type)
9286                     {
9287                     default:
9288                       continue;
9289
9290                     case R_PPC64_TOC16:
9291                     case R_PPC64_TOC16_LO:
9292                     case R_PPC64_TOC16_HI:
9293                     case R_PPC64_TOC16_HA:
9294                     case R_PPC64_TOC16_DS:
9295                     case R_PPC64_TOC16_LO_DS:
9296                     case R_PPC64_ADDR64:
9297                       break;
9298                     }
9299
9300                   r_symndx = ELF64_R_SYM (rel->r_info);
9301                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9302                                   r_symndx, ibfd))
9303                     goto error_ret;
9304
9305                   if (sym_sec != toc)
9306                     continue;
9307
9308                   if (h != NULL)
9309                     val = h->root.u.def.value;
9310                   else
9311                     {
9312                       val = sym->st_value;
9313                       if (val != 0)
9314                         local_toc_syms = TRUE;
9315                     }
9316
9317                   val += rel->r_addend;
9318
9319                   if (val > toc->rawsize)
9320                     val = toc->rawsize;
9321                   else if ((skip[val >> 3] & ref_from_discarded) != 0)
9322                     continue;
9323                   else if ((skip[val >> 3] & can_optimize) != 0)
9324                     {
9325                       Elf_Internal_Rela *tocrel
9326                         = toc_relocs + (skip[val >> 3] >> 2);
9327                       unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9328
9329                       switch (r_type)
9330                         {
9331                         case R_PPC64_TOC16_HA:
9332                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9333                           break;
9334
9335                         case R_PPC64_TOC16_LO_DS:
9336                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9337                           break;
9338
9339                         default:
9340                           if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9341                             ppc_howto_init ();
9342                           info->callbacks->einfo
9343                             (_("%P: %H: %s references "
9344                                "optimized away TOC entry\n"),
9345                              ibfd, sec, rel->r_offset,
9346                              ppc64_elf_howto_table[r_type]->name);
9347                           bfd_set_error (bfd_error_bad_value);
9348                           goto error_ret;
9349                         }
9350                       rel->r_addend = tocrel->r_addend;
9351                       elf_section_data (sec)->relocs = relstart;
9352                       continue;
9353                     }
9354
9355                   if (h != NULL || sym->st_value != 0)
9356                     continue;
9357
9358                   rel->r_addend -= skip[val >> 3];
9359                   elf_section_data (sec)->relocs = relstart;
9360                 }
9361
9362               if (elf_section_data (sec)->relocs != relstart)
9363                 free (relstart);
9364             }
9365
9366           /* We shouldn't have local or global symbols defined in the TOC,
9367              but handle them anyway.  */
9368           if (local_syms != NULL)
9369             for (sym = local_syms;
9370                  sym < local_syms + symtab_hdr->sh_info;
9371                  ++sym)
9372               if (sym->st_value != 0
9373                   && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9374                 {
9375                   unsigned long i;
9376
9377                   if (sym->st_value > toc->rawsize)
9378                     i = toc->rawsize >> 3;
9379                   else
9380                     i = sym->st_value >> 3;
9381
9382                   if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9383                     {
9384                       if (local_toc_syms)
9385                         (*_bfd_error_handler)
9386                           (_("%s defined on removed toc entry"),
9387                            bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9388                       do
9389                         ++i;
9390                       while ((skip[i] & (ref_from_discarded | can_optimize)));
9391                       sym->st_value = (bfd_vma) i << 3;
9392                     }
9393
9394                   sym->st_value -= skip[i];
9395                   symtab_hdr->contents = (unsigned char *) local_syms;
9396                 }
9397
9398           /* Adjust any global syms defined in this toc input section.  */
9399           if (toc_inf.global_toc_syms)
9400             {
9401               toc_inf.toc = toc;
9402               toc_inf.skip = skip;
9403               toc_inf.global_toc_syms = FALSE;
9404               elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9405                                       &toc_inf);
9406             }
9407
9408           if (toc->reloc_count != 0)
9409             {
9410               Elf_Internal_Shdr *rel_hdr;
9411               Elf_Internal_Rela *wrel;
9412               bfd_size_type sz;
9413
9414               /* Remove unused toc relocs, and adjust those we keep.  */
9415               if (toc_relocs == NULL)
9416                 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9417                                                         info->keep_memory);
9418               if (toc_relocs == NULL)
9419                 goto error_ret;
9420
9421               wrel = toc_relocs;
9422               for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9423                 if ((skip[rel->r_offset >> 3]
9424                      & (ref_from_discarded | can_optimize)) == 0)
9425                   {
9426                     wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9427                     wrel->r_info = rel->r_info;
9428                     wrel->r_addend = rel->r_addend;
9429                     ++wrel;
9430                   }
9431                 else if (!dec_dynrel_count (rel->r_info, toc, info,
9432                                             &local_syms, NULL, NULL))
9433                   goto error_ret;
9434
9435               elf_section_data (toc)->relocs = toc_relocs;
9436               toc->reloc_count = wrel - toc_relocs;
9437               rel_hdr = _bfd_elf_single_rel_hdr (toc);
9438               sz = rel_hdr->sh_entsize;
9439               rel_hdr->sh_size = toc->reloc_count * sz;
9440             }
9441         }
9442       else if (toc_relocs != NULL
9443                && elf_section_data (toc)->relocs != toc_relocs)
9444         free (toc_relocs);
9445
9446       if (local_syms != NULL
9447           && symtab_hdr->contents != (unsigned char *) local_syms)
9448         {
9449           if (!info->keep_memory)
9450             free (local_syms);
9451           else
9452             symtab_hdr->contents = (unsigned char *) local_syms;
9453         }
9454       free (skip);
9455     }
9456
9457   return TRUE;
9458 }
9459
9460 /* Return true iff input section I references the TOC using
9461    instructions limited to +/-32k offsets.  */
9462
9463 bfd_boolean
9464 ppc64_elf_has_small_toc_reloc (asection *i)
9465 {
9466   return (is_ppc64_elf (i->owner)
9467           && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9468 }
9469
9470 /* Allocate space for one GOT entry.  */
9471
9472 static void
9473 allocate_got (struct elf_link_hash_entry *h,
9474               struct bfd_link_info *info,
9475               struct got_entry *gent)
9476 {
9477   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9478   bfd_boolean dyn;
9479   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9480   int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9481                  ? 16 : 8);
9482   int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9483                   ? 2 : 1) * sizeof (Elf64_External_Rela);
9484   asection *got = ppc64_elf_tdata (gent->owner)->got;
9485
9486   gent->got.offset = got->size;
9487   got->size += entsize;
9488
9489   dyn = htab->elf.dynamic_sections_created;
9490   if (h->type == STT_GNU_IFUNC)
9491     {
9492       htab->elf.irelplt->size += rentsize;
9493       htab->got_reli_size += rentsize;
9494     }
9495   else if ((bfd_link_pic (info)
9496             || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
9497            && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9498                || h->root.type != bfd_link_hash_undefweak))
9499     {
9500       asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9501       relgot->size += rentsize;
9502     }
9503 }
9504
9505 /* This function merges got entries in the same toc group.  */
9506
9507 static void
9508 merge_got_entries (struct got_entry **pent)
9509 {
9510   struct got_entry *ent, *ent2;
9511
9512   for (ent = *pent; ent != NULL; ent = ent->next)
9513     if (!ent->is_indirect)
9514       for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9515         if (!ent2->is_indirect
9516             && ent2->addend == ent->addend
9517             && ent2->tls_type == ent->tls_type
9518             && elf_gp (ent2->owner) == elf_gp (ent->owner))
9519           {
9520             ent2->is_indirect = TRUE;
9521             ent2->got.ent = ent;
9522           }
9523 }
9524
9525 /* Allocate space in .plt, .got and associated reloc sections for
9526    dynamic relocs.  */
9527
9528 static bfd_boolean
9529 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9530 {
9531   struct bfd_link_info *info;
9532   struct ppc_link_hash_table *htab;
9533   asection *s;
9534   struct ppc_link_hash_entry *eh;
9535   struct elf_dyn_relocs *p;
9536   struct got_entry **pgent, *gent;
9537
9538   if (h->root.type == bfd_link_hash_indirect)
9539     return TRUE;
9540
9541   info = (struct bfd_link_info *) inf;
9542   htab = ppc_hash_table (info);
9543   if (htab == NULL)
9544     return FALSE;
9545
9546   if ((htab->elf.dynamic_sections_created
9547        && h->dynindx != -1
9548        && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
9549       || h->type == STT_GNU_IFUNC)
9550     {
9551       struct plt_entry *pent;
9552       bfd_boolean doneone = FALSE;
9553       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9554         if (pent->plt.refcount > 0)
9555           {
9556             if (!htab->elf.dynamic_sections_created
9557                 || h->dynindx == -1)
9558               {
9559                 s = htab->elf.iplt;
9560                 pent->plt.offset = s->size;
9561                 s->size += PLT_ENTRY_SIZE (htab);
9562                 s = htab->elf.irelplt;
9563               }
9564             else
9565               {
9566                 /* If this is the first .plt entry, make room for the special
9567                    first entry.  */
9568                 s = htab->elf.splt;
9569                 if (s->size == 0)
9570                   s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9571
9572                 pent->plt.offset = s->size;
9573
9574                 /* Make room for this entry.  */
9575                 s->size += PLT_ENTRY_SIZE (htab);
9576
9577                 /* Make room for the .glink code.  */
9578                 s = htab->glink;
9579                 if (s->size == 0)
9580                   s->size += GLINK_CALL_STUB_SIZE;
9581                 if (htab->opd_abi)
9582                   {
9583                     /* We need bigger stubs past index 32767.  */
9584                     if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9585                       s->size += 4;
9586                     s->size += 2*4;
9587                   }
9588                 else
9589                   s->size += 4;
9590
9591                 /* We also need to make an entry in the .rela.plt section.  */
9592                 s = htab->elf.srelplt;
9593               }
9594             s->size += sizeof (Elf64_External_Rela);
9595             doneone = TRUE;
9596           }
9597         else
9598           pent->plt.offset = (bfd_vma) -1;
9599       if (!doneone)
9600         {
9601           h->plt.plist = NULL;
9602           h->needs_plt = 0;
9603         }
9604     }
9605   else
9606     {
9607       h->plt.plist = NULL;
9608       h->needs_plt = 0;
9609     }
9610
9611   eh = (struct ppc_link_hash_entry *) h;
9612   /* Run through the TLS GD got entries first if we're changing them
9613      to TPREL.  */
9614   if ((eh->tls_mask & TLS_TPRELGD) != 0)
9615     for (gent = h->got.glist; gent != NULL; gent = gent->next)
9616       if (gent->got.refcount > 0
9617           && (gent->tls_type & TLS_GD) != 0)
9618         {
9619           /* This was a GD entry that has been converted to TPREL.  If
9620              there happens to be a TPREL entry we can use that one.  */
9621           struct got_entry *ent;
9622           for (ent = h->got.glist; ent != NULL; ent = ent->next)
9623             if (ent->got.refcount > 0
9624                 && (ent->tls_type & TLS_TPREL) != 0
9625                 && ent->addend == gent->addend
9626                 && ent->owner == gent->owner)
9627               {
9628                 gent->got.refcount = 0;
9629                 break;
9630               }
9631
9632           /* If not, then we'll be using our own TPREL entry.  */
9633           if (gent->got.refcount != 0)
9634             gent->tls_type = TLS_TLS | TLS_TPREL;
9635         }
9636
9637   /* Remove any list entry that won't generate a word in the GOT before
9638      we call merge_got_entries.  Otherwise we risk merging to empty
9639      entries.  */
9640   pgent = &h->got.glist;
9641   while ((gent = *pgent) != NULL)
9642     if (gent->got.refcount > 0)
9643       {
9644         if ((gent->tls_type & TLS_LD) != 0
9645             && !h->def_dynamic)
9646           {
9647             ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9648             *pgent = gent->next;
9649           }
9650         else
9651           pgent = &gent->next;
9652       }
9653     else
9654       *pgent = gent->next;
9655
9656   if (!htab->do_multi_toc)
9657     merge_got_entries (&h->got.glist);
9658
9659   for (gent = h->got.glist; gent != NULL; gent = gent->next)
9660     if (!gent->is_indirect)
9661       {
9662         /* Make sure this symbol is output as a dynamic symbol.
9663            Undefined weak syms won't yet be marked as dynamic,
9664            nor will all TLS symbols.  */
9665         if (h->dynindx == -1
9666             && !h->forced_local
9667             && h->type != STT_GNU_IFUNC
9668             && htab->elf.dynamic_sections_created)
9669           {
9670             if (! bfd_elf_link_record_dynamic_symbol (info, h))
9671               return FALSE;
9672           }
9673
9674         if (!is_ppc64_elf (gent->owner))
9675           abort ();
9676
9677         allocate_got (h, info, gent);
9678       }
9679
9680   if (eh->dyn_relocs == NULL
9681       || (!htab->elf.dynamic_sections_created
9682           && h->type != STT_GNU_IFUNC))
9683     return TRUE;
9684
9685   /* In the shared -Bsymbolic case, discard space allocated for
9686      dynamic pc-relative relocs against symbols which turn out to be
9687      defined in regular objects.  For the normal shared case, discard
9688      space for relocs that have become local due to symbol visibility
9689      changes.  */
9690
9691   if (bfd_link_pic (info))
9692     {
9693       /* Relocs that use pc_count are those that appear on a call insn,
9694          or certain REL relocs (see must_be_dyn_reloc) that can be
9695          generated via assembly.  We want calls to protected symbols to
9696          resolve directly to the function rather than going via the plt.
9697          If people want function pointer comparisons to work as expected
9698          then they should avoid writing weird assembly.  */
9699       if (SYMBOL_CALLS_LOCAL (info, h))
9700         {
9701           struct elf_dyn_relocs **pp;
9702
9703           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9704             {
9705               p->count -= p->pc_count;
9706               p->pc_count = 0;
9707               if (p->count == 0)
9708                 *pp = p->next;
9709               else
9710                 pp = &p->next;
9711             }
9712         }
9713
9714       /* Also discard relocs on undefined weak syms with non-default
9715          visibility.  */
9716       if (eh->dyn_relocs != NULL
9717           && h->root.type == bfd_link_hash_undefweak)
9718         {
9719           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9720             eh->dyn_relocs = NULL;
9721
9722           /* Make sure this symbol is output as a dynamic symbol.
9723              Undefined weak syms won't yet be marked as dynamic.  */
9724           else if (h->dynindx == -1
9725                    && !h->forced_local)
9726             {
9727               if (! bfd_elf_link_record_dynamic_symbol (info, h))
9728                 return FALSE;
9729             }
9730         }
9731     }
9732   else if (h->type == STT_GNU_IFUNC)
9733     {
9734       if (!h->non_got_ref)
9735         eh->dyn_relocs = NULL;
9736     }
9737   else if (ELIMINATE_COPY_RELOCS)
9738     {
9739       /* For the non-shared case, discard space for relocs against
9740          symbols which turn out to need copy relocs or are not
9741          dynamic.  */
9742
9743       if (!h->non_got_ref
9744           && !h->def_regular)
9745         {
9746           /* Make sure this symbol is output as a dynamic symbol.
9747              Undefined weak syms won't yet be marked as dynamic.  */
9748           if (h->dynindx == -1
9749               && !h->forced_local)
9750             {
9751               if (! bfd_elf_link_record_dynamic_symbol (info, h))
9752                 return FALSE;
9753             }
9754
9755           /* If that succeeded, we know we'll be keeping all the
9756              relocs.  */
9757           if (h->dynindx != -1)
9758             goto keep;
9759         }
9760
9761       eh->dyn_relocs = NULL;
9762
9763     keep: ;
9764     }
9765
9766   /* Finally, allocate space.  */
9767   for (p = eh->dyn_relocs; p != NULL; p = p->next)
9768     {
9769       asection *sreloc = elf_section_data (p->sec)->sreloc;
9770       if (eh->elf.type == STT_GNU_IFUNC)
9771         sreloc = htab->elf.irelplt;
9772       sreloc->size += p->count * sizeof (Elf64_External_Rela);
9773     }
9774
9775   return TRUE;
9776 }
9777
9778 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9779    to set up space for global entry stubs.  These are put in glink,
9780    after the branch table.  */
9781
9782 static bfd_boolean
9783 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
9784 {
9785   struct bfd_link_info *info;
9786   struct ppc_link_hash_table *htab;
9787   struct plt_entry *pent;
9788   asection *s;
9789
9790   if (h->root.type == bfd_link_hash_indirect)
9791     return TRUE;
9792
9793   if (!h->pointer_equality_needed)
9794     return TRUE;
9795
9796   if (h->def_regular)
9797     return TRUE;
9798
9799   info = inf;
9800   htab = ppc_hash_table (info);
9801   if (htab == NULL)
9802     return FALSE;
9803
9804   s = htab->glink;
9805   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9806     if (pent->plt.offset != (bfd_vma) -1
9807         && pent->addend == 0)
9808       {
9809         /* For ELFv2, if this symbol is not defined in a regular file
9810            and we are not generating a shared library or pie, then we
9811            need to define the symbol in the executable on a call stub.
9812            This is to avoid text relocations.  */
9813         s->size = (s->size + 15) & -16;
9814         h->root.u.def.section = s;
9815         h->root.u.def.value = s->size;
9816         s->size += 16;
9817         break;
9818       }
9819   return TRUE;
9820 }
9821
9822 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9823    read-only sections.  */
9824
9825 static bfd_boolean
9826 maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
9827 {
9828   if (h->root.type == bfd_link_hash_indirect)
9829     return TRUE;
9830
9831   if (readonly_dynrelocs (h))
9832     {
9833       ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
9834
9835       /* Not an error, just cut short the traversal.  */
9836       return FALSE;
9837     }
9838   return TRUE;
9839 }
9840
9841 /* Set the sizes of the dynamic sections.  */
9842
9843 static bfd_boolean
9844 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
9845                                  struct bfd_link_info *info)
9846 {
9847   struct ppc_link_hash_table *htab;
9848   bfd *dynobj;
9849   asection *s;
9850   bfd_boolean relocs;
9851   bfd *ibfd;
9852   struct got_entry *first_tlsld;
9853
9854   htab = ppc_hash_table (info);
9855   if (htab == NULL)
9856     return FALSE;
9857
9858   dynobj = htab->elf.dynobj;
9859   if (dynobj == NULL)
9860     abort ();
9861
9862   if (htab->elf.dynamic_sections_created)
9863     {
9864       /* Set the contents of the .interp section to the interpreter.  */
9865       if (bfd_link_executable (info) && !info->nointerp)
9866         {
9867           s = bfd_get_linker_section (dynobj, ".interp");
9868           if (s == NULL)
9869             abort ();
9870           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
9871           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
9872         }
9873     }
9874
9875   /* Set up .got offsets for local syms, and space for local dynamic
9876      relocs.  */
9877   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9878     {
9879       struct got_entry **lgot_ents;
9880       struct got_entry **end_lgot_ents;
9881       struct plt_entry **local_plt;
9882       struct plt_entry **end_local_plt;
9883       unsigned char *lgot_masks;
9884       bfd_size_type locsymcount;
9885       Elf_Internal_Shdr *symtab_hdr;
9886
9887       if (!is_ppc64_elf (ibfd))
9888         continue;
9889
9890       for (s = ibfd->sections; s != NULL; s = s->next)
9891         {
9892           struct ppc_dyn_relocs *p;
9893
9894           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
9895             {
9896               if (!bfd_is_abs_section (p->sec)
9897                   && bfd_is_abs_section (p->sec->output_section))
9898                 {
9899                   /* Input section has been discarded, either because
9900                      it is a copy of a linkonce section or due to
9901                      linker script /DISCARD/, so we'll be discarding
9902                      the relocs too.  */
9903                 }
9904               else if (p->count != 0)
9905                 {
9906                   asection *srel = elf_section_data (p->sec)->sreloc;
9907                   if (p->ifunc)
9908                     srel = htab->elf.irelplt;
9909                   srel->size += p->count * sizeof (Elf64_External_Rela);
9910                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
9911                     info->flags |= DF_TEXTREL;
9912                 }
9913             }
9914         }
9915
9916       lgot_ents = elf_local_got_ents (ibfd);
9917       if (!lgot_ents)
9918         continue;
9919
9920       symtab_hdr = &elf_symtab_hdr (ibfd);
9921       locsymcount = symtab_hdr->sh_info;
9922       end_lgot_ents = lgot_ents + locsymcount;
9923       local_plt = (struct plt_entry **) end_lgot_ents;
9924       end_local_plt = local_plt + locsymcount;
9925       lgot_masks = (unsigned char *) end_local_plt;
9926       s = ppc64_elf_tdata (ibfd)->got;
9927       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
9928         {
9929           struct got_entry **pent, *ent;
9930
9931           pent = lgot_ents;
9932           while ((ent = *pent) != NULL)
9933             if (ent->got.refcount > 0)
9934               {
9935                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
9936                   {
9937                     ppc64_tlsld_got (ibfd)->got.refcount += 1;
9938                     *pent = ent->next;
9939                   }
9940                 else
9941                   {
9942                     unsigned int ent_size = 8;
9943                     unsigned int rel_size = sizeof (Elf64_External_Rela);
9944
9945                     ent->got.offset = s->size;
9946                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
9947                       {
9948                         ent_size *= 2;
9949                         rel_size *= 2;
9950                       }
9951                     s->size += ent_size;
9952                     if ((*lgot_masks & PLT_IFUNC) != 0)
9953                       {
9954                         htab->elf.irelplt->size += rel_size;
9955                         htab->got_reli_size += rel_size;
9956                       }
9957                     else if (bfd_link_pic (info))
9958                       {
9959                         asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9960                         srel->size += rel_size;
9961                       }
9962                     pent = &ent->next;
9963                   }
9964               }
9965             else
9966               *pent = ent->next;
9967         }
9968
9969       /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt.  */
9970       for (; local_plt < end_local_plt; ++local_plt)
9971         {
9972           struct plt_entry *ent;
9973
9974           for (ent = *local_plt; ent != NULL; ent = ent->next)
9975             if (ent->plt.refcount > 0)
9976               {
9977                 s = htab->elf.iplt;
9978                 ent->plt.offset = s->size;
9979                 s->size += PLT_ENTRY_SIZE (htab);
9980
9981                 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
9982               }
9983             else
9984               ent->plt.offset = (bfd_vma) -1;
9985         }
9986     }
9987
9988   /* Allocate global sym .plt and .got entries, and space for global
9989      sym dynamic relocs.  */
9990   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
9991   /* Stash the end of glink branch table.  */
9992   if (htab->glink != NULL)
9993     htab->glink->rawsize = htab->glink->size;
9994
9995   if (!htab->opd_abi && !bfd_link_pic (info))
9996     elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
9997
9998   first_tlsld = NULL;
9999   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10000     {
10001       struct got_entry *ent;
10002
10003       if (!is_ppc64_elf (ibfd))
10004         continue;
10005
10006       ent = ppc64_tlsld_got (ibfd);
10007       if (ent->got.refcount > 0)
10008         {
10009           if (!htab->do_multi_toc && first_tlsld != NULL)
10010             {
10011               ent->is_indirect = TRUE;
10012               ent->got.ent = first_tlsld;
10013             }
10014           else
10015             {
10016               if (first_tlsld == NULL)
10017                 first_tlsld = ent;
10018               s = ppc64_elf_tdata (ibfd)->got;
10019               ent->got.offset = s->size;
10020               ent->owner = ibfd;
10021               s->size += 16;
10022               if (bfd_link_pic (info))
10023                 {
10024                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10025                   srel->size += sizeof (Elf64_External_Rela);
10026                 }
10027             }
10028         }
10029       else
10030         ent->got.offset = (bfd_vma) -1;
10031     }
10032
10033   /* We now have determined the sizes of the various dynamic sections.
10034      Allocate memory for them.  */
10035   relocs = FALSE;
10036   for (s = dynobj->sections; s != NULL; s = s->next)
10037     {
10038       if ((s->flags & SEC_LINKER_CREATED) == 0)
10039         continue;
10040
10041       if (s == htab->brlt || s == htab->relbrlt)
10042         /* These haven't been allocated yet;  don't strip.  */
10043         continue;
10044       else if (s == htab->elf.sgot
10045                || s == htab->elf.splt
10046                || s == htab->elf.iplt
10047                || s == htab->glink
10048                || s == htab->dynbss)
10049         {
10050           /* Strip this section if we don't need it; see the
10051              comment below.  */
10052         }
10053       else if (s == htab->glink_eh_frame)
10054         {
10055           if (!bfd_is_abs_section (s->output_section))
10056             /* Not sized yet.  */
10057             continue;
10058         }
10059       else if (CONST_STRNEQ (s->name, ".rela"))
10060         {
10061           if (s->size != 0)
10062             {
10063               if (s != htab->elf.srelplt)
10064                 relocs = TRUE;
10065
10066               /* We use the reloc_count field as a counter if we need
10067                  to copy relocs into the output file.  */
10068               s->reloc_count = 0;
10069             }
10070         }
10071       else
10072         {
10073           /* It's not one of our sections, so don't allocate space.  */
10074           continue;
10075         }
10076
10077       if (s->size == 0)
10078         {
10079           /* If we don't need this section, strip it from the
10080              output file.  This is mostly to handle .rela.bss and
10081              .rela.plt.  We must create both sections in
10082              create_dynamic_sections, because they must be created
10083              before the linker maps input sections to output
10084              sections.  The linker does that before
10085              adjust_dynamic_symbol is called, and it is that
10086              function which decides whether anything needs to go
10087              into these sections.  */
10088           s->flags |= SEC_EXCLUDE;
10089           continue;
10090         }
10091
10092       if ((s->flags & SEC_HAS_CONTENTS) == 0)
10093         continue;
10094
10095       /* Allocate memory for the section contents.  We use bfd_zalloc
10096          here in case unused entries are not reclaimed before the
10097          section's contents are written out.  This should not happen,
10098          but this way if it does we get a R_PPC64_NONE reloc in .rela
10099          sections instead of garbage.
10100          We also rely on the section contents being zero when writing
10101          the GOT.  */
10102       s->contents = bfd_zalloc (dynobj, s->size);
10103       if (s->contents == NULL)
10104         return FALSE;
10105     }
10106
10107   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10108     {
10109       if (!is_ppc64_elf (ibfd))
10110         continue;
10111
10112       s = ppc64_elf_tdata (ibfd)->got;
10113       if (s != NULL && s != htab->elf.sgot)
10114         {
10115           if (s->size == 0)
10116             s->flags |= SEC_EXCLUDE;
10117           else
10118             {
10119               s->contents = bfd_zalloc (ibfd, s->size);
10120               if (s->contents == NULL)
10121                 return FALSE;
10122             }
10123         }
10124       s = ppc64_elf_tdata (ibfd)->relgot;
10125       if (s != NULL)
10126         {
10127           if (s->size == 0)
10128             s->flags |= SEC_EXCLUDE;
10129           else
10130             {
10131               s->contents = bfd_zalloc (ibfd, s->size);
10132               if (s->contents == NULL)
10133                 return FALSE;
10134               relocs = TRUE;
10135               s->reloc_count = 0;
10136             }
10137         }
10138     }
10139
10140   if (htab->elf.dynamic_sections_created)
10141     {
10142       bfd_boolean tls_opt;
10143
10144       /* Add some entries to the .dynamic section.  We fill in the
10145          values later, in ppc64_elf_finish_dynamic_sections, but we
10146          must add the entries now so that we get the correct size for
10147          the .dynamic section.  The DT_DEBUG entry is filled in by the
10148          dynamic linker and used by the debugger.  */
10149 #define add_dynamic_entry(TAG, VAL) \
10150   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10151
10152       if (bfd_link_executable (info))
10153         {
10154           if (!add_dynamic_entry (DT_DEBUG, 0))
10155             return FALSE;
10156         }
10157
10158       if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
10159         {
10160           if (!add_dynamic_entry (DT_PLTGOT, 0)
10161               || !add_dynamic_entry (DT_PLTRELSZ, 0)
10162               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
10163               || !add_dynamic_entry (DT_JMPREL, 0)
10164               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
10165             return FALSE;
10166         }
10167
10168       if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
10169         {
10170           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
10171               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
10172             return FALSE;
10173         }
10174
10175       tls_opt = (htab->params->tls_get_addr_opt
10176                  && htab->tls_get_addr_fd != NULL
10177                  && htab->tls_get_addr_fd->elf.plt.plist != NULL);
10178       if (tls_opt || !htab->opd_abi)
10179         {
10180           if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
10181             return FALSE;
10182         }
10183
10184       if (relocs)
10185         {
10186           if (!add_dynamic_entry (DT_RELA, 0)
10187               || !add_dynamic_entry (DT_RELASZ, 0)
10188               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
10189             return FALSE;
10190
10191           /* If any dynamic relocs apply to a read-only section,
10192              then we need a DT_TEXTREL entry.  */
10193           if ((info->flags & DF_TEXTREL) == 0)
10194             elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
10195
10196           if ((info->flags & DF_TEXTREL) != 0)
10197             {
10198               if (!add_dynamic_entry (DT_TEXTREL, 0))
10199                 return FALSE;
10200             }
10201         }
10202     }
10203 #undef add_dynamic_entry
10204
10205   return TRUE;
10206 }
10207
10208 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
10209
10210 static bfd_boolean
10211 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
10212 {
10213   if (h->plt.plist != NULL
10214       && !h->def_regular
10215       && !h->pointer_equality_needed)
10216     return FALSE;
10217
10218   return _bfd_elf_hash_symbol (h);
10219 }
10220
10221 /* Determine the type of stub needed, if any, for a call.  */
10222
10223 static inline enum ppc_stub_type
10224 ppc_type_of_stub (asection *input_sec,
10225                   const Elf_Internal_Rela *rel,
10226                   struct ppc_link_hash_entry **hash,
10227                   struct plt_entry **plt_ent,
10228                   bfd_vma destination,
10229                   unsigned long local_off)
10230 {
10231   struct ppc_link_hash_entry *h = *hash;
10232   bfd_vma location;
10233   bfd_vma branch_offset;
10234   bfd_vma max_branch_offset;
10235   enum elf_ppc64_reloc_type r_type;
10236
10237   if (h != NULL)
10238     {
10239       struct plt_entry *ent;
10240       struct ppc_link_hash_entry *fdh = h;
10241       if (h->oh != NULL
10242           && h->oh->is_func_descriptor)
10243         {
10244           fdh = ppc_follow_link (h->oh);
10245           *hash = fdh;
10246         }
10247
10248       for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10249         if (ent->addend == rel->r_addend
10250             && ent->plt.offset != (bfd_vma) -1)
10251           {
10252             *plt_ent = ent;
10253             return ppc_stub_plt_call;
10254           }
10255
10256       /* Here, we know we don't have a plt entry.  If we don't have a
10257          either a defined function descriptor or a defined entry symbol
10258          in a regular object file, then it is pointless trying to make
10259          any other type of stub.  */
10260       if (!is_static_defined (&fdh->elf)
10261           && !is_static_defined (&h->elf))
10262         return ppc_stub_none;
10263     }
10264   else if (elf_local_got_ents (input_sec->owner) != NULL)
10265     {
10266       Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10267       struct plt_entry **local_plt = (struct plt_entry **)
10268         elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10269       unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10270
10271       if (local_plt[r_symndx] != NULL)
10272         {
10273           struct plt_entry *ent;
10274
10275           for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10276             if (ent->addend == rel->r_addend
10277                 && ent->plt.offset != (bfd_vma) -1)
10278               {
10279                 *plt_ent = ent;
10280                 return ppc_stub_plt_call;
10281               }
10282         }
10283     }
10284
10285   /* Determine where the call point is.  */
10286   location = (input_sec->output_offset
10287               + input_sec->output_section->vma
10288               + rel->r_offset);
10289
10290   branch_offset = destination - location;
10291   r_type = ELF64_R_TYPE (rel->r_info);
10292
10293   /* Determine if a long branch stub is needed.  */
10294   max_branch_offset = 1 << 25;
10295   if (r_type != R_PPC64_REL24)
10296     max_branch_offset = 1 << 15;
10297
10298   if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10299     /* We need a stub.  Figure out whether a long_branch or plt_branch
10300        is needed later.  */
10301     return ppc_stub_long_branch;
10302
10303   return ppc_stub_none;
10304 }
10305
10306 /* With power7 weakly ordered memory model, it is possible for ld.so
10307    to update a plt entry in one thread and have another thread see a
10308    stale zero toc entry.  To avoid this we need some sort of acquire
10309    barrier in the call stub.  One solution is to make the load of the
10310    toc word seem to appear to depend on the load of the function entry
10311    word.  Another solution is to test for r2 being zero, and branch to
10312    the appropriate glink entry if so.
10313
10314    .    fake dep barrier        compare
10315    .    ld 12,xxx(2)            ld 12,xxx(2)
10316    .    mtctr 12                mtctr 12
10317    .    xor 11,12,12            ld 2,xxx+8(2)
10318    .    add 2,2,11              cmpldi 2,0
10319    .    ld 2,xxx+8(2)           bnectr+
10320    .    bctr                    b <glink_entry>
10321
10322    The solution involving the compare turns out to be faster, so
10323    that's what we use unless the branch won't reach.  */
10324
10325 #define ALWAYS_USE_FAKE_DEP 0
10326 #define ALWAYS_EMIT_R2SAVE 0
10327
10328 #define PPC_LO(v) ((v) & 0xffff)
10329 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10330 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10331
10332 static inline unsigned int
10333 plt_stub_size (struct ppc_link_hash_table *htab,
10334                struct ppc_stub_hash_entry *stub_entry,
10335                bfd_vma off)
10336 {
10337   unsigned size = 12;
10338
10339   if (ALWAYS_EMIT_R2SAVE
10340       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10341     size += 4;
10342   if (PPC_HA (off) != 0)
10343     size += 4;
10344   if (htab->opd_abi)
10345     {
10346       size += 4;
10347       if (htab->params->plt_static_chain)
10348         size += 4;
10349       if (htab->params->plt_thread_safe
10350           && htab->elf.dynamic_sections_created
10351           && stub_entry->h != NULL
10352           && stub_entry->h->elf.dynindx != -1)
10353         size += 8;
10354       if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
10355         size += 4;
10356     }
10357   if (stub_entry->h != NULL
10358       && (stub_entry->h == htab->tls_get_addr_fd
10359           || stub_entry->h == htab->tls_get_addr)
10360       && htab->params->tls_get_addr_opt)
10361     size += 13 * 4;
10362   return size;
10363 }
10364
10365 /* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
10366    then return the padding needed to do so.  */
10367 static inline unsigned int
10368 plt_stub_pad (struct ppc_link_hash_table *htab,
10369               struct ppc_stub_hash_entry *stub_entry,
10370               bfd_vma plt_off)
10371 {
10372   int stub_align = 1 << htab->params->plt_stub_align;
10373   unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10374   bfd_vma stub_off = stub_entry->group->stub_sec->size;
10375
10376   if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10377       > ((stub_size - 1) & -stub_align))
10378     return stub_align - (stub_off & (stub_align - 1));
10379   return 0;
10380 }
10381
10382 /* Build a .plt call stub.  */
10383
10384 static inline bfd_byte *
10385 build_plt_stub (struct ppc_link_hash_table *htab,
10386                 struct ppc_stub_hash_entry *stub_entry,
10387                 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10388 {
10389   bfd *obfd = htab->params->stub_bfd;
10390   bfd_boolean plt_load_toc = htab->opd_abi;
10391   bfd_boolean plt_static_chain = htab->params->plt_static_chain;
10392   bfd_boolean plt_thread_safe = (htab->params->plt_thread_safe
10393                                  && htab->elf.dynamic_sections_created
10394                                  && stub_entry->h != NULL
10395                                  && stub_entry->h->elf.dynindx != -1);
10396   bfd_boolean use_fake_dep = plt_thread_safe;
10397   bfd_vma cmp_branch_off = 0;
10398
10399   if (!ALWAYS_USE_FAKE_DEP
10400       && plt_load_toc
10401       && plt_thread_safe
10402       && !((stub_entry->h == htab->tls_get_addr_fd
10403             || stub_entry->h == htab->tls_get_addr)
10404            && htab->params->tls_get_addr_opt))
10405     {
10406       bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10407       bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10408                           / PLT_ENTRY_SIZE (htab));
10409       bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10410       bfd_vma to, from;
10411
10412       if (pltindex > 32768)
10413         glinkoff += (pltindex - 32768) * 4;
10414       to = (glinkoff
10415             + htab->glink->output_offset
10416             + htab->glink->output_section->vma);
10417       from = (p - stub_entry->group->stub_sec->contents
10418               + 4 * (ALWAYS_EMIT_R2SAVE
10419                      || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10420               + 4 * (PPC_HA (offset) != 0)
10421               + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10422                      != PPC_HA (offset))
10423               + 4 * (plt_static_chain != 0)
10424               + 20
10425               + stub_entry->group->stub_sec->output_offset
10426               + stub_entry->group->stub_sec->output_section->vma);
10427       cmp_branch_off = to - from;
10428       use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10429     }
10430
10431   if (PPC_HA (offset) != 0)
10432     {
10433       if (r != NULL)
10434         {
10435           if (ALWAYS_EMIT_R2SAVE
10436               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10437             r[0].r_offset += 4;
10438           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10439           r[1].r_offset = r[0].r_offset + 4;
10440           r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10441           r[1].r_addend = r[0].r_addend;
10442           if (plt_load_toc)
10443             {
10444               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10445                 {
10446                   r[2].r_offset = r[1].r_offset + 4;
10447                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10448                   r[2].r_addend = r[0].r_addend;
10449                 }
10450               else
10451                 {
10452                   r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10453                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10454                   r[2].r_addend = r[0].r_addend + 8;
10455                   if (plt_static_chain)
10456                     {
10457                       r[3].r_offset = r[2].r_offset + 4;
10458                       r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10459                       r[3].r_addend = r[0].r_addend + 16;
10460                     }
10461                 }
10462             }
10463         }
10464       if (ALWAYS_EMIT_R2SAVE
10465           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10466         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10467       if (plt_load_toc)
10468         {
10469           bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10470           bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p),  p += 4;
10471         }
10472       else
10473         {
10474           bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
10475           bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p),  p += 4;
10476         }
10477       if (plt_load_toc
10478           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10479         {
10480           bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10481           offset = 0;
10482         }
10483       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10484       if (plt_load_toc)
10485         {
10486           if (use_fake_dep)
10487             {
10488               bfd_put_32 (obfd, XOR_R2_R12_R12, p),             p += 4;
10489               bfd_put_32 (obfd, ADD_R11_R11_R2, p),             p += 4;
10490             }
10491           bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10492           if (plt_static_chain)
10493             bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10494         }
10495     }
10496   else
10497     {
10498       if (r != NULL)
10499         {
10500           if (ALWAYS_EMIT_R2SAVE
10501               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10502             r[0].r_offset += 4;
10503           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10504           if (plt_load_toc)
10505             {
10506               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10507                 {
10508                   r[1].r_offset = r[0].r_offset + 4;
10509                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10510                   r[1].r_addend = r[0].r_addend;
10511                 }
10512               else
10513                 {
10514                   r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10515                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10516                   r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10517                   if (plt_static_chain)
10518                     {
10519                       r[2].r_offset = r[1].r_offset + 4;
10520                       r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10521                       r[2].r_addend = r[0].r_addend + 8;
10522                     }
10523                 }
10524             }
10525         }
10526       if (ALWAYS_EMIT_R2SAVE
10527           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10528         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10529       bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p),       p += 4;
10530       if (plt_load_toc
10531           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10532         {
10533           bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),   p += 4;
10534           offset = 0;
10535         }
10536       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10537       if (plt_load_toc)
10538         {
10539           if (use_fake_dep)
10540             {
10541               bfd_put_32 (obfd, XOR_R11_R12_R12, p),            p += 4;
10542               bfd_put_32 (obfd, ADD_R2_R2_R11, p),              p += 4;
10543             }
10544           if (plt_static_chain)
10545             bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10546           bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10547         }
10548     }
10549   if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10550     {
10551       bfd_put_32 (obfd, CMPLDI_R2_0, p),                        p += 4;
10552       bfd_put_32 (obfd, BNECTR_P4, p),                          p += 4;
10553       bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10554     }
10555   else
10556     bfd_put_32 (obfd, BCTR, p),                                 p += 4;
10557   return p;
10558 }
10559
10560 /* Build a special .plt call stub for __tls_get_addr.  */
10561
10562 #define LD_R11_0R3      0xe9630000
10563 #define LD_R12_0R3      0xe9830000
10564 #define MR_R0_R3        0x7c601b78
10565 #define CMPDI_R11_0     0x2c2b0000
10566 #define ADD_R3_R12_R13  0x7c6c6a14
10567 #define BEQLR           0x4d820020
10568 #define MR_R3_R0        0x7c030378
10569 #define STD_R11_0R1     0xf9610000
10570 #define BCTRL           0x4e800421
10571 #define LD_R11_0R1      0xe9610000
10572 #define MTLR_R11        0x7d6803a6
10573
10574 static inline bfd_byte *
10575 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10576                          struct ppc_stub_hash_entry *stub_entry,
10577                          bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10578 {
10579   bfd *obfd = htab->params->stub_bfd;
10580
10581   bfd_put_32 (obfd, LD_R11_0R3 + 0, p),         p += 4;
10582   bfd_put_32 (obfd, LD_R12_0R3 + 8, p),         p += 4;
10583   bfd_put_32 (obfd, MR_R0_R3, p),               p += 4;
10584   bfd_put_32 (obfd, CMPDI_R11_0, p),            p += 4;
10585   bfd_put_32 (obfd, ADD_R3_R12_R13, p),         p += 4;
10586   bfd_put_32 (obfd, BEQLR, p),                  p += 4;
10587   bfd_put_32 (obfd, MR_R3_R0, p),               p += 4;
10588   bfd_put_32 (obfd, MFLR_R11, p),               p += 4;
10589   bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10590
10591   if (r != NULL)
10592     r[0].r_offset += 9 * 4;
10593   p = build_plt_stub (htab, stub_entry, p, offset, r);
10594   bfd_put_32 (obfd, BCTRL, p - 4);
10595
10596   bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p),     p += 4;
10597   bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10598   bfd_put_32 (obfd, MTLR_R11, p),               p += 4;
10599   bfd_put_32 (obfd, BLR, p),                    p += 4;
10600
10601   return p;
10602 }
10603
10604 static Elf_Internal_Rela *
10605 get_relocs (asection *sec, int count)
10606 {
10607   Elf_Internal_Rela *relocs;
10608   struct bfd_elf_section_data *elfsec_data;
10609
10610   elfsec_data = elf_section_data (sec);
10611   relocs = elfsec_data->relocs;
10612   if (relocs == NULL)
10613     {
10614       bfd_size_type relsize;
10615       relsize = sec->reloc_count * sizeof (*relocs);
10616       relocs = bfd_alloc (sec->owner, relsize);
10617       if (relocs == NULL)
10618         return NULL;
10619       elfsec_data->relocs = relocs;
10620       elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10621                                           sizeof (Elf_Internal_Shdr));
10622       if (elfsec_data->rela.hdr == NULL)
10623         return NULL;
10624       elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10625                                         * sizeof (Elf64_External_Rela));
10626       elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10627       sec->reloc_count = 0;
10628     }
10629   relocs += sec->reloc_count;
10630   sec->reloc_count += count;
10631   return relocs;
10632 }
10633
10634 static bfd_vma
10635 get_r2off (struct bfd_link_info *info,
10636            struct ppc_stub_hash_entry *stub_entry)
10637 {
10638   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10639   bfd_vma r2off = htab->sec_info[stub_entry->target_section->id].toc_off;
10640
10641   if (r2off == 0)
10642     {
10643       /* Support linking -R objects.  Get the toc pointer from the
10644          opd entry.  */
10645       char buf[8];
10646       if (!htab->opd_abi)
10647         return r2off;
10648       asection *opd = stub_entry->h->elf.root.u.def.section;
10649       bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10650
10651       if (strcmp (opd->name, ".opd") != 0
10652           || opd->reloc_count != 0)
10653         {
10654           info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
10655                                   stub_entry->h->elf.root.root.string);
10656           bfd_set_error (bfd_error_bad_value);
10657           return (bfd_vma) -1;
10658         }
10659       if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10660         return (bfd_vma) -1;
10661       r2off = bfd_get_64 (opd->owner, buf);
10662       r2off -= elf_gp (info->output_bfd);
10663     }
10664   r2off -= htab->sec_info[stub_entry->group->link_sec->id].toc_off;
10665   return r2off;
10666 }
10667
10668 static bfd_boolean
10669 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10670 {
10671   struct ppc_stub_hash_entry *stub_entry;
10672   struct ppc_branch_hash_entry *br_entry;
10673   struct bfd_link_info *info;
10674   struct ppc_link_hash_table *htab;
10675   bfd_byte *loc;
10676   bfd_byte *p;
10677   bfd_vma dest, off;
10678   int size;
10679   Elf_Internal_Rela *r;
10680   asection *plt;
10681
10682   /* Massage our args to the form they really have.  */
10683   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10684   info = in_arg;
10685
10686   htab = ppc_hash_table (info);
10687   if (htab == NULL)
10688     return FALSE;
10689
10690   /* Make a note of the offset within the stubs for this entry.  */
10691   stub_entry->stub_offset = stub_entry->group->stub_sec->size;
10692   loc = stub_entry->group->stub_sec->contents + stub_entry->stub_offset;
10693
10694   htab->stub_count[stub_entry->stub_type - 1] += 1;
10695   switch (stub_entry->stub_type)
10696     {
10697     case ppc_stub_long_branch:
10698     case ppc_stub_long_branch_r2off:
10699       /* Branches are relative.  This is where we are going to.  */
10700       dest = (stub_entry->target_value
10701               + stub_entry->target_section->output_offset
10702               + stub_entry->target_section->output_section->vma);
10703       dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10704       off = dest;
10705
10706       /* And this is where we are coming from.  */
10707       off -= (stub_entry->stub_offset
10708               + stub_entry->group->stub_sec->output_offset
10709               + stub_entry->group->stub_sec->output_section->vma);
10710
10711       size = 4;
10712       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10713         {
10714           bfd_vma r2off = get_r2off (info, stub_entry);
10715
10716           if (r2off == (bfd_vma) -1)
10717             {
10718               htab->stub_error = TRUE;
10719               return FALSE;
10720             }
10721           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10722           loc += 4;
10723           size = 8;
10724           if (PPC_HA (r2off) != 0)
10725             {
10726               bfd_put_32 (htab->params->stub_bfd,
10727                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
10728               loc += 4;
10729               size += 4;
10730             }
10731           if (PPC_LO (r2off) != 0)
10732             {
10733               bfd_put_32 (htab->params->stub_bfd,
10734                           ADDI_R2_R2 | PPC_LO (r2off), loc);
10735               loc += 4;
10736               size += 4;
10737             }
10738           off -= size - 4;
10739         }
10740       bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10741
10742       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10743         {
10744           info->callbacks->einfo
10745             (_("%P: long branch stub `%s' offset overflow\n"),
10746              stub_entry->root.string);
10747           htab->stub_error = TRUE;
10748           return FALSE;
10749         }
10750
10751       if (info->emitrelocations)
10752         {
10753           r = get_relocs (stub_entry->group->stub_sec, 1);
10754           if (r == NULL)
10755             return FALSE;
10756           r->r_offset = loc - stub_entry->group->stub_sec->contents;
10757           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10758           r->r_addend = dest;
10759           if (stub_entry->h != NULL)
10760             {
10761               struct elf_link_hash_entry **hashes;
10762               unsigned long symndx;
10763               struct ppc_link_hash_entry *h;
10764
10765               hashes = elf_sym_hashes (htab->params->stub_bfd);
10766               if (hashes == NULL)
10767                 {
10768                   bfd_size_type hsize;
10769
10770                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10771                   hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
10772                   if (hashes == NULL)
10773                     return FALSE;
10774                   elf_sym_hashes (htab->params->stub_bfd) = hashes;
10775                   htab->stub_globals = 1;
10776                 }
10777               symndx = htab->stub_globals++;
10778               h = stub_entry->h;
10779               hashes[symndx] = &h->elf;
10780               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10781               if (h->oh != NULL && h->oh->is_func)
10782                 h = ppc_follow_link (h->oh);
10783               if (h->elf.root.u.def.section != stub_entry->target_section)
10784                 /* H is an opd symbol.  The addend must be zero.  */
10785                 r->r_addend = 0;
10786               else
10787                 {
10788                   off = (h->elf.root.u.def.value
10789                          + h->elf.root.u.def.section->output_offset
10790                          + h->elf.root.u.def.section->output_section->vma);
10791                   r->r_addend -= off;
10792                 }
10793             }
10794         }
10795       break;
10796
10797     case ppc_stub_plt_branch:
10798     case ppc_stub_plt_branch_r2off:
10799       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10800                                          stub_entry->root.string + 9,
10801                                          FALSE, FALSE);
10802       if (br_entry == NULL)
10803         {
10804           info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
10805                                   stub_entry->root.string);
10806           htab->stub_error = TRUE;
10807           return FALSE;
10808         }
10809
10810       dest = (stub_entry->target_value
10811               + stub_entry->target_section->output_offset
10812               + stub_entry->target_section->output_section->vma);
10813       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10814         dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10815
10816       bfd_put_64 (htab->brlt->owner, dest,
10817                   htab->brlt->contents + br_entry->offset);
10818
10819       if (br_entry->iter == htab->stub_iteration)
10820         {
10821           br_entry->iter = 0;
10822
10823           if (htab->relbrlt != NULL)
10824             {
10825               /* Create a reloc for the branch lookup table entry.  */
10826               Elf_Internal_Rela rela;
10827               bfd_byte *rl;
10828
10829               rela.r_offset = (br_entry->offset
10830                                + htab->brlt->output_offset
10831                                + htab->brlt->output_section->vma);
10832               rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10833               rela.r_addend = dest;
10834
10835               rl = htab->relbrlt->contents;
10836               rl += (htab->relbrlt->reloc_count++
10837                      * sizeof (Elf64_External_Rela));
10838               bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
10839             }
10840           else if (info->emitrelocations)
10841             {
10842               r = get_relocs (htab->brlt, 1);
10843               if (r == NULL)
10844                 return FALSE;
10845               /* brlt, being SEC_LINKER_CREATED does not go through the
10846                  normal reloc processing.  Symbols and offsets are not
10847                  translated from input file to output file form, so
10848                  set up the offset per the output file.  */
10849               r->r_offset = (br_entry->offset
10850                              + htab->brlt->output_offset
10851                              + htab->brlt->output_section->vma);
10852               r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10853               r->r_addend = dest;
10854             }
10855         }
10856
10857       dest = (br_entry->offset
10858               + htab->brlt->output_offset
10859               + htab->brlt->output_section->vma);
10860
10861       off = (dest
10862              - elf_gp (htab->brlt->output_section->owner)
10863              - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
10864
10865       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10866         {
10867           info->callbacks->einfo
10868             (_("%P: linkage table error against `%T'\n"),
10869              stub_entry->root.string);
10870           bfd_set_error (bfd_error_bad_value);
10871           htab->stub_error = TRUE;
10872           return FALSE;
10873         }
10874
10875       if (info->emitrelocations)
10876         {
10877           r = get_relocs (stub_entry->group->stub_sec, 1 + (PPC_HA (off) != 0));
10878           if (r == NULL)
10879             return FALSE;
10880           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
10881           if (bfd_big_endian (info->output_bfd))
10882             r[0].r_offset += 2;
10883           if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
10884             r[0].r_offset += 4;
10885           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10886           r[0].r_addend = dest;
10887           if (PPC_HA (off) != 0)
10888             {
10889               r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10890               r[1].r_offset = r[0].r_offset + 4;
10891               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10892               r[1].r_addend = r[0].r_addend;
10893             }
10894         }
10895
10896       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10897         {
10898           if (PPC_HA (off) != 0)
10899             {
10900               size = 16;
10901               bfd_put_32 (htab->params->stub_bfd,
10902                           ADDIS_R12_R2 | PPC_HA (off), loc);
10903               loc += 4;
10904               bfd_put_32 (htab->params->stub_bfd,
10905                           LD_R12_0R12 | PPC_LO (off), loc);
10906             }
10907           else
10908             {
10909               size = 12;
10910               bfd_put_32 (htab->params->stub_bfd,
10911                           LD_R12_0R2 | PPC_LO (off), loc);
10912             }
10913         }
10914       else
10915         {
10916           bfd_vma r2off = get_r2off (info, stub_entry);
10917
10918           if (r2off == (bfd_vma) -1)
10919             {
10920               htab->stub_error = TRUE;
10921               return FALSE;
10922             }
10923
10924           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10925           loc += 4;
10926           size = 16;
10927           if (PPC_HA (off) != 0)
10928             {
10929               size += 4;
10930               bfd_put_32 (htab->params->stub_bfd,
10931                           ADDIS_R12_R2 | PPC_HA (off), loc);
10932               loc += 4;
10933               bfd_put_32 (htab->params->stub_bfd,
10934                           LD_R12_0R12 | PPC_LO (off), loc);
10935             }
10936           else
10937             bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
10938
10939           if (PPC_HA (r2off) != 0)
10940             {
10941               size += 4;
10942               loc += 4;
10943               bfd_put_32 (htab->params->stub_bfd,
10944                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
10945             }
10946           if (PPC_LO (r2off) != 0)
10947             {
10948               size += 4;
10949               loc += 4;
10950               bfd_put_32 (htab->params->stub_bfd,
10951                           ADDI_R2_R2 | PPC_LO (r2off), loc);
10952             }
10953         }
10954       loc += 4;
10955       bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, loc);
10956       loc += 4;
10957       bfd_put_32 (htab->params->stub_bfd, BCTR, loc);
10958       break;
10959
10960     case ppc_stub_plt_call:
10961     case ppc_stub_plt_call_r2save:
10962       if (stub_entry->h != NULL
10963           && stub_entry->h->is_func_descriptor
10964           && stub_entry->h->oh != NULL)
10965         {
10966           struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
10967
10968           /* If the old-ABI "dot-symbol" is undefined make it weak so
10969              we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.  */
10970           if (fh->elf.root.type == bfd_link_hash_undefined)
10971             fh->elf.root.type = bfd_link_hash_undefweak;
10972           /* Stop undo_symbol_twiddle changing it back to undefined.  */
10973           fh->was_undefined = 0;
10974         }
10975
10976       /* Now build the stub.  */
10977       dest = stub_entry->plt_ent->plt.offset & ~1;
10978       if (dest >= (bfd_vma) -2)
10979         abort ();
10980
10981       plt = htab->elf.splt;
10982       if (!htab->elf.dynamic_sections_created
10983           || stub_entry->h == NULL
10984           || stub_entry->h->elf.dynindx == -1)
10985         plt = htab->elf.iplt;
10986
10987       dest += plt->output_offset + plt->output_section->vma;
10988
10989       if (stub_entry->h == NULL
10990           && (stub_entry->plt_ent->plt.offset & 1) == 0)
10991         {
10992           Elf_Internal_Rela rela;
10993           bfd_byte *rl;
10994
10995           rela.r_offset = dest;
10996           if (htab->opd_abi)
10997             rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
10998           else
10999             rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
11000           rela.r_addend = (stub_entry->target_value
11001                            + stub_entry->target_section->output_offset
11002                            + stub_entry->target_section->output_section->vma);
11003
11004           rl = (htab->elf.irelplt->contents
11005                 + (htab->elf.irelplt->reloc_count++
11006                    * sizeof (Elf64_External_Rela)));
11007           bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
11008           stub_entry->plt_ent->plt.offset |= 1;
11009         }
11010
11011       off = (dest
11012              - elf_gp (plt->output_section->owner)
11013              - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11014
11015       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11016         {
11017           info->callbacks->einfo
11018             (_("%P: linkage table error against `%T'\n"),
11019              stub_entry->h != NULL
11020              ? stub_entry->h->elf.root.root.string
11021              : "<local sym>");
11022           bfd_set_error (bfd_error_bad_value);
11023           htab->stub_error = TRUE;
11024           return FALSE;
11025         }
11026
11027       if (htab->params->plt_stub_align != 0)
11028         {
11029           unsigned pad = plt_stub_pad (htab, stub_entry, off);
11030
11031           stub_entry->group->stub_sec->size += pad;
11032           stub_entry->stub_offset = stub_entry->group->stub_sec->size;
11033           loc += pad;
11034         }
11035
11036       r = NULL;
11037       if (info->emitrelocations)
11038         {
11039           r = get_relocs (stub_entry->group->stub_sec,
11040                           ((PPC_HA (off) != 0)
11041                            + (htab->opd_abi
11042                               ? 2 + (htab->params->plt_static_chain
11043                                      && PPC_HA (off + 16) == PPC_HA (off))
11044                               : 1)));
11045           if (r == NULL)
11046             return FALSE;
11047           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11048           if (bfd_big_endian (info->output_bfd))
11049             r[0].r_offset += 2;
11050           r[0].r_addend = dest;
11051         }
11052       if (stub_entry->h != NULL
11053           && (stub_entry->h == htab->tls_get_addr_fd
11054               || stub_entry->h == htab->tls_get_addr)
11055           && htab->params->tls_get_addr_opt)
11056         p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
11057       else
11058         p = build_plt_stub (htab, stub_entry, loc, off, r);
11059       size = p - loc;
11060       break;
11061
11062     case ppc_stub_save_res:
11063       return TRUE;
11064
11065     default:
11066       BFD_FAIL ();
11067       return FALSE;
11068     }
11069
11070   stub_entry->group->stub_sec->size += size;
11071
11072   if (htab->params->emit_stub_syms)
11073     {
11074       struct elf_link_hash_entry *h;
11075       size_t len1, len2;
11076       char *name;
11077       const char *const stub_str[] = { "long_branch",
11078                                        "long_branch_r2off",
11079                                        "plt_branch",
11080                                        "plt_branch_r2off",
11081                                        "plt_call",
11082                                        "plt_call" };
11083
11084       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
11085       len2 = strlen (stub_entry->root.string);
11086       name = bfd_malloc (len1 + len2 + 2);
11087       if (name == NULL)
11088         return FALSE;
11089       memcpy (name, stub_entry->root.string, 9);
11090       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
11091       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
11092       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
11093       if (h == NULL)
11094         return FALSE;
11095       if (h->root.type == bfd_link_hash_new)
11096         {
11097           h->root.type = bfd_link_hash_defined;
11098           h->root.u.def.section = stub_entry->group->stub_sec;
11099           h->root.u.def.value = stub_entry->stub_offset;
11100           h->ref_regular = 1;
11101           h->def_regular = 1;
11102           h->ref_regular_nonweak = 1;
11103           h->forced_local = 1;
11104           h->non_elf = 0;
11105           h->root.linker_def = 1;
11106         }
11107     }
11108
11109   return TRUE;
11110 }
11111
11112 /* As above, but don't actually build the stub.  Just bump offset so
11113    we know stub section sizes, and select plt_branch stubs where
11114    long_branch stubs won't do.  */
11115
11116 static bfd_boolean
11117 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11118 {
11119   struct ppc_stub_hash_entry *stub_entry;
11120   struct bfd_link_info *info;
11121   struct ppc_link_hash_table *htab;
11122   bfd_vma off;
11123   int size;
11124
11125   /* Massage our args to the form they really have.  */
11126   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11127   info = in_arg;
11128
11129   htab = ppc_hash_table (info);
11130   if (htab == NULL)
11131     return FALSE;
11132
11133   if (stub_entry->h != NULL
11134       && stub_entry->h->save_res
11135       && stub_entry->h->elf.root.type == bfd_link_hash_defined
11136       && stub_entry->h->elf.root.u.def.section == htab->sfpr)
11137     {
11138       /* Don't make stubs to out-of-line register save/restore
11139          functions.  Instead, emit copies of the functions.  */
11140       stub_entry->group->needs_save_res = 1;
11141       stub_entry->stub_type = ppc_stub_save_res;
11142       return TRUE;
11143     }
11144
11145   if (stub_entry->stub_type == ppc_stub_plt_call
11146       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11147     {
11148       asection *plt;
11149       off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
11150       if (off >= (bfd_vma) -2)
11151         abort ();
11152       plt = htab->elf.splt;
11153       if (!htab->elf.dynamic_sections_created
11154           || stub_entry->h == NULL
11155           || stub_entry->h->elf.dynindx == -1)
11156         plt = htab->elf.iplt;
11157       off += (plt->output_offset
11158               + plt->output_section->vma
11159               - elf_gp (plt->output_section->owner)
11160               - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11161
11162       size = plt_stub_size (htab, stub_entry, off);
11163       if (htab->params->plt_stub_align)
11164         size += plt_stub_pad (htab, stub_entry, off);
11165       if (info->emitrelocations)
11166         {
11167           stub_entry->group->stub_sec->reloc_count
11168             += ((PPC_HA (off) != 0)
11169                 + (htab->opd_abi
11170                    ? 2 + (htab->params->plt_static_chain
11171                           && PPC_HA (off + 16) == PPC_HA (off))
11172                    : 1));
11173           stub_entry->group->stub_sec->flags |= SEC_RELOC;
11174         }
11175     }
11176   else
11177     {
11178       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
11179          variants.  */
11180       bfd_vma r2off = 0;
11181       bfd_vma local_off = 0;
11182
11183       off = (stub_entry->target_value
11184              + stub_entry->target_section->output_offset
11185              + stub_entry->target_section->output_section->vma);
11186       off -= (stub_entry->group->stub_sec->size
11187               + stub_entry->group->stub_sec->output_offset
11188               + stub_entry->group->stub_sec->output_section->vma);
11189
11190       /* Reset the stub type from the plt variant in case we now
11191          can reach with a shorter stub.  */
11192       if (stub_entry->stub_type >= ppc_stub_plt_branch)
11193         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
11194
11195       size = 4;
11196       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11197         {
11198           r2off = get_r2off (info, stub_entry);
11199           if (r2off == (bfd_vma) -1)
11200             {
11201               htab->stub_error = TRUE;
11202               return FALSE;
11203             }
11204           size = 8;
11205           if (PPC_HA (r2off) != 0)
11206             size += 4;
11207           if (PPC_LO (r2off) != 0)
11208             size += 4;
11209           off -= size - 4;
11210         }
11211
11212       local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11213
11214       /* If the branch offset if too big, use a ppc_stub_plt_branch.
11215          Do the same for -R objects without function descriptors.  */
11216       if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
11217           || (stub_entry->stub_type == ppc_stub_long_branch_r2off
11218               && r2off == 0
11219               && htab->sec_info[stub_entry->target_section->id].toc_off == 0))
11220         {
11221           struct ppc_branch_hash_entry *br_entry;
11222
11223           br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11224                                              stub_entry->root.string + 9,
11225                                              TRUE, FALSE);
11226           if (br_entry == NULL)
11227             {
11228               info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
11229                                       stub_entry->root.string);
11230               htab->stub_error = TRUE;
11231               return FALSE;
11232             }
11233
11234           if (br_entry->iter != htab->stub_iteration)
11235             {
11236               br_entry->iter = htab->stub_iteration;
11237               br_entry->offset = htab->brlt->size;
11238               htab->brlt->size += 8;
11239
11240               if (htab->relbrlt != NULL)
11241                 htab->relbrlt->size += sizeof (Elf64_External_Rela);
11242               else if (info->emitrelocations)
11243                 {
11244                   htab->brlt->reloc_count += 1;
11245                   htab->brlt->flags |= SEC_RELOC;
11246                 }
11247             }
11248
11249           stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
11250           off = (br_entry->offset
11251                  + htab->brlt->output_offset
11252                  + htab->brlt->output_section->vma
11253                  - elf_gp (htab->brlt->output_section->owner)
11254                  - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11255
11256           if (info->emitrelocations)
11257             {
11258               stub_entry->group->stub_sec->reloc_count
11259                 += 1 + (PPC_HA (off) != 0);
11260               stub_entry->group->stub_sec->flags |= SEC_RELOC;
11261             }
11262
11263           if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11264             {
11265               size = 12;
11266               if (PPC_HA (off) != 0)
11267                 size = 16;
11268             }
11269           else
11270             {
11271               size = 16;
11272               if (PPC_HA (off) != 0)
11273                 size += 4;
11274
11275               if (PPC_HA (r2off) != 0)
11276                 size += 4;
11277               if (PPC_LO (r2off) != 0)
11278                 size += 4;
11279             }
11280         }
11281       else if (info->emitrelocations)
11282         {
11283           stub_entry->group->stub_sec->reloc_count += 1;
11284           stub_entry->group->stub_sec->flags |= SEC_RELOC;
11285         }
11286     }
11287
11288   stub_entry->group->stub_sec->size += size;
11289   return TRUE;
11290 }
11291
11292 /* Set up various things so that we can make a list of input sections
11293    for each output section included in the link.  Returns -1 on error,
11294    0 when no stubs will be needed, and 1 on success.  */
11295
11296 int
11297 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
11298 {
11299   unsigned int id;
11300   bfd_size_type amt;
11301   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11302
11303   if (htab == NULL)
11304     return -1;
11305
11306   htab->sec_info_arr_size = bfd_get_next_section_id ();
11307   amt = sizeof (*htab->sec_info) * (htab->sec_info_arr_size);
11308   htab->sec_info = bfd_zmalloc (amt);
11309   if (htab->sec_info == NULL)
11310     return -1;
11311
11312   /* Set toc_off for com, und, abs and ind sections.  */
11313   for (id = 0; id < 3; id++)
11314     htab->sec_info[id].toc_off = TOC_BASE_OFF;
11315
11316   return 1;
11317 }
11318
11319 /* Set up for first pass at multitoc partitioning.  */
11320
11321 void
11322 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11323 {
11324   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11325
11326   htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11327   htab->toc_bfd = NULL;
11328   htab->toc_first_sec = NULL;
11329 }
11330
11331 /* The linker repeatedly calls this function for each TOC input section
11332    and linker generated GOT section.  Group input bfds such that the toc
11333    within a group is less than 64k in size.  */
11334
11335 bfd_boolean
11336 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11337 {
11338   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11339   bfd_vma addr, off, limit;
11340
11341   if (htab == NULL)
11342     return FALSE;
11343
11344   if (!htab->second_toc_pass)
11345     {
11346       /* Keep track of the first .toc or .got section for this input bfd.  */
11347       bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11348
11349       if (new_bfd)
11350         {
11351           htab->toc_bfd = isec->owner;
11352           htab->toc_first_sec = isec;
11353         }
11354
11355       addr = isec->output_offset + isec->output_section->vma;
11356       off = addr - htab->toc_curr;
11357       limit = 0x80008000;
11358       if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11359         limit = 0x10000;
11360       if (off + isec->size > limit)
11361         {
11362           addr = (htab->toc_first_sec->output_offset
11363                   + htab->toc_first_sec->output_section->vma);
11364           htab->toc_curr = addr;
11365           htab->toc_curr &= -TOC_BASE_ALIGN;
11366         }
11367
11368       /* toc_curr is the base address of this toc group.  Set elf_gp
11369          for the input section to be the offset relative to the
11370          output toc base plus 0x8000.  Making the input elf_gp an
11371          offset allows us to move the toc as a whole without
11372          recalculating input elf_gp.  */
11373       off = htab->toc_curr - elf_gp (isec->output_section->owner);
11374       off += TOC_BASE_OFF;
11375
11376       /* Die if someone uses a linker script that doesn't keep input
11377          file .toc and .got together.  */
11378       if (new_bfd
11379           && elf_gp (isec->owner) != 0
11380           && elf_gp (isec->owner) != off)
11381         return FALSE;
11382
11383       elf_gp (isec->owner) = off;
11384       return TRUE;
11385     }
11386
11387   /* During the second pass toc_first_sec points to the start of
11388      a toc group, and toc_curr is used to track the old elf_gp.
11389      We use toc_bfd to ensure we only look at each bfd once.  */
11390   if (htab->toc_bfd == isec->owner)
11391     return TRUE;
11392   htab->toc_bfd = isec->owner;
11393
11394   if (htab->toc_first_sec == NULL
11395       || htab->toc_curr != elf_gp (isec->owner))
11396     {
11397       htab->toc_curr = elf_gp (isec->owner);
11398       htab->toc_first_sec = isec;
11399     }
11400   addr = (htab->toc_first_sec->output_offset
11401           + htab->toc_first_sec->output_section->vma);
11402   off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
11403   elf_gp (isec->owner) = off;
11404
11405   return TRUE;
11406 }
11407
11408 /* Called via elf_link_hash_traverse to merge GOT entries for global
11409    symbol H.  */
11410
11411 static bfd_boolean
11412 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11413 {
11414   if (h->root.type == bfd_link_hash_indirect)
11415     return TRUE;
11416
11417   merge_got_entries (&h->got.glist);
11418
11419   return TRUE;
11420 }
11421
11422 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11423    symbol H.  */
11424
11425 static bfd_boolean
11426 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11427 {
11428   struct got_entry *gent;
11429
11430   if (h->root.type == bfd_link_hash_indirect)
11431     return TRUE;
11432
11433   for (gent = h->got.glist; gent != NULL; gent = gent->next)
11434     if (!gent->is_indirect)
11435       allocate_got (h, (struct bfd_link_info *) inf, gent);
11436   return TRUE;
11437 }
11438
11439 /* Called on the first multitoc pass after the last call to
11440    ppc64_elf_next_toc_section.  This function removes duplicate GOT
11441    entries.  */
11442
11443 bfd_boolean
11444 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11445 {
11446   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11447   struct bfd *ibfd, *ibfd2;
11448   bfd_boolean done_something;
11449
11450   htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11451
11452   if (!htab->do_multi_toc)
11453     return FALSE;
11454
11455   /* Merge global sym got entries within a toc group.  */
11456   elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11457
11458   /* And tlsld_got.  */
11459   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11460     {
11461       struct got_entry *ent, *ent2;
11462
11463       if (!is_ppc64_elf (ibfd))
11464         continue;
11465
11466       ent = ppc64_tlsld_got (ibfd);
11467       if (!ent->is_indirect
11468           && ent->got.offset != (bfd_vma) -1)
11469         {
11470           for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
11471             {
11472               if (!is_ppc64_elf (ibfd2))
11473                 continue;
11474
11475               ent2 = ppc64_tlsld_got (ibfd2);
11476               if (!ent2->is_indirect
11477                   && ent2->got.offset != (bfd_vma) -1
11478                   && elf_gp (ibfd2) == elf_gp (ibfd))
11479                 {
11480                   ent2->is_indirect = TRUE;
11481                   ent2->got.ent = ent;
11482                 }
11483             }
11484         }
11485     }
11486
11487   /* Zap sizes of got sections.  */
11488   htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11489   htab->elf.irelplt->size -= htab->got_reli_size;
11490   htab->got_reli_size = 0;
11491
11492   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11493     {
11494       asection *got, *relgot;
11495
11496       if (!is_ppc64_elf (ibfd))
11497         continue;
11498
11499       got = ppc64_elf_tdata (ibfd)->got;
11500       if (got != NULL)
11501         {
11502           got->rawsize = got->size;
11503           got->size = 0;
11504           relgot = ppc64_elf_tdata (ibfd)->relgot;
11505           relgot->rawsize = relgot->size;
11506           relgot->size = 0;
11507         }
11508     }
11509
11510   /* Now reallocate the got, local syms first.  We don't need to
11511      allocate section contents again since we never increase size.  */
11512   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11513     {
11514       struct got_entry **lgot_ents;
11515       struct got_entry **end_lgot_ents;
11516       struct plt_entry **local_plt;
11517       struct plt_entry **end_local_plt;
11518       unsigned char *lgot_masks;
11519       bfd_size_type locsymcount;
11520       Elf_Internal_Shdr *symtab_hdr;
11521       asection *s;
11522
11523       if (!is_ppc64_elf (ibfd))
11524         continue;
11525
11526       lgot_ents = elf_local_got_ents (ibfd);
11527       if (!lgot_ents)
11528         continue;
11529
11530       symtab_hdr = &elf_symtab_hdr (ibfd);
11531       locsymcount = symtab_hdr->sh_info;
11532       end_lgot_ents = lgot_ents + locsymcount;
11533       local_plt = (struct plt_entry **) end_lgot_ents;
11534       end_local_plt = local_plt + locsymcount;
11535       lgot_masks = (unsigned char *) end_local_plt;
11536       s = ppc64_elf_tdata (ibfd)->got;
11537       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11538         {
11539           struct got_entry *ent;
11540
11541           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11542             {
11543               unsigned int ent_size = 8;
11544               unsigned int rel_size = sizeof (Elf64_External_Rela);
11545
11546               ent->got.offset = s->size;
11547               if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11548                 {
11549                   ent_size *= 2;
11550                   rel_size *= 2;
11551                 }
11552               s->size += ent_size;
11553               if ((*lgot_masks & PLT_IFUNC) != 0)
11554                 {
11555                   htab->elf.irelplt->size += rel_size;
11556                   htab->got_reli_size += rel_size;
11557                 }
11558               else if (bfd_link_pic (info))
11559                 {
11560                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11561                   srel->size += rel_size;
11562                 }
11563             }
11564         }
11565     }
11566
11567   elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11568
11569   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11570     {
11571       struct got_entry *ent;
11572
11573       if (!is_ppc64_elf (ibfd))
11574         continue;
11575
11576       ent = ppc64_tlsld_got (ibfd);
11577       if (!ent->is_indirect
11578           && ent->got.offset != (bfd_vma) -1)
11579         {
11580           asection *s = ppc64_elf_tdata (ibfd)->got;
11581           ent->got.offset = s->size;
11582           s->size += 16;
11583           if (bfd_link_pic (info))
11584             {
11585               asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11586               srel->size += sizeof (Elf64_External_Rela);
11587             }
11588         }
11589     }
11590
11591   done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11592   if (!done_something)
11593     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11594       {
11595         asection *got;
11596
11597         if (!is_ppc64_elf (ibfd))
11598           continue;
11599
11600         got = ppc64_elf_tdata (ibfd)->got;
11601         if (got != NULL)
11602           {
11603             done_something = got->rawsize != got->size;
11604             if (done_something)
11605               break;
11606           }
11607       }
11608
11609   if (done_something)
11610     (*htab->params->layout_sections_again) ();
11611
11612   /* Set up for second pass over toc sections to recalculate elf_gp
11613      on input sections.  */
11614   htab->toc_bfd = NULL;
11615   htab->toc_first_sec = NULL;
11616   htab->second_toc_pass = TRUE;
11617   return done_something;
11618 }
11619
11620 /* Called after second pass of multitoc partitioning.  */
11621
11622 void
11623 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11624 {
11625   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11626
11627   /* After the second pass, toc_curr tracks the TOC offset used
11628      for code sections below in ppc64_elf_next_input_section.  */
11629   htab->toc_curr = TOC_BASE_OFF;
11630 }
11631
11632 /* No toc references were found in ISEC.  If the code in ISEC makes no
11633    calls, then there's no need to use toc adjusting stubs when branching
11634    into ISEC.  Actually, indirect calls from ISEC are OK as they will
11635    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
11636    needed, and 2 if a cyclical call-graph was found but no other reason
11637    for a stub was detected.  If called from the top level, a return of
11638    2 means the same as a return of 0.  */
11639
11640 static int
11641 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11642 {
11643   int ret;
11644
11645   /* Mark this section as checked.  */
11646   isec->call_check_done = 1;
11647
11648   /* We know none of our code bearing sections will need toc stubs.  */
11649   if ((isec->flags & SEC_LINKER_CREATED) != 0)
11650     return 0;
11651
11652   if (isec->size == 0)
11653     return 0;
11654
11655   if (isec->output_section == NULL)
11656     return 0;
11657
11658   ret = 0;
11659   if (isec->reloc_count != 0)
11660     {
11661       Elf_Internal_Rela *relstart, *rel;
11662       Elf_Internal_Sym *local_syms;
11663       struct ppc_link_hash_table *htab;
11664
11665       relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11666                                             info->keep_memory);
11667       if (relstart == NULL)
11668         return -1;
11669
11670       /* Look for branches to outside of this section.  */
11671       local_syms = NULL;
11672       htab = ppc_hash_table (info);
11673       if (htab == NULL)
11674         return -1;
11675
11676       for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11677         {
11678           enum elf_ppc64_reloc_type r_type;
11679           unsigned long r_symndx;
11680           struct elf_link_hash_entry *h;
11681           struct ppc_link_hash_entry *eh;
11682           Elf_Internal_Sym *sym;
11683           asection *sym_sec;
11684           struct _opd_sec_data *opd;
11685           bfd_vma sym_value;
11686           bfd_vma dest;
11687
11688           r_type = ELF64_R_TYPE (rel->r_info);
11689           if (r_type != R_PPC64_REL24
11690               && r_type != R_PPC64_REL14
11691               && r_type != R_PPC64_REL14_BRTAKEN
11692               && r_type != R_PPC64_REL14_BRNTAKEN)
11693             continue;
11694
11695           r_symndx = ELF64_R_SYM (rel->r_info);
11696           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11697                           isec->owner))
11698             {
11699               ret = -1;
11700               break;
11701             }
11702
11703           /* Calls to dynamic lib functions go through a plt call stub
11704              that uses r2.  */
11705           eh = (struct ppc_link_hash_entry *) h;
11706           if (eh != NULL
11707               && (eh->elf.plt.plist != NULL
11708                   || (eh->oh != NULL
11709                       && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11710             {
11711               ret = 1;
11712               break;
11713             }
11714
11715           if (sym_sec == NULL)
11716             /* Ignore other undefined symbols.  */
11717             continue;
11718
11719           /* Assume branches to other sections not included in the
11720              link need stubs too, to cover -R and absolute syms.  */
11721           if (sym_sec->output_section == NULL)
11722             {
11723               ret = 1;
11724               break;
11725             }
11726
11727           if (h == NULL)
11728             sym_value = sym->st_value;
11729           else
11730             {
11731               if (h->root.type != bfd_link_hash_defined
11732                   && h->root.type != bfd_link_hash_defweak)
11733                 abort ();
11734               sym_value = h->root.u.def.value;
11735             }
11736           sym_value += rel->r_addend;
11737
11738           /* If this branch reloc uses an opd sym, find the code section.  */
11739           opd = get_opd_info (sym_sec);
11740           if (opd != NULL)
11741             {
11742               if (h == NULL && opd->adjust != NULL)
11743                 {
11744                   long adjust;
11745
11746                   adjust = opd->adjust[OPD_NDX (sym_value)];
11747                   if (adjust == -1)
11748                     /* Assume deleted functions won't ever be called.  */
11749                     continue;
11750                   sym_value += adjust;
11751                 }
11752
11753               dest = opd_entry_value (sym_sec, sym_value,
11754                                       &sym_sec, NULL, FALSE);
11755               if (dest == (bfd_vma) -1)
11756                 continue;
11757             }
11758           else
11759             dest = (sym_value
11760                     + sym_sec->output_offset
11761                     + sym_sec->output_section->vma);
11762
11763           /* Ignore branch to self.  */
11764           if (sym_sec == isec)
11765             continue;
11766
11767           /* If the called function uses the toc, we need a stub.  */
11768           if (sym_sec->has_toc_reloc
11769               || sym_sec->makes_toc_func_call)
11770             {
11771               ret = 1;
11772               break;
11773             }
11774
11775           /* Assume any branch that needs a long branch stub might in fact
11776              need a plt_branch stub.  A plt_branch stub uses r2.  */
11777           else if (dest - (isec->output_offset
11778                            + isec->output_section->vma
11779                            + rel->r_offset) + (1 << 25)
11780                    >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
11781                                                              ? h->other
11782                                                              : sym->st_other))
11783             {
11784               ret = 1;
11785               break;
11786             }
11787
11788           /* If calling back to a section in the process of being
11789              tested, we can't say for sure that no toc adjusting stubs
11790              are needed, so don't return zero.  */
11791           else if (sym_sec->call_check_in_progress)
11792             ret = 2;
11793
11794           /* Branches to another section that itself doesn't have any TOC
11795              references are OK.  Recursively call ourselves to check.  */
11796           else if (!sym_sec->call_check_done)
11797             {
11798               int recur;
11799
11800               /* Mark current section as indeterminate, so that other
11801                  sections that call back to current won't be marked as
11802                  known.  */
11803               isec->call_check_in_progress = 1;
11804               recur = toc_adjusting_stub_needed (info, sym_sec);
11805               isec->call_check_in_progress = 0;
11806
11807               if (recur != 0)
11808                 {
11809                   ret = recur;
11810                   if (recur != 2)
11811                     break;
11812                 }
11813             }
11814         }
11815
11816       if (local_syms != NULL
11817           && (elf_symtab_hdr (isec->owner).contents
11818               != (unsigned char *) local_syms))
11819         free (local_syms);
11820       if (elf_section_data (isec)->relocs != relstart)
11821         free (relstart);
11822     }
11823
11824   if ((ret & 1) == 0
11825       && isec->map_head.s != NULL
11826       && (strcmp (isec->output_section->name, ".init") == 0
11827           || strcmp (isec->output_section->name, ".fini") == 0))
11828     {
11829       if (isec->map_head.s->has_toc_reloc
11830           || isec->map_head.s->makes_toc_func_call)
11831         ret = 1;
11832       else if (!isec->map_head.s->call_check_done)
11833         {
11834           int recur;
11835           isec->call_check_in_progress = 1;
11836           recur = toc_adjusting_stub_needed (info, isec->map_head.s);
11837           isec->call_check_in_progress = 0;
11838           if (recur != 0)
11839             ret = recur;
11840         }
11841     }
11842
11843   if (ret == 1)
11844     isec->makes_toc_func_call = 1;
11845
11846   return ret;
11847 }
11848
11849 /* The linker repeatedly calls this function for each input section,
11850    in the order that input sections are linked into output sections.
11851    Build lists of input sections to determine groupings between which
11852    we may insert linker stubs.  */
11853
11854 bfd_boolean
11855 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
11856 {
11857   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11858
11859   if (htab == NULL)
11860     return FALSE;
11861
11862   if ((isec->output_section->flags & SEC_CODE) != 0
11863       && isec->output_section->id < htab->sec_info_arr_size)
11864     {
11865       /* This happens to make the list in reverse order,
11866          which is what we want.  */
11867       htab->sec_info[isec->id].u.list
11868         = htab->sec_info[isec->output_section->id].u.list;
11869       htab->sec_info[isec->output_section->id].u.list = isec;
11870     }
11871
11872   if (htab->multi_toc_needed)
11873     {
11874       /* Analyse sections that aren't already flagged as needing a
11875          valid toc pointer.  Exclude .fixup for the linux kernel.
11876          .fixup contains branches, but only back to the function that
11877          hit an exception.  */
11878       if (!(isec->has_toc_reloc
11879             || (isec->flags & SEC_CODE) == 0
11880             || strcmp (isec->name, ".fixup") == 0
11881             || isec->call_check_done))
11882         {
11883           if (toc_adjusting_stub_needed (info, isec) < 0)
11884             return FALSE;
11885         }
11886       /* Make all sections use the TOC assigned for this object file.
11887          This will be wrong for pasted sections;  We fix that in
11888          check_pasted_section().  */
11889       if (elf_gp (isec->owner) != 0)
11890         htab->toc_curr = elf_gp (isec->owner);
11891     }
11892
11893   htab->sec_info[isec->id].toc_off = htab->toc_curr;
11894   return TRUE;
11895 }
11896
11897 /* Check that all .init and .fini sections use the same toc, if they
11898    have toc relocs.  */
11899
11900 static bfd_boolean
11901 check_pasted_section (struct bfd_link_info *info, const char *name)
11902 {
11903   asection *o = bfd_get_section_by_name (info->output_bfd, name);
11904
11905   if (o != NULL)
11906     {
11907       struct ppc_link_hash_table *htab = ppc_hash_table (info);
11908       bfd_vma toc_off = 0;
11909       asection *i;
11910
11911       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11912         if (i->has_toc_reloc)
11913           {
11914             if (toc_off == 0)
11915               toc_off = htab->sec_info[i->id].toc_off;
11916             else if (toc_off != htab->sec_info[i->id].toc_off)
11917               return FALSE;
11918           }
11919
11920       if (toc_off == 0)
11921         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11922           if (i->makes_toc_func_call)
11923             {
11924               toc_off = htab->sec_info[i->id].toc_off;
11925               break;
11926             }
11927
11928       /* Make sure the whole pasted function uses the same toc offset.  */
11929       if (toc_off != 0)
11930         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11931           htab->sec_info[i->id].toc_off = toc_off;
11932     }
11933   return TRUE;
11934 }
11935
11936 bfd_boolean
11937 ppc64_elf_check_init_fini (struct bfd_link_info *info)
11938 {
11939   return (check_pasted_section (info, ".init")
11940           & check_pasted_section (info, ".fini"));
11941 }
11942
11943 /* See whether we can group stub sections together.  Grouping stub
11944    sections may result in fewer stubs.  More importantly, we need to
11945    put all .init* and .fini* stubs at the beginning of the .init or
11946    .fini output sections respectively, because glibc splits the
11947    _init and _fini functions into multiple parts.  Putting a stub in
11948    the middle of a function is not a good idea.  */
11949
11950 static bfd_boolean
11951 group_sections (struct bfd_link_info *info,
11952                 bfd_size_type stub_group_size,
11953                 bfd_boolean stubs_always_before_branch)
11954 {
11955   struct ppc_link_hash_table *htab;
11956   asection *osec;
11957   bfd_size_type stub14_group_size;
11958   bfd_boolean suppress_size_errors;
11959
11960   htab = ppc_hash_table (info);
11961   if (htab == NULL)
11962     return FALSE;
11963
11964   suppress_size_errors = FALSE;
11965   stub14_group_size = stub_group_size >> 10;
11966   if (stub_group_size == 1)
11967     {
11968       /* Default values.  */
11969       if (stubs_always_before_branch)
11970         {
11971           stub_group_size = 0x1e00000;
11972           stub14_group_size = 0x7800;
11973         }
11974       else
11975         {
11976           stub_group_size = 0x1c00000;
11977           stub14_group_size = 0x7000;
11978         }
11979       suppress_size_errors = TRUE;
11980     }
11981
11982   for (osec = info->output_bfd->sections; osec != NULL; osec = osec->next)
11983     {
11984       asection *tail;
11985
11986       if (osec->id >= htab->sec_info_arr_size)
11987         continue;
11988
11989       tail = htab->sec_info[osec->id].u.list;
11990       while (tail != NULL)
11991         {
11992           asection *curr;
11993           asection *prev;
11994           bfd_size_type total;
11995           bfd_boolean big_sec;
11996           bfd_vma curr_toc;
11997           struct map_stub *group;
11998
11999           curr = tail;
12000           total = tail->size;
12001           big_sec = total > (ppc64_elf_section_data (tail) != NULL
12002                              && ppc64_elf_section_data (tail)->has_14bit_branch
12003                              ? stub14_group_size : stub_group_size);
12004           if (big_sec && !suppress_size_errors)
12005             (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
12006                                      tail->owner, tail);
12007           curr_toc = htab->sec_info[tail->id].toc_off;
12008
12009           while ((prev = htab->sec_info[curr->id].u.list) != NULL
12010                  && ((total += curr->output_offset - prev->output_offset)
12011                      < (ppc64_elf_section_data (prev) != NULL
12012                         && ppc64_elf_section_data (prev)->has_14bit_branch
12013                         ? stub14_group_size : stub_group_size))
12014                  && htab->sec_info[prev->id].toc_off == curr_toc)
12015             curr = prev;
12016
12017           /* OK, the size from the start of CURR to the end is less
12018              than stub_group_size and thus can be handled by one stub
12019              section.  (or the tail section is itself larger than
12020              stub_group_size, in which case we may be toast.)  We
12021              should really be keeping track of the total size of stubs
12022              added here, as stubs contribute to the final output
12023              section size.  That's a little tricky, and this way will
12024              only break if stubs added make the total size more than
12025              2^25, ie. for the default stub_group_size, if stubs total
12026              more than 2097152 bytes, or nearly 75000 plt call stubs.  */
12027           group = bfd_alloc (curr->owner, sizeof (*group));
12028           if (group == NULL)
12029             return FALSE;
12030           group->link_sec = curr;
12031           group->stub_sec = NULL;
12032           group->needs_save_res = 0;
12033           group->next = htab->group;
12034           htab->group = group;
12035           do
12036             {
12037               prev = htab->sec_info[tail->id].u.list;
12038               /* Set up this stub group.  */
12039               htab->sec_info[tail->id].u.group = group;
12040             }
12041           while (tail != curr && (tail = prev) != NULL);
12042
12043           /* But wait, there's more!  Input sections up to stub_group_size
12044              bytes before the stub section can be handled by it too.
12045              Don't do this if we have a really large section after the
12046              stubs, as adding more stubs increases the chance that
12047              branches may not reach into the stub section.  */
12048           if (!stubs_always_before_branch && !big_sec)
12049             {
12050               total = 0;
12051               while (prev != NULL
12052                      && ((total += tail->output_offset - prev->output_offset)
12053                          < (ppc64_elf_section_data (prev) != NULL
12054                             && ppc64_elf_section_data (prev)->has_14bit_branch
12055                             ? stub14_group_size : stub_group_size))
12056                      && htab->sec_info[prev->id].toc_off == curr_toc)
12057                 {
12058                   tail = prev;
12059                   prev = htab->sec_info[tail->id].u.list;
12060                   htab->sec_info[tail->id].u.group = group;
12061                 }
12062             }
12063           tail = prev;
12064         }
12065     }
12066   return TRUE;
12067 }
12068
12069 static const unsigned char glink_eh_frame_cie[] =
12070 {
12071   0, 0, 0, 16,                          /* length.  */
12072   0, 0, 0, 0,                           /* id.  */
12073   1,                                    /* CIE version.  */
12074   'z', 'R', 0,                          /* Augmentation string.  */
12075   4,                                    /* Code alignment.  */
12076   0x78,                                 /* Data alignment.  */
12077   65,                                   /* RA reg.  */
12078   1,                                    /* Augmentation size.  */
12079   DW_EH_PE_pcrel | DW_EH_PE_sdata4,     /* FDE encoding.  */
12080   DW_CFA_def_cfa, 1, 0,                 /* def_cfa: r1 offset 0.  */
12081   0, 0, 0, 0
12082 };
12083
12084 /* Stripping output sections is normally done before dynamic section
12085    symbols have been allocated.  This function is called later, and
12086    handles cases like htab->brlt which is mapped to its own output
12087    section.  */
12088
12089 static void
12090 maybe_strip_output (struct bfd_link_info *info, asection *isec)
12091 {
12092   if (isec->size == 0
12093       && isec->output_section->size == 0
12094       && !(isec->output_section->flags & SEC_KEEP)
12095       && !bfd_section_removed_from_list (info->output_bfd,
12096                                          isec->output_section)
12097       && elf_section_data (isec->output_section)->dynindx == 0)
12098     {
12099       isec->output_section->flags |= SEC_EXCLUDE;
12100       bfd_section_list_remove (info->output_bfd, isec->output_section);
12101       info->output_bfd->section_count--;
12102     }
12103 }
12104
12105 /* Determine and set the size of the stub section for a final link.
12106
12107    The basic idea here is to examine all the relocations looking for
12108    PC-relative calls to a target that is unreachable with a "bl"
12109    instruction.  */
12110
12111 bfd_boolean
12112 ppc64_elf_size_stubs (struct bfd_link_info *info)
12113 {
12114   bfd_size_type stub_group_size;
12115   bfd_boolean stubs_always_before_branch;
12116   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12117
12118   if (htab == NULL)
12119     return FALSE;
12120
12121   if (htab->params->plt_thread_safe == -1 && !bfd_link_executable (info))
12122     htab->params->plt_thread_safe = 1;
12123   if (!htab->opd_abi)
12124     htab->params->plt_thread_safe = 0;
12125   else if (htab->params->plt_thread_safe == -1)
12126     {
12127       static const char *const thread_starter[] =
12128         {
12129           "pthread_create",
12130           /* libstdc++ */
12131           "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
12132           /* librt */
12133           "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
12134           "mq_notify", "create_timer",
12135           /* libanl */
12136           "getaddrinfo_a",
12137           /* libgomp */
12138           "GOMP_parallel",
12139           "GOMP_parallel_start",
12140           "GOMP_parallel_loop_static",
12141           "GOMP_parallel_loop_static_start",
12142           "GOMP_parallel_loop_dynamic",
12143           "GOMP_parallel_loop_dynamic_start",
12144           "GOMP_parallel_loop_guided",
12145           "GOMP_parallel_loop_guided_start",
12146           "GOMP_parallel_loop_runtime",
12147           "GOMP_parallel_loop_runtime_start",
12148           "GOMP_parallel_sections",
12149           "GOMP_parallel_sections_start",
12150           /* libgo */
12151           "__go_go",
12152         };
12153       unsigned i;
12154
12155       for (i = 0; i < ARRAY_SIZE (thread_starter); i++)
12156         {
12157           struct elf_link_hash_entry *h;
12158           h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
12159                                     FALSE, FALSE, TRUE);
12160           htab->params->plt_thread_safe = h != NULL && h->ref_regular;
12161           if (htab->params->plt_thread_safe)
12162             break;
12163         }
12164     }
12165   stubs_always_before_branch = htab->params->group_size < 0;
12166   if (htab->params->group_size < 0)
12167     stub_group_size = -htab->params->group_size;
12168   else
12169     stub_group_size = htab->params->group_size;
12170
12171   if (!group_sections (info, stub_group_size, stubs_always_before_branch))
12172     return FALSE;
12173
12174   while (1)
12175     {
12176       bfd *input_bfd;
12177       unsigned int bfd_indx;
12178       struct map_stub *group;
12179       asection *stub_sec;
12180
12181       htab->stub_iteration += 1;
12182
12183       for (input_bfd = info->input_bfds, bfd_indx = 0;
12184            input_bfd != NULL;
12185            input_bfd = input_bfd->link.next, bfd_indx++)
12186         {
12187           Elf_Internal_Shdr *symtab_hdr;
12188           asection *section;
12189           Elf_Internal_Sym *local_syms = NULL;
12190
12191           if (!is_ppc64_elf (input_bfd))
12192             continue;
12193
12194           /* We'll need the symbol table in a second.  */
12195           symtab_hdr = &elf_symtab_hdr (input_bfd);
12196           if (symtab_hdr->sh_info == 0)
12197             continue;
12198
12199           /* Walk over each section attached to the input bfd.  */
12200           for (section = input_bfd->sections;
12201                section != NULL;
12202                section = section->next)
12203             {
12204               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
12205
12206               /* If there aren't any relocs, then there's nothing more
12207                  to do.  */
12208               if ((section->flags & SEC_RELOC) == 0
12209                   || (section->flags & SEC_ALLOC) == 0
12210                   || (section->flags & SEC_LOAD) == 0
12211                   || (section->flags & SEC_CODE) == 0
12212                   || section->reloc_count == 0)
12213                 continue;
12214
12215               /* If this section is a link-once section that will be
12216                  discarded, then don't create any stubs.  */
12217               if (section->output_section == NULL
12218                   || section->output_section->owner != info->output_bfd)
12219                 continue;
12220
12221               /* Get the relocs.  */
12222               internal_relocs
12223                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
12224                                              info->keep_memory);
12225               if (internal_relocs == NULL)
12226                 goto error_ret_free_local;
12227
12228               /* Now examine each relocation.  */
12229               irela = internal_relocs;
12230               irelaend = irela + section->reloc_count;
12231               for (; irela < irelaend; irela++)
12232                 {
12233                   enum elf_ppc64_reloc_type r_type;
12234                   unsigned int r_indx;
12235                   enum ppc_stub_type stub_type;
12236                   struct ppc_stub_hash_entry *stub_entry;
12237                   asection *sym_sec, *code_sec;
12238                   bfd_vma sym_value, code_value;
12239                   bfd_vma destination;
12240                   unsigned long local_off;
12241                   bfd_boolean ok_dest;
12242                   struct ppc_link_hash_entry *hash;
12243                   struct ppc_link_hash_entry *fdh;
12244                   struct elf_link_hash_entry *h;
12245                   Elf_Internal_Sym *sym;
12246                   char *stub_name;
12247                   const asection *id_sec;
12248                   struct _opd_sec_data *opd;
12249                   struct plt_entry *plt_ent;
12250
12251                   r_type = ELF64_R_TYPE (irela->r_info);
12252                   r_indx = ELF64_R_SYM (irela->r_info);
12253
12254                   if (r_type >= R_PPC64_max)
12255                     {
12256                       bfd_set_error (bfd_error_bad_value);
12257                       goto error_ret_free_internal;
12258                     }
12259
12260                   /* Only look for stubs on branch instructions.  */
12261                   if (r_type != R_PPC64_REL24
12262                       && r_type != R_PPC64_REL14
12263                       && r_type != R_PPC64_REL14_BRTAKEN
12264                       && r_type != R_PPC64_REL14_BRNTAKEN)
12265                     continue;
12266
12267                   /* Now determine the call target, its name, value,
12268                      section.  */
12269                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12270                                   r_indx, input_bfd))
12271                     goto error_ret_free_internal;
12272                   hash = (struct ppc_link_hash_entry *) h;
12273
12274                   ok_dest = FALSE;
12275                   fdh = NULL;
12276                   sym_value = 0;
12277                   if (hash == NULL)
12278                     {
12279                       sym_value = sym->st_value;
12280                       if (sym_sec != NULL
12281                           && sym_sec->output_section != NULL)
12282                         ok_dest = TRUE;
12283                     }
12284                   else if (hash->elf.root.type == bfd_link_hash_defined
12285                            || hash->elf.root.type == bfd_link_hash_defweak)
12286                     {
12287                       sym_value = hash->elf.root.u.def.value;
12288                       if (sym_sec->output_section != NULL)
12289                         ok_dest = TRUE;
12290                     }
12291                   else if (hash->elf.root.type == bfd_link_hash_undefweak
12292                            || hash->elf.root.type == bfd_link_hash_undefined)
12293                     {
12294                       /* Recognise an old ABI func code entry sym, and
12295                          use the func descriptor sym instead if it is
12296                          defined.  */
12297                       if (hash->elf.root.root.string[0] == '.'
12298                           && (fdh = lookup_fdh (hash, htab)) != NULL)
12299                         {
12300                           if (fdh->elf.root.type == bfd_link_hash_defined
12301                               || fdh->elf.root.type == bfd_link_hash_defweak)
12302                             {
12303                               sym_sec = fdh->elf.root.u.def.section;
12304                               sym_value = fdh->elf.root.u.def.value;
12305                               if (sym_sec->output_section != NULL)
12306                                 ok_dest = TRUE;
12307                             }
12308                           else
12309                             fdh = NULL;
12310                         }
12311                     }
12312                   else
12313                     {
12314                       bfd_set_error (bfd_error_bad_value);
12315                       goto error_ret_free_internal;
12316                     }
12317
12318                   destination = 0;
12319                   local_off = 0;
12320                   if (ok_dest)
12321                     {
12322                       sym_value += irela->r_addend;
12323                       destination = (sym_value
12324                                      + sym_sec->output_offset
12325                                      + sym_sec->output_section->vma);
12326                       local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12327                                                             ? hash->elf.other
12328                                                             : sym->st_other);
12329                     }
12330
12331                   code_sec = sym_sec;
12332                   code_value = sym_value;
12333                   opd = get_opd_info (sym_sec);
12334                   if (opd != NULL)
12335                     {
12336                       bfd_vma dest;
12337
12338                       if (hash == NULL && opd->adjust != NULL)
12339                         {
12340                           long adjust = opd->adjust[OPD_NDX (sym_value)];
12341                           if (adjust == -1)
12342                             continue;
12343                           code_value += adjust;
12344                           sym_value += adjust;
12345                         }
12346                       dest = opd_entry_value (sym_sec, sym_value,
12347                                               &code_sec, &code_value, FALSE);
12348                       if (dest != (bfd_vma) -1)
12349                         {
12350                           destination = dest;
12351                           if (fdh != NULL)
12352                             {
12353                               /* Fixup old ABI sym to point at code
12354                                  entry.  */
12355                               hash->elf.root.type = bfd_link_hash_defweak;
12356                               hash->elf.root.u.def.section = code_sec;
12357                               hash->elf.root.u.def.value = code_value;
12358                             }
12359                         }
12360                     }
12361
12362                   /* Determine what (if any) linker stub is needed.  */
12363                   plt_ent = NULL;
12364                   stub_type = ppc_type_of_stub (section, irela, &hash,
12365                                                 &plt_ent, destination,
12366                                                 local_off);
12367
12368                   if (stub_type != ppc_stub_plt_call)
12369                     {
12370                       /* Check whether we need a TOC adjusting stub.
12371                          Since the linker pastes together pieces from
12372                          different object files when creating the
12373                          _init and _fini functions, it may be that a
12374                          call to what looks like a local sym is in
12375                          fact a call needing a TOC adjustment.  */
12376                       if (code_sec != NULL
12377                           && code_sec->output_section != NULL
12378                           && (htab->sec_info[code_sec->id].toc_off
12379                               != htab->sec_info[section->id].toc_off)
12380                           && (code_sec->has_toc_reloc
12381                               || code_sec->makes_toc_func_call))
12382                         stub_type = ppc_stub_long_branch_r2off;
12383                     }
12384
12385                   if (stub_type == ppc_stub_none)
12386                     continue;
12387
12388                   /* __tls_get_addr calls might be eliminated.  */
12389                   if (stub_type != ppc_stub_plt_call
12390                       && hash != NULL
12391                       && (hash == htab->tls_get_addr
12392                           || hash == htab->tls_get_addr_fd)
12393                       && section->has_tls_reloc
12394                       && irela != internal_relocs)
12395                     {
12396                       /* Get tls info.  */
12397                       unsigned char *tls_mask;
12398
12399                       if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12400                                          irela - 1, input_bfd))
12401                         goto error_ret_free_internal;
12402                       if (*tls_mask != 0)
12403                         continue;
12404                     }
12405
12406                   if (stub_type == ppc_stub_plt_call
12407                       && irela + 1 < irelaend
12408                       && irela[1].r_offset == irela->r_offset + 4
12409                       && ELF64_R_TYPE (irela[1].r_info) == R_PPC64_TOCSAVE)
12410                     {
12411                       if (!tocsave_find (htab, INSERT,
12412                                          &local_syms, irela + 1, input_bfd))
12413                         goto error_ret_free_internal;
12414                     }
12415                   else if (stub_type == ppc_stub_plt_call)
12416                     stub_type = ppc_stub_plt_call_r2save;
12417
12418                   /* Support for grouping stub sections.  */
12419                   id_sec = htab->sec_info[section->id].u.group->link_sec;
12420
12421                   /* Get the name of this stub.  */
12422                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12423                   if (!stub_name)
12424                     goto error_ret_free_internal;
12425
12426                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12427                                                      stub_name, FALSE, FALSE);
12428                   if (stub_entry != NULL)
12429                     {
12430                       /* The proper stub has already been created.  */
12431                       free (stub_name);
12432                       if (stub_type == ppc_stub_plt_call_r2save)
12433                         stub_entry->stub_type = stub_type;
12434                       continue;
12435                     }
12436
12437                   stub_entry = ppc_add_stub (stub_name, section, info);
12438                   if (stub_entry == NULL)
12439                     {
12440                       free (stub_name);
12441                     error_ret_free_internal:
12442                       if (elf_section_data (section)->relocs == NULL)
12443                         free (internal_relocs);
12444                     error_ret_free_local:
12445                       if (local_syms != NULL
12446                           && (symtab_hdr->contents
12447                               != (unsigned char *) local_syms))
12448                         free (local_syms);
12449                       return FALSE;
12450                     }
12451
12452                   stub_entry->stub_type = stub_type;
12453                   if (stub_type != ppc_stub_plt_call
12454                       && stub_type != ppc_stub_plt_call_r2save)
12455                     {
12456                       stub_entry->target_value = code_value;
12457                       stub_entry->target_section = code_sec;
12458                     }
12459                   else
12460                     {
12461                       stub_entry->target_value = sym_value;
12462                       stub_entry->target_section = sym_sec;
12463                     }
12464                   stub_entry->h = hash;
12465                   stub_entry->plt_ent = plt_ent;
12466                   stub_entry->other = hash ? hash->elf.other : sym->st_other;
12467
12468                   if (stub_entry->h != NULL)
12469                     htab->stub_globals += 1;
12470                 }
12471
12472               /* We're done with the internal relocs, free them.  */
12473               if (elf_section_data (section)->relocs != internal_relocs)
12474                 free (internal_relocs);
12475             }
12476
12477           if (local_syms != NULL
12478               && symtab_hdr->contents != (unsigned char *) local_syms)
12479             {
12480               if (!info->keep_memory)
12481                 free (local_syms);
12482               else
12483                 symtab_hdr->contents = (unsigned char *) local_syms;
12484             }
12485         }
12486
12487       /* We may have added some stubs.  Find out the new size of the
12488          stub sections.  */
12489       for (stub_sec = htab->params->stub_bfd->sections;
12490            stub_sec != NULL;
12491            stub_sec = stub_sec->next)
12492         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12493           {
12494             stub_sec->rawsize = stub_sec->size;
12495             stub_sec->size = 0;
12496             stub_sec->reloc_count = 0;
12497             stub_sec->flags &= ~SEC_RELOC;
12498           }
12499
12500       htab->brlt->size = 0;
12501       htab->brlt->reloc_count = 0;
12502       htab->brlt->flags &= ~SEC_RELOC;
12503       if (htab->relbrlt != NULL)
12504         htab->relbrlt->size = 0;
12505
12506       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12507
12508       for (group = htab->group; group != NULL; group = group->next)
12509         if (group->needs_save_res)
12510           group->stub_sec->size += htab->sfpr->size;
12511
12512       if (info->emitrelocations
12513           && htab->glink != NULL && htab->glink->size != 0)
12514         {
12515           htab->glink->reloc_count = 1;
12516           htab->glink->flags |= SEC_RELOC;
12517         }
12518
12519       if (htab->glink_eh_frame != NULL
12520           && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12521           && htab->glink_eh_frame->output_section->size != 0)
12522         {
12523           size_t size = 0, align;
12524
12525           for (stub_sec = htab->params->stub_bfd->sections;
12526                stub_sec != NULL;
12527                stub_sec = stub_sec->next)
12528             if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12529               size += 24;
12530           if (htab->glink != NULL && htab->glink->size != 0)
12531             size += 24;
12532           if (size != 0)
12533             size += sizeof (glink_eh_frame_cie);
12534           align = 1;
12535           align <<= htab->glink_eh_frame->output_section->alignment_power;
12536           align -= 1;
12537           size = (size + align) & ~align;
12538           htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12539           htab->glink_eh_frame->size = size;
12540         }
12541
12542       if (htab->params->plt_stub_align != 0)
12543         for (stub_sec = htab->params->stub_bfd->sections;
12544              stub_sec != NULL;
12545              stub_sec = stub_sec->next)
12546           if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12547             stub_sec->size = ((stub_sec->size
12548                                + (1 << htab->params->plt_stub_align) - 1)
12549                               & -(1 << htab->params->plt_stub_align));
12550
12551       for (stub_sec = htab->params->stub_bfd->sections;
12552            stub_sec != NULL;
12553            stub_sec = stub_sec->next)
12554         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12555             && stub_sec->rawsize != stub_sec->size)
12556           break;
12557
12558       /* Exit from this loop when no stubs have been added, and no stubs
12559          have changed size.  */
12560       if (stub_sec == NULL
12561           && (htab->glink_eh_frame == NULL
12562               || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12563         break;
12564
12565       /* Ask the linker to do its stuff.  */
12566       (*htab->params->layout_sections_again) ();
12567     }
12568
12569   if (htab->glink_eh_frame != NULL
12570       && htab->glink_eh_frame->size != 0)
12571     {
12572       bfd_vma val;
12573       bfd_byte *p, *last_fde;
12574       size_t last_fde_len, size, align, pad;
12575       asection *stub_sec;
12576
12577       p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12578       if (p == NULL)
12579         return FALSE;
12580       htab->glink_eh_frame->contents = p;
12581       last_fde = p;
12582
12583       memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12584       /* CIE length (rewrite in case little-endian).  */
12585       last_fde_len = sizeof (glink_eh_frame_cie) - 4;
12586       bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12587       p += sizeof (glink_eh_frame_cie);
12588
12589       for (stub_sec = htab->params->stub_bfd->sections;
12590            stub_sec != NULL;
12591            stub_sec = stub_sec->next)
12592         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12593           {
12594             last_fde = p;
12595             last_fde_len = 20;
12596             /* FDE length.  */
12597             bfd_put_32 (htab->elf.dynobj, 20, p);
12598             p += 4;
12599             /* CIE pointer.  */
12600             val = p - htab->glink_eh_frame->contents;
12601             bfd_put_32 (htab->elf.dynobj, val, p);
12602             p += 4;
12603             /* Offset to stub section, written later.  */
12604             p += 4;
12605             /* stub section size.  */
12606             bfd_put_32 (htab->elf.dynobj, stub_sec->size, p);
12607             p += 4;
12608             /* Augmentation.  */
12609             p += 1;
12610             /* Pad.  */
12611             p += 7;
12612           }
12613       if (htab->glink != NULL && htab->glink->size != 0)
12614         {
12615           last_fde = p;
12616           last_fde_len = 20;
12617           /* FDE length.  */
12618           bfd_put_32 (htab->elf.dynobj, 20, p);
12619           p += 4;
12620           /* CIE pointer.  */
12621           val = p - htab->glink_eh_frame->contents;
12622           bfd_put_32 (htab->elf.dynobj, val, p);
12623           p += 4;
12624           /* Offset to .glink, written later.  */
12625           p += 4;
12626           /* .glink size.  */
12627           bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12628           p += 4;
12629           /* Augmentation.  */
12630           p += 1;
12631
12632           *p++ = DW_CFA_advance_loc + 1;
12633           *p++ = DW_CFA_register;
12634           *p++ = 65;
12635           *p++ = htab->opd_abi ? 12 : 0;
12636           *p++ = DW_CFA_advance_loc + 4;
12637           *p++ = DW_CFA_restore_extended;
12638           *p++ = 65;
12639         }
12640       /* Subsume any padding into the last FDE if user .eh_frame
12641          sections are aligned more than glink_eh_frame.  Otherwise any
12642          zero padding will be seen as a terminator.  */
12643       size = p - htab->glink_eh_frame->contents;
12644       align = 1;
12645       align <<= htab->glink_eh_frame->output_section->alignment_power;
12646       align -= 1;
12647       pad = ((size + align) & ~align) - size;
12648       htab->glink_eh_frame->size = size + pad;
12649       bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12650     }
12651
12652   maybe_strip_output (info, htab->brlt);
12653   if (htab->glink_eh_frame != NULL)
12654     maybe_strip_output (info, htab->glink_eh_frame);
12655
12656   return TRUE;
12657 }
12658
12659 /* Called after we have determined section placement.  If sections
12660    move, we'll be called again.  Provide a value for TOCstart.  */
12661
12662 bfd_vma
12663 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12664 {
12665   asection *s;
12666   bfd_vma TOCstart, adjust;
12667
12668   if (info != NULL)
12669     {
12670       struct elf_link_hash_entry *h;
12671       struct elf_link_hash_table *htab = elf_hash_table (info);
12672
12673       if (is_elf_hash_table (htab)
12674           && htab->hgot != NULL)
12675         h = htab->hgot;
12676       else
12677         {
12678           h = elf_link_hash_lookup (htab, ".TOC.", FALSE, FALSE, TRUE);
12679           if (is_elf_hash_table (htab))
12680             htab->hgot = h;
12681         }
12682       if (h != NULL
12683           && h->root.type == bfd_link_hash_defined
12684           && !h->root.linker_def
12685           && (!is_elf_hash_table (htab)
12686               || h->def_regular))
12687         {
12688           TOCstart = (h->root.u.def.value - TOC_BASE_OFF
12689                       + h->root.u.def.section->output_offset
12690                       + h->root.u.def.section->output_section->vma);
12691           _bfd_set_gp_value (obfd, TOCstart);
12692           return TOCstart;
12693         }
12694     }
12695
12696   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12697      order.  The TOC starts where the first of these sections starts.  */
12698   s = bfd_get_section_by_name (obfd, ".got");
12699   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12700     s = bfd_get_section_by_name (obfd, ".toc");
12701   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12702     s = bfd_get_section_by_name (obfd, ".tocbss");
12703   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12704     s = bfd_get_section_by_name (obfd, ".plt");
12705   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12706     {
12707       /* This may happen for
12708          o  references to TOC base (SYM@toc / TOC[tc0]) without a
12709          .toc directive
12710          o  bad linker script
12711          o --gc-sections and empty TOC sections
12712
12713          FIXME: Warn user?  */
12714
12715       /* Look for a likely section.  We probably won't even be
12716          using TOCstart.  */
12717       for (s = obfd->sections; s != NULL; s = s->next)
12718         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
12719                          | SEC_EXCLUDE))
12720             == (SEC_ALLOC | SEC_SMALL_DATA))
12721           break;
12722       if (s == NULL)
12723         for (s = obfd->sections; s != NULL; s = s->next)
12724           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
12725               == (SEC_ALLOC | SEC_SMALL_DATA))
12726             break;
12727       if (s == NULL)
12728         for (s = obfd->sections; s != NULL; s = s->next)
12729           if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
12730               == SEC_ALLOC)
12731             break;
12732       if (s == NULL)
12733         for (s = obfd->sections; s != NULL; s = s->next)
12734           if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
12735             break;
12736     }
12737
12738   TOCstart = 0;
12739   if (s != NULL)
12740     TOCstart = s->output_section->vma + s->output_offset;
12741
12742   /* Force alignment.  */
12743   adjust = TOCstart & (TOC_BASE_ALIGN - 1);
12744   TOCstart -= adjust;
12745   _bfd_set_gp_value (obfd, TOCstart);
12746
12747   if (info != NULL && s != NULL)
12748     {
12749       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12750
12751       if (htab != NULL)
12752         {
12753           if (htab->elf.hgot != NULL)
12754             {
12755               htab->elf.hgot->root.u.def.value = TOC_BASE_OFF - adjust;
12756               htab->elf.hgot->root.u.def.section = s;
12757             }
12758         }
12759       else
12760         {
12761           struct bfd_link_hash_entry *bh = NULL;
12762           _bfd_generic_link_add_one_symbol (info, obfd, ".TOC.", BSF_GLOBAL,
12763                                             s, TOC_BASE_OFF - adjust,
12764                                             NULL, FALSE, FALSE, &bh);
12765         }
12766     }
12767   return TOCstart;
12768 }
12769
12770 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
12771    write out any global entry stubs.  */
12772
12773 static bfd_boolean
12774 build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
12775 {
12776   struct bfd_link_info *info;
12777   struct ppc_link_hash_table *htab;
12778   struct plt_entry *pent;
12779   asection *s;
12780
12781   if (h->root.type == bfd_link_hash_indirect)
12782     return TRUE;
12783
12784   if (!h->pointer_equality_needed)
12785     return TRUE;
12786
12787   if (h->def_regular)
12788     return TRUE;
12789
12790   info = inf;
12791   htab = ppc_hash_table (info);
12792   if (htab == NULL)
12793     return FALSE;
12794
12795   s = htab->glink;
12796   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
12797     if (pent->plt.offset != (bfd_vma) -1
12798         && pent->addend == 0)
12799       {
12800         bfd_byte *p;
12801         asection *plt;
12802         bfd_vma off;
12803
12804         p = s->contents + h->root.u.def.value;
12805         plt = htab->elf.splt;
12806         if (!htab->elf.dynamic_sections_created
12807             || h->dynindx == -1)
12808           plt = htab->elf.iplt;
12809         off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
12810         off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
12811
12812         if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
12813           {
12814             info->callbacks->einfo
12815               (_("%P: linkage table error against `%T'\n"),
12816                h->root.root.string);
12817             bfd_set_error (bfd_error_bad_value);
12818             htab->stub_error = TRUE;
12819           }
12820
12821         htab->stub_count[ppc_stub_global_entry - 1] += 1;
12822         if (htab->params->emit_stub_syms)
12823           {
12824             size_t len = strlen (h->root.root.string);
12825             char *name = bfd_malloc (sizeof "12345678.global_entry." + len);
12826
12827             if (name == NULL)
12828               return FALSE;
12829
12830             sprintf (name, "%08x.global_entry.%s", s->id, h->root.root.string);
12831             h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
12832             if (h == NULL)
12833               return FALSE;
12834             if (h->root.type == bfd_link_hash_new)
12835               {
12836                 h->root.type = bfd_link_hash_defined;
12837                 h->root.u.def.section = s;
12838                 h->root.u.def.value = p - s->contents;
12839                 h->ref_regular = 1;
12840                 h->def_regular = 1;
12841                 h->ref_regular_nonweak = 1;
12842                 h->forced_local = 1;
12843                 h->non_elf = 0;
12844                 h->root.linker_def = 1;
12845               }
12846           }
12847
12848         if (PPC_HA (off) != 0)
12849           {
12850             bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
12851             p += 4;
12852           }
12853         bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
12854         p += 4;
12855         bfd_put_32 (s->owner, MTCTR_R12, p);
12856         p += 4;
12857         bfd_put_32 (s->owner, BCTR, p);
12858         break;
12859       }
12860   return TRUE;
12861 }
12862
12863 /* Build all the stubs associated with the current output file.
12864    The stubs are kept in a hash table attached to the main linker
12865    hash table.  This function is called via gldelf64ppc_finish.  */
12866
12867 bfd_boolean
12868 ppc64_elf_build_stubs (struct bfd_link_info *info,
12869                        char **stats)
12870 {
12871   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12872   struct map_stub *group;
12873   asection *stub_sec;
12874   bfd_byte *p;
12875   int stub_sec_count = 0;
12876
12877   if (htab == NULL)
12878     return FALSE;
12879
12880   /* Allocate memory to hold the linker stubs.  */
12881   for (stub_sec = htab->params->stub_bfd->sections;
12882        stub_sec != NULL;
12883        stub_sec = stub_sec->next)
12884     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12885         && stub_sec->size != 0)
12886       {
12887         stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
12888         if (stub_sec->contents == NULL)
12889           return FALSE;
12890         /* We want to check that built size is the same as calculated
12891            size.  rawsize is a convenient location to use.  */
12892         stub_sec->rawsize = stub_sec->size;
12893         stub_sec->size = 0;
12894       }
12895
12896   if (htab->glink != NULL && htab->glink->size != 0)
12897     {
12898       unsigned int indx;
12899       bfd_vma plt0;
12900
12901       /* Build the .glink plt call stub.  */
12902       if (htab->params->emit_stub_syms)
12903         {
12904           struct elf_link_hash_entry *h;
12905           h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
12906                                     TRUE, FALSE, FALSE);
12907           if (h == NULL)
12908             return FALSE;
12909           if (h->root.type == bfd_link_hash_new)
12910             {
12911               h->root.type = bfd_link_hash_defined;
12912               h->root.u.def.section = htab->glink;
12913               h->root.u.def.value = 8;
12914               h->ref_regular = 1;
12915               h->def_regular = 1;
12916               h->ref_regular_nonweak = 1;
12917               h->forced_local = 1;
12918               h->non_elf = 0;
12919               h->root.linker_def = 1;
12920             }
12921         }
12922       plt0 = (htab->elf.splt->output_section->vma
12923               + htab->elf.splt->output_offset
12924               - 16);
12925       if (info->emitrelocations)
12926         {
12927           Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
12928           if (r == NULL)
12929             return FALSE;
12930           r->r_offset = (htab->glink->output_offset
12931                          + htab->glink->output_section->vma);
12932           r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
12933           r->r_addend = plt0;
12934         }
12935       p = htab->glink->contents;
12936       plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
12937       bfd_put_64 (htab->glink->owner, plt0, p);
12938       p += 8;
12939       if (htab->opd_abi)
12940         {
12941           bfd_put_32 (htab->glink->owner, MFLR_R12, p);
12942           p += 4;
12943           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12944           p += 4;
12945           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12946           p += 4;
12947           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12948           p += 4;
12949           bfd_put_32 (htab->glink->owner, MTLR_R12, p);
12950           p += 4;
12951           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12952           p += 4;
12953           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12954           p += 4;
12955           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
12956           p += 4;
12957           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12958           p += 4;
12959           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
12960           p += 4;
12961         }
12962       else
12963         {
12964           bfd_put_32 (htab->glink->owner, MFLR_R0, p);
12965           p += 4;
12966           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12967           p += 4;
12968           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12969           p += 4;
12970           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12971           p += 4;
12972           bfd_put_32 (htab->glink->owner, MTLR_R0, p);
12973           p += 4;
12974           bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
12975           p += 4;
12976           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12977           p += 4;
12978           bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
12979           p += 4;
12980           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12981           p += 4;
12982           bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
12983           p += 4;
12984           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12985           p += 4;
12986           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
12987           p += 4;
12988         }
12989       bfd_put_32 (htab->glink->owner, BCTR, p);
12990       p += 4;
12991       while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
12992         {
12993           bfd_put_32 (htab->glink->owner, NOP, p);
12994           p += 4;
12995         }
12996
12997       /* Build the .glink lazy link call stubs.  */
12998       indx = 0;
12999       while (p < htab->glink->contents + htab->glink->rawsize)
13000         {
13001           if (htab->opd_abi)
13002             {
13003               if (indx < 0x8000)
13004                 {
13005                   bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
13006                   p += 4;
13007                 }
13008               else
13009                 {
13010                   bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
13011                   p += 4;
13012                   bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
13013                               p);
13014                   p += 4;
13015                 }
13016             }
13017           bfd_put_32 (htab->glink->owner,
13018                       B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
13019           indx++;
13020           p += 4;
13021         }
13022
13023       /* Build .glink global entry stubs.  */
13024       if (htab->glink->size > htab->glink->rawsize)
13025         elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
13026     }
13027
13028   if (htab->brlt != NULL && htab->brlt->size != 0)
13029     {
13030       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
13031                                          htab->brlt->size);
13032       if (htab->brlt->contents == NULL)
13033         return FALSE;
13034     }
13035   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
13036     {
13037       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
13038                                             htab->relbrlt->size);
13039       if (htab->relbrlt->contents == NULL)
13040         return FALSE;
13041     }
13042
13043   /* Build the stubs as directed by the stub hash table.  */
13044   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
13045
13046   for (group = htab->group; group != NULL; group = group->next)
13047     if (group->needs_save_res)
13048       {
13049         stub_sec = group->stub_sec;
13050         memcpy (stub_sec->contents + stub_sec->size, htab->sfpr->contents,
13051                 htab->sfpr->size);
13052         if (htab->params->emit_stub_syms)
13053           {
13054             unsigned int i;
13055
13056             for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
13057               if (!sfpr_define (info, &save_res_funcs[i], stub_sec))
13058                 return FALSE;
13059           }
13060         stub_sec->size += htab->sfpr->size;
13061       }
13062
13063   if (htab->relbrlt != NULL)
13064     htab->relbrlt->reloc_count = 0;
13065
13066   if (htab->params->plt_stub_align != 0)
13067     for (stub_sec = htab->params->stub_bfd->sections;
13068          stub_sec != NULL;
13069          stub_sec = stub_sec->next)
13070       if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
13071         stub_sec->size = ((stub_sec->size
13072                            + (1 << htab->params->plt_stub_align) - 1)
13073                           & -(1 << htab->params->plt_stub_align));
13074
13075   for (stub_sec = htab->params->stub_bfd->sections;
13076        stub_sec != NULL;
13077        stub_sec = stub_sec->next)
13078     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
13079       {
13080         stub_sec_count += 1;
13081         if (stub_sec->rawsize != stub_sec->size)
13082           break;
13083       }
13084
13085   /* Note that the glink_eh_frame check here is not only testing that
13086      the generated size matched the calculated size but also that
13087      bfd_elf_discard_info didn't make any changes to the section.  */
13088   if (stub_sec != NULL
13089       || (htab->glink_eh_frame != NULL
13090           && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
13091     {
13092       htab->stub_error = TRUE;
13093       info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
13094     }
13095
13096   if (htab->stub_error)
13097     return FALSE;
13098
13099   if (stats != NULL)
13100     {
13101       *stats = bfd_malloc (500);
13102       if (*stats == NULL)
13103         return FALSE;
13104
13105       sprintf (*stats, _("linker stubs in %u group%s\n"
13106                          "  branch       %lu\n"
13107                          "  toc adjust   %lu\n"
13108                          "  long branch  %lu\n"
13109                          "  long toc adj %lu\n"
13110                          "  plt call     %lu\n"
13111                          "  plt call toc %lu\n"
13112                          "  global entry %lu"),
13113                stub_sec_count,
13114                stub_sec_count == 1 ? "" : "s",
13115                htab->stub_count[ppc_stub_long_branch - 1],
13116                htab->stub_count[ppc_stub_long_branch_r2off - 1],
13117                htab->stub_count[ppc_stub_plt_branch - 1],
13118                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
13119                htab->stub_count[ppc_stub_plt_call - 1],
13120                htab->stub_count[ppc_stub_plt_call_r2save - 1],
13121                htab->stub_count[ppc_stub_global_entry - 1]);
13122     }
13123   return TRUE;
13124 }
13125
13126 /* This function undoes the changes made by add_symbol_adjust.  */
13127
13128 static bfd_boolean
13129 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
13130 {
13131   struct ppc_link_hash_entry *eh;
13132
13133   if (h->root.type == bfd_link_hash_indirect)
13134     return TRUE;
13135
13136   eh = (struct ppc_link_hash_entry *) h;
13137   if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
13138     return TRUE;
13139
13140   eh->elf.root.type = bfd_link_hash_undefined;
13141   return TRUE;
13142 }
13143
13144 void
13145 ppc64_elf_restore_symbols (struct bfd_link_info *info)
13146 {
13147   struct ppc_link_hash_table *htab = ppc_hash_table (info);
13148
13149   if (htab != NULL)
13150     elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
13151 }
13152
13153 /* What to do when ld finds relocations against symbols defined in
13154    discarded sections.  */
13155
13156 static unsigned int
13157 ppc64_elf_action_discarded (asection *sec)
13158 {
13159   if (strcmp (".opd", sec->name) == 0)
13160     return 0;
13161
13162   if (strcmp (".toc", sec->name) == 0)
13163     return 0;
13164
13165   if (strcmp (".toc1", sec->name) == 0)
13166     return 0;
13167
13168   return _bfd_elf_default_action_discarded (sec);
13169 }
13170
13171 /* The RELOCATE_SECTION function is called by the ELF backend linker
13172    to handle the relocations for a section.
13173
13174    The relocs are always passed as Rela structures; if the section
13175    actually uses Rel structures, the r_addend field will always be
13176    zero.
13177
13178    This function is responsible for adjust the section contents as
13179    necessary, and (if using Rela relocs and generating a
13180    relocatable output file) adjusting the reloc addend as
13181    necessary.
13182
13183    This function does not have to worry about setting the reloc
13184    address or the reloc symbol index.
13185
13186    LOCAL_SYMS is a pointer to the swapped in local symbols.
13187
13188    LOCAL_SECTIONS is an array giving the section in the input file
13189    corresponding to the st_shndx field of each local symbol.
13190
13191    The global hash table entry for the global symbols can be found
13192    via elf_sym_hashes (input_bfd).
13193
13194    When generating relocatable output, this function must handle
13195    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
13196    going to be the section symbol corresponding to the output
13197    section, which means that the addend must be adjusted
13198    accordingly.  */
13199
13200 static bfd_boolean
13201 ppc64_elf_relocate_section (bfd *output_bfd,
13202                             struct bfd_link_info *info,
13203                             bfd *input_bfd,
13204                             asection *input_section,
13205                             bfd_byte *contents,
13206                             Elf_Internal_Rela *relocs,
13207                             Elf_Internal_Sym *local_syms,
13208                             asection **local_sections)
13209 {
13210   struct ppc_link_hash_table *htab;
13211   Elf_Internal_Shdr *symtab_hdr;
13212   struct elf_link_hash_entry **sym_hashes;
13213   Elf_Internal_Rela *rel;
13214   Elf_Internal_Rela *wrel;
13215   Elf_Internal_Rela *relend;
13216   Elf_Internal_Rela outrel;
13217   bfd_byte *loc;
13218   struct got_entry **local_got_ents;
13219   bfd_vma TOCstart;
13220   bfd_boolean ret = TRUE;
13221   bfd_boolean is_opd;
13222   /* Assume 'at' branch hints.  */
13223   bfd_boolean is_isa_v2 = TRUE;
13224   bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
13225
13226   /* Initialize howto table if needed.  */
13227   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
13228     ppc_howto_init ();
13229
13230   htab = ppc_hash_table (info);
13231   if (htab == NULL)
13232     return FALSE;
13233
13234   /* Don't relocate stub sections.  */
13235   if (input_section->owner == htab->params->stub_bfd)
13236     return TRUE;
13237
13238   BFD_ASSERT (is_ppc64_elf (input_bfd));
13239
13240   local_got_ents = elf_local_got_ents (input_bfd);
13241   TOCstart = elf_gp (output_bfd);
13242   symtab_hdr = &elf_symtab_hdr (input_bfd);
13243   sym_hashes = elf_sym_hashes (input_bfd);
13244   is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
13245
13246   rel = wrel = relocs;
13247   relend = relocs + input_section->reloc_count;
13248   for (; rel < relend; wrel++, rel++)
13249     {
13250       enum elf_ppc64_reloc_type r_type;
13251       bfd_vma addend;
13252       bfd_reloc_status_type r;
13253       Elf_Internal_Sym *sym;
13254       asection *sec;
13255       struct elf_link_hash_entry *h_elf;
13256       struct ppc_link_hash_entry *h;
13257       struct ppc_link_hash_entry *fdh;
13258       const char *sym_name;
13259       unsigned long r_symndx, toc_symndx;
13260       bfd_vma toc_addend;
13261       unsigned char tls_mask, tls_gd, tls_type;
13262       unsigned char sym_type;
13263       bfd_vma relocation;
13264       bfd_boolean unresolved_reloc;
13265       bfd_boolean warned;
13266       enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
13267       unsigned int insn;
13268       unsigned int mask;
13269       struct ppc_stub_hash_entry *stub_entry;
13270       bfd_vma max_br_offset;
13271       bfd_vma from;
13272       Elf_Internal_Rela orig_rel;
13273       reloc_howto_type *howto;
13274       struct reloc_howto_struct alt_howto;
13275
13276     again:
13277       orig_rel = *rel;
13278
13279       r_type = ELF64_R_TYPE (rel->r_info);
13280       r_symndx = ELF64_R_SYM (rel->r_info);
13281
13282       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
13283          symbol of the previous ADDR64 reloc.  The symbol gives us the
13284          proper TOC base to use.  */
13285       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
13286           && wrel != relocs
13287           && ELF64_R_TYPE (wrel[-1].r_info) == R_PPC64_ADDR64
13288           && is_opd)
13289         r_symndx = ELF64_R_SYM (wrel[-1].r_info);
13290
13291       sym = NULL;
13292       sec = NULL;
13293       h_elf = NULL;
13294       sym_name = NULL;
13295       unresolved_reloc = FALSE;
13296       warned = FALSE;
13297
13298       if (r_symndx < symtab_hdr->sh_info)
13299         {
13300           /* It's a local symbol.  */
13301           struct _opd_sec_data *opd;
13302
13303           sym = local_syms + r_symndx;
13304           sec = local_sections[r_symndx];
13305           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
13306           sym_type = ELF64_ST_TYPE (sym->st_info);
13307           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
13308           opd = get_opd_info (sec);
13309           if (opd != NULL && opd->adjust != NULL)
13310             {
13311               long adjust = opd->adjust[OPD_NDX (sym->st_value
13312                                                  + rel->r_addend)];
13313               if (adjust == -1)
13314                 relocation = 0;
13315               else
13316                 {
13317                   /* If this is a relocation against the opd section sym
13318                      and we have edited .opd, adjust the reloc addend so
13319                      that ld -r and ld --emit-relocs output is correct.
13320                      If it is a reloc against some other .opd symbol,
13321                      then the symbol value will be adjusted later.  */
13322                   if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
13323                     rel->r_addend += adjust;
13324                   else
13325                     relocation += adjust;
13326                 }
13327             }
13328         }
13329       else
13330         {
13331           bfd_boolean ignored;
13332
13333           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
13334                                    r_symndx, symtab_hdr, sym_hashes,
13335                                    h_elf, sec, relocation,
13336                                    unresolved_reloc, warned, ignored);
13337           sym_name = h_elf->root.root.string;
13338           sym_type = h_elf->type;
13339           if (sec != NULL
13340               && sec->owner == output_bfd
13341               && strcmp (sec->name, ".opd") == 0)
13342             {
13343               /* This is a symbol defined in a linker script.  All
13344                  such are defined in output sections, even those
13345                  defined by simple assignment from a symbol defined in
13346                  an input section.  Transfer the symbol to an
13347                  appropriate input .opd section, so that a branch to
13348                  this symbol will be mapped to the location specified
13349                  by the opd entry.  */
13350               struct bfd_link_order *lo;
13351               for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
13352                 if (lo->type == bfd_indirect_link_order)
13353                   {
13354                     asection *isec = lo->u.indirect.section;
13355                     if (h_elf->root.u.def.value >= isec->output_offset
13356                         && h_elf->root.u.def.value < (isec->output_offset
13357                                                       + isec->size))
13358                       {
13359                         h_elf->root.u.def.value -= isec->output_offset;
13360                         h_elf->root.u.def.section = isec;
13361                         sec = isec;
13362                         break;
13363                       }
13364                   }
13365             }
13366         }
13367       h = (struct ppc_link_hash_entry *) h_elf;
13368
13369       if (sec != NULL && discarded_section (sec))
13370         {
13371           _bfd_clear_contents (ppc64_elf_howto_table[r_type],
13372                                input_bfd, input_section,
13373                                contents + rel->r_offset);
13374           wrel->r_offset = rel->r_offset;
13375           wrel->r_info = 0;
13376           wrel->r_addend = 0;
13377
13378           /* For ld -r, remove relocations in debug sections against
13379              sections defined in discarded sections.  Not done for
13380              non-debug to preserve relocs in .eh_frame which the
13381              eh_frame editing code expects to be present.  */
13382           if (bfd_link_relocatable (info)
13383               && (input_section->flags & SEC_DEBUGGING))
13384             wrel--;
13385
13386           continue;
13387         }
13388
13389       if (bfd_link_relocatable (info))
13390         goto copy_reloc;
13391
13392       if (h != NULL && &h->elf == htab->elf.hgot)
13393         {
13394           relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
13395           sec = bfd_abs_section_ptr;
13396           unresolved_reloc = FALSE;
13397         }
13398
13399       /* TLS optimizations.  Replace instruction sequences and relocs
13400          based on information we collected in tls_optimize.  We edit
13401          RELOCS so that --emit-relocs will output something sensible
13402          for the final instruction stream.  */
13403       tls_mask = 0;
13404       tls_gd = 0;
13405       toc_symndx = 0;
13406       if (h != NULL)
13407         tls_mask = h->tls_mask;
13408       else if (local_got_ents != NULL)
13409         {
13410           struct plt_entry **local_plt = (struct plt_entry **)
13411             (local_got_ents + symtab_hdr->sh_info);
13412           unsigned char *lgot_masks = (unsigned char *)
13413             (local_plt + symtab_hdr->sh_info);
13414           tls_mask = lgot_masks[r_symndx];
13415         }
13416       if (tls_mask == 0
13417           && (r_type == R_PPC64_TLS
13418               || r_type == R_PPC64_TLSGD
13419               || r_type == R_PPC64_TLSLD))
13420         {
13421           /* Check for toc tls entries.  */
13422           unsigned char *toc_tls;
13423
13424           if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13425                              &local_syms, rel, input_bfd))
13426             return FALSE;
13427
13428           if (toc_tls)
13429             tls_mask = *toc_tls;
13430         }
13431
13432       /* Check that tls relocs are used with tls syms, and non-tls
13433          relocs are used with non-tls syms.  */
13434       if (r_symndx != STN_UNDEF
13435           && r_type != R_PPC64_NONE
13436           && (h == NULL
13437               || h->elf.root.type == bfd_link_hash_defined
13438               || h->elf.root.type == bfd_link_hash_defweak)
13439           && (IS_PPC64_TLS_RELOC (r_type)
13440               != (sym_type == STT_TLS
13441                   || (sym_type == STT_SECTION
13442                       && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13443         {
13444           if (tls_mask != 0
13445               && (r_type == R_PPC64_TLS
13446                   || r_type == R_PPC64_TLSGD
13447                   || r_type == R_PPC64_TLSLD))
13448             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
13449             ;
13450           else
13451             info->callbacks->einfo
13452               (!IS_PPC64_TLS_RELOC (r_type)
13453                ? _("%P: %H: %s used with TLS symbol `%T'\n")
13454                : _("%P: %H: %s used with non-TLS symbol `%T'\n"),
13455                input_bfd, input_section, rel->r_offset,
13456                ppc64_elf_howto_table[r_type]->name,
13457                sym_name);
13458         }
13459
13460       /* Ensure reloc mapping code below stays sane.  */
13461       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13462           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13463           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
13464           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13465           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13466           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13467           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
13468           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13469           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13470           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13471         abort ();
13472
13473       switch (r_type)
13474         {
13475         default:
13476           break;
13477
13478         case R_PPC64_LO_DS_OPT:
13479           insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13480           if ((insn & (0x3f << 26)) != 58u << 26)
13481             abort ();
13482           insn += (14u << 26) - (58u << 26);
13483           bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13484           r_type = R_PPC64_TOC16_LO;
13485           rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13486           break;
13487
13488         case R_PPC64_TOC16:
13489         case R_PPC64_TOC16_LO:
13490         case R_PPC64_TOC16_DS:
13491         case R_PPC64_TOC16_LO_DS:
13492           {
13493             /* Check for toc tls entries.  */
13494             unsigned char *toc_tls;
13495             int retval;
13496
13497             retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13498                                    &local_syms, rel, input_bfd);
13499             if (retval == 0)
13500               return FALSE;
13501
13502             if (toc_tls)
13503               {
13504                 tls_mask = *toc_tls;
13505                 if (r_type == R_PPC64_TOC16_DS
13506                     || r_type == R_PPC64_TOC16_LO_DS)
13507                   {
13508                     if (tls_mask != 0
13509                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13510                       goto toctprel;
13511                   }
13512                 else
13513                   {
13514                     /* If we found a GD reloc pair, then we might be
13515                        doing a GD->IE transition.  */
13516                     if (retval == 2)
13517                       {
13518                         tls_gd = TLS_TPRELGD;
13519                         if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13520                           goto tls_ldgd_opt;
13521                       }
13522                     else if (retval == 3)
13523                       {
13524                         if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13525                           goto tls_ldgd_opt;
13526                       }
13527                   }
13528               }
13529           }
13530           break;
13531
13532         case R_PPC64_GOT_TPREL16_HI:
13533         case R_PPC64_GOT_TPREL16_HA:
13534           if (tls_mask != 0
13535               && (tls_mask & TLS_TPREL) == 0)
13536             {
13537               rel->r_offset -= d_offset;
13538               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13539               r_type = R_PPC64_NONE;
13540               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13541             }
13542           break;
13543
13544         case R_PPC64_GOT_TPREL16_DS:
13545         case R_PPC64_GOT_TPREL16_LO_DS:
13546           if (tls_mask != 0
13547               && (tls_mask & TLS_TPREL) == 0)
13548             {
13549             toctprel:
13550               insn = bfd_get_32 (output_bfd,
13551                                  contents + rel->r_offset - d_offset);
13552               insn &= 31 << 21;
13553               insn |= 0x3c0d0000;       /* addis 0,13,0 */
13554               bfd_put_32 (output_bfd, insn,
13555                           contents + rel->r_offset - d_offset);
13556               r_type = R_PPC64_TPREL16_HA;
13557               if (toc_symndx != 0)
13558                 {
13559                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13560                   rel->r_addend = toc_addend;
13561                   /* We changed the symbol.  Start over in order to
13562                      get h, sym, sec etc. right.  */
13563                   goto again;
13564                 }
13565               else
13566                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13567             }
13568           break;
13569
13570         case R_PPC64_TLS:
13571           if (tls_mask != 0
13572               && (tls_mask & TLS_TPREL) == 0)
13573             {
13574               insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
13575               insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13576               if (insn == 0)
13577                 abort ();
13578               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13579               /* Was PPC64_TLS which sits on insn boundary, now
13580                  PPC64_TPREL16_LO which is at low-order half-word.  */
13581               rel->r_offset += d_offset;
13582               r_type = R_PPC64_TPREL16_LO;
13583               if (toc_symndx != 0)
13584                 {
13585                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13586                   rel->r_addend = toc_addend;
13587                   /* We changed the symbol.  Start over in order to
13588                      get h, sym, sec etc. right.  */
13589                   goto again;
13590                 }
13591               else
13592                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13593             }
13594           break;
13595
13596         case R_PPC64_GOT_TLSGD16_HI:
13597         case R_PPC64_GOT_TLSGD16_HA:
13598           tls_gd = TLS_TPRELGD;
13599           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13600             goto tls_gdld_hi;
13601           break;
13602
13603         case R_PPC64_GOT_TLSLD16_HI:
13604         case R_PPC64_GOT_TLSLD16_HA:
13605           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13606             {
13607             tls_gdld_hi:
13608               if ((tls_mask & tls_gd) != 0)
13609                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13610                           + R_PPC64_GOT_TPREL16_DS);
13611               else
13612                 {
13613                   rel->r_offset -= d_offset;
13614                   bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13615                   r_type = R_PPC64_NONE;
13616                 }
13617               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13618             }
13619           break;
13620
13621         case R_PPC64_GOT_TLSGD16:
13622         case R_PPC64_GOT_TLSGD16_LO:
13623           tls_gd = TLS_TPRELGD;
13624           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13625             goto tls_ldgd_opt;
13626           break;
13627
13628         case R_PPC64_GOT_TLSLD16:
13629         case R_PPC64_GOT_TLSLD16_LO:
13630           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13631             {
13632               unsigned int insn1, insn2, insn3;
13633               bfd_vma offset;
13634
13635             tls_ldgd_opt:
13636               offset = (bfd_vma) -1;
13637               /* If not using the newer R_PPC64_TLSGD/LD to mark
13638                  __tls_get_addr calls, we must trust that the call
13639                  stays with its arg setup insns, ie. that the next
13640                  reloc is the __tls_get_addr call associated with
13641                  the current reloc.  Edit both insns.  */
13642               if (input_section->has_tls_get_addr_call
13643                   && rel + 1 < relend
13644                   && branch_reloc_hash_match (input_bfd, rel + 1,
13645                                               htab->tls_get_addr,
13646                                               htab->tls_get_addr_fd))
13647                 offset = rel[1].r_offset;
13648               /* We read the low GOT_TLS (or TOC16) insn because we
13649                  need to keep the destination reg.  It may be
13650                  something other than the usual r3, and moved to r3
13651                  before the call by intervening code.  */
13652               insn1 = bfd_get_32 (output_bfd,
13653                                   contents + rel->r_offset - d_offset);
13654               if ((tls_mask & tls_gd) != 0)
13655                 {
13656                   /* IE */
13657                   insn1 &= (0x1f << 21) | (0x1f << 16);
13658                   insn1 |= 58 << 26;    /* ld */
13659                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13660                   if (offset != (bfd_vma) -1)
13661                     rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13662                   if ((tls_mask & TLS_EXPLICIT) == 0)
13663                     r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13664                               + R_PPC64_GOT_TPREL16_DS);
13665                   else
13666                     r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13667                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13668                 }
13669               else
13670                 {
13671                   /* LE */
13672                   insn1 &= 0x1f << 21;
13673                   insn1 |= 0x3c0d0000;  /* addis r,13,0 */
13674                   insn2 = 0x38630000;   /* addi 3,3,0 */
13675                   if (tls_gd == 0)
13676                     {
13677                       /* Was an LD reloc.  */
13678                       if (toc_symndx)
13679                         sec = local_sections[toc_symndx];
13680                       for (r_symndx = 0;
13681                            r_symndx < symtab_hdr->sh_info;
13682                            r_symndx++)
13683                         if (local_sections[r_symndx] == sec)
13684                           break;
13685                       if (r_symndx >= symtab_hdr->sh_info)
13686                         r_symndx = STN_UNDEF;
13687                       rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13688                       if (r_symndx != STN_UNDEF)
13689                         rel->r_addend -= (local_syms[r_symndx].st_value
13690                                           + sec->output_offset
13691                                           + sec->output_section->vma);
13692                     }
13693                   else if (toc_symndx != 0)
13694                     {
13695                       r_symndx = toc_symndx;
13696                       rel->r_addend = toc_addend;
13697                     }
13698                   r_type = R_PPC64_TPREL16_HA;
13699                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13700                   if (offset != (bfd_vma) -1)
13701                     {
13702                       rel[1].r_info = ELF64_R_INFO (r_symndx,
13703                                                     R_PPC64_TPREL16_LO);
13704                       rel[1].r_offset = offset + d_offset;
13705                       rel[1].r_addend = rel->r_addend;
13706                     }
13707                 }
13708               bfd_put_32 (output_bfd, insn1,
13709                           contents + rel->r_offset - d_offset);
13710               if (offset != (bfd_vma) -1)
13711                 {
13712                   insn3 = bfd_get_32 (output_bfd,
13713                                       contents + offset + 4);
13714                   if (insn3 == NOP
13715                       || insn3 == CROR_151515 || insn3 == CROR_313131)
13716                     {
13717                       rel[1].r_offset += 4;
13718                       bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13719                       insn2 = NOP;
13720                     }
13721                   bfd_put_32 (output_bfd, insn2, contents + offset);
13722                 }
13723               if ((tls_mask & tls_gd) == 0
13724                   && (tls_gd == 0 || toc_symndx != 0))
13725                 {
13726                   /* We changed the symbol.  Start over in order
13727                      to get h, sym, sec etc. right.  */
13728                   goto again;
13729                 }
13730             }
13731           break;
13732
13733         case R_PPC64_TLSGD:
13734           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13735             {
13736               unsigned int insn2, insn3;
13737               bfd_vma offset = rel->r_offset;
13738
13739               if ((tls_mask & TLS_TPRELGD) != 0)
13740                 {
13741                   /* IE */
13742                   r_type = R_PPC64_NONE;
13743                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13744                 }
13745               else
13746                 {
13747                   /* LE */
13748                   if (toc_symndx != 0)
13749                     {
13750                       r_symndx = toc_symndx;
13751                       rel->r_addend = toc_addend;
13752                     }
13753                   r_type = R_PPC64_TPREL16_LO;
13754                   rel->r_offset = offset + d_offset;
13755                   insn2 = 0x38630000;   /* addi 3,3,0 */
13756                 }
13757               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13758               /* Zap the reloc on the _tls_get_addr call too.  */
13759               BFD_ASSERT (offset == rel[1].r_offset);
13760               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13761               insn3 = bfd_get_32 (output_bfd,
13762                                   contents + offset + 4);
13763               if (insn3 == NOP
13764                   || insn3 == CROR_151515 || insn3 == CROR_313131)
13765                 {
13766                   rel->r_offset += 4;
13767                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13768                   insn2 = NOP;
13769                 }
13770               bfd_put_32 (output_bfd, insn2, contents + offset);
13771               if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
13772                 goto again;
13773             }
13774           break;
13775
13776         case R_PPC64_TLSLD:
13777           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13778             {
13779               unsigned int insn2, insn3;
13780               bfd_vma offset = rel->r_offset;
13781
13782               if (toc_symndx)
13783                 sec = local_sections[toc_symndx];
13784               for (r_symndx = 0;
13785                    r_symndx < symtab_hdr->sh_info;
13786                    r_symndx++)
13787                 if (local_sections[r_symndx] == sec)
13788                   break;
13789               if (r_symndx >= symtab_hdr->sh_info)
13790                 r_symndx = STN_UNDEF;
13791               rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13792               if (r_symndx != STN_UNDEF)
13793                 rel->r_addend -= (local_syms[r_symndx].st_value
13794                                   + sec->output_offset
13795                                   + sec->output_section->vma);
13796
13797               r_type = R_PPC64_TPREL16_LO;
13798               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13799               rel->r_offset = offset + d_offset;
13800               /* Zap the reloc on the _tls_get_addr call too.  */
13801               BFD_ASSERT (offset == rel[1].r_offset);
13802               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13803               insn2 = 0x38630000;       /* addi 3,3,0 */
13804               insn3 = bfd_get_32 (output_bfd,
13805                                   contents + offset + 4);
13806               if (insn3 == NOP
13807                   || insn3 == CROR_151515 || insn3 == CROR_313131)
13808                 {
13809                   rel->r_offset += 4;
13810                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13811                   insn2 = NOP;
13812                 }
13813               bfd_put_32 (output_bfd, insn2, contents + offset);
13814               goto again;
13815             }
13816           break;
13817
13818         case R_PPC64_DTPMOD64:
13819           if (rel + 1 < relend
13820               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
13821               && rel[1].r_offset == rel->r_offset + 8)
13822             {
13823               if ((tls_mask & TLS_GD) == 0)
13824                 {
13825                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
13826                   if ((tls_mask & TLS_TPRELGD) != 0)
13827                     r_type = R_PPC64_TPREL64;
13828                   else
13829                     {
13830                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13831                       r_type = R_PPC64_NONE;
13832                     }
13833                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13834                 }
13835             }
13836           else
13837             {
13838               if ((tls_mask & TLS_LD) == 0)
13839                 {
13840                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13841                   r_type = R_PPC64_NONE;
13842                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13843                 }
13844             }
13845           break;
13846
13847         case R_PPC64_TPREL64:
13848           if ((tls_mask & TLS_TPREL) == 0)
13849             {
13850               r_type = R_PPC64_NONE;
13851               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13852             }
13853           break;
13854
13855         case R_PPC64_REL16_HA:
13856           /* If we are generating a non-PIC executable, edit
13857              .  0:      addis 2,12,.TOC.-0b@ha
13858              .          addi 2,2,.TOC.-0b@l
13859              used by ELFv2 global entry points to set up r2, to
13860              .          lis 2,.TOC.@ha
13861              .          addi 2,2,.TOC.@l
13862              if .TOC. is in range.  */
13863           if (!bfd_link_pic (info)
13864               && !info->traditional_format
13865               && h != NULL && &h->elf == htab->elf.hgot
13866               && rel + 1 < relend
13867               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
13868               && rel[1].r_offset == rel->r_offset + 4
13869               && rel[1].r_addend == rel->r_addend + 4
13870               && relocation + 0x80008000 <= 0xffffffff)
13871             {
13872               unsigned int insn1, insn2;
13873               bfd_vma offset = rel->r_offset - d_offset;
13874               insn1 = bfd_get_32 (output_bfd, contents + offset);
13875               insn2 = bfd_get_32 (output_bfd, contents + offset + 4);
13876               if ((insn1 & 0xffff0000) == 0x3c4c0000 /* addis 2,12 */
13877                   && (insn2 & 0xffff0000) == 0x38420000 /* addi 2,2 */)
13878                 {
13879                   r_type = R_PPC64_ADDR16_HA;
13880                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13881                   rel->r_addend -= d_offset;
13882                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
13883                   rel[1].r_addend -= d_offset + 4;
13884                   bfd_put_32 (output_bfd, 0x3c400000, contents + offset);
13885                 }
13886             }
13887           break;
13888         }
13889
13890       /* Handle other relocations that tweak non-addend part of insn.  */
13891       insn = 0;
13892       max_br_offset = 1 << 25;
13893       addend = rel->r_addend;
13894       reloc_dest = DEST_NORMAL;
13895       switch (r_type)
13896         {
13897         default:
13898           break;
13899
13900         case R_PPC64_TOCSAVE:
13901           if (relocation + addend == (rel->r_offset
13902                                       + input_section->output_offset
13903                                       + input_section->output_section->vma)
13904               && tocsave_find (htab, NO_INSERT,
13905                                &local_syms, rel, input_bfd))
13906             {
13907               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
13908               if (insn == NOP
13909                   || insn == CROR_151515 || insn == CROR_313131)
13910                 bfd_put_32 (input_bfd,
13911                             STD_R2_0R1 + STK_TOC (htab),
13912                             contents + rel->r_offset);
13913             }
13914           break;
13915
13916           /* Branch taken prediction relocations.  */
13917         case R_PPC64_ADDR14_BRTAKEN:
13918         case R_PPC64_REL14_BRTAKEN:
13919           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
13920           /* Fall thru.  */
13921
13922           /* Branch not taken prediction relocations.  */
13923         case R_PPC64_ADDR14_BRNTAKEN:
13924         case R_PPC64_REL14_BRNTAKEN:
13925           insn |= bfd_get_32 (output_bfd,
13926                               contents + rel->r_offset) & ~(0x01 << 21);
13927           /* Fall thru.  */
13928
13929         case R_PPC64_REL14:
13930           max_br_offset = 1 << 15;
13931           /* Fall thru.  */
13932
13933         case R_PPC64_REL24:
13934           /* Calls to functions with a different TOC, such as calls to
13935              shared objects, need to alter the TOC pointer.  This is
13936              done using a linkage stub.  A REL24 branching to these
13937              linkage stubs needs to be followed by a nop, as the nop
13938              will be replaced with an instruction to restore the TOC
13939              base pointer.  */
13940           fdh = h;
13941           if (h != NULL
13942               && h->oh != NULL
13943               && h->oh->is_func_descriptor)
13944             fdh = ppc_follow_link (h->oh);
13945           stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
13946                                            htab);
13947           if (stub_entry != NULL
13948               && (stub_entry->stub_type == ppc_stub_plt_call
13949                   || stub_entry->stub_type == ppc_stub_plt_call_r2save
13950                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
13951                   || stub_entry->stub_type == ppc_stub_long_branch_r2off))
13952             {
13953               bfd_boolean can_plt_call = FALSE;
13954
13955               /* All of these stubs will modify r2, so there must be a
13956                  branch and link followed by a nop.  The nop is
13957                  replaced by an insn to restore r2.  */
13958               if (rel->r_offset + 8 <= input_section->size)
13959                 {
13960                   unsigned long br;
13961
13962                   br = bfd_get_32 (input_bfd,
13963                                    contents + rel->r_offset);
13964                   if ((br & 1) != 0)
13965                     {
13966                       unsigned long nop;
13967
13968                       nop = bfd_get_32 (input_bfd,
13969                                         contents + rel->r_offset + 4);
13970                       if (nop == NOP
13971                           || nop == CROR_151515 || nop == CROR_313131)
13972                         {
13973                           if (h != NULL
13974                               && (h == htab->tls_get_addr_fd
13975                                   || h == htab->tls_get_addr)
13976                               && htab->params->tls_get_addr_opt)
13977                             {
13978                               /* Special stub used, leave nop alone.  */
13979                             }
13980                           else
13981                             bfd_put_32 (input_bfd,
13982                                         LD_R2_0R1 + STK_TOC (htab),
13983                                         contents + rel->r_offset + 4);
13984                           can_plt_call = TRUE;
13985                         }
13986                     }
13987                 }
13988
13989               if (!can_plt_call && h != NULL)
13990                 {
13991                   const char *name = h->elf.root.root.string;
13992
13993                   if (*name == '.')
13994                     ++name;
13995
13996                   if (strncmp (name, "__libc_start_main", 17) == 0
13997                       && (name[17] == 0 || name[17] == '@'))
13998                     {
13999                       /* Allow crt1 branch to go via a toc adjusting
14000                          stub.  Other calls that never return could do
14001                          the same, if we could detect such.  */
14002                       can_plt_call = TRUE;
14003                     }
14004                 }
14005
14006               if (!can_plt_call)
14007                 {
14008                   /* g++ as of 20130507 emits self-calls without a
14009                      following nop.  This is arguably wrong since we
14010                      have conflicting information.  On the one hand a
14011                      global symbol and on the other a local call
14012                      sequence, but don't error for this special case.
14013                      It isn't possible to cheaply verify we have
14014                      exactly such a call.  Allow all calls to the same
14015                      section.  */
14016                   asection *code_sec = sec;
14017
14018                   if (get_opd_info (sec) != NULL)
14019                     {
14020                       bfd_vma off = (relocation + addend
14021                                      - sec->output_section->vma
14022                                      - sec->output_offset);
14023
14024                       opd_entry_value (sec, off, &code_sec, NULL, FALSE);
14025                     }
14026                   if (code_sec == input_section)
14027                     can_plt_call = TRUE;
14028                 }
14029
14030               if (!can_plt_call)
14031                 {
14032                   if (stub_entry->stub_type == ppc_stub_plt_call
14033                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14034                     info->callbacks->einfo
14035                       (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
14036                          "recompile with -fPIC\n"),
14037                        input_bfd, input_section, rel->r_offset, sym_name);
14038                   else
14039                     info->callbacks->einfo
14040                       (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
14041                          "(-mcmodel=small toc adjust stub)\n"),
14042                        input_bfd, input_section, rel->r_offset, sym_name);
14043
14044                   bfd_set_error (bfd_error_bad_value);
14045                   ret = FALSE;
14046                 }
14047
14048               if (can_plt_call
14049                   && (stub_entry->stub_type == ppc_stub_plt_call
14050                       || stub_entry->stub_type == ppc_stub_plt_call_r2save))
14051                 unresolved_reloc = FALSE;
14052             }
14053
14054           if ((stub_entry == NULL
14055                || stub_entry->stub_type == ppc_stub_long_branch
14056                || stub_entry->stub_type == ppc_stub_plt_branch)
14057               && get_opd_info (sec) != NULL)
14058             {
14059               /* The branch destination is the value of the opd entry. */
14060               bfd_vma off = (relocation + addend
14061                              - sec->output_section->vma
14062                              - sec->output_offset);
14063               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
14064               if (dest != (bfd_vma) -1)
14065                 {
14066                   relocation = dest;
14067                   addend = 0;
14068                   reloc_dest = DEST_OPD;
14069                 }
14070             }
14071
14072           /* If the branch is out of reach we ought to have a long
14073              branch stub.  */
14074           from = (rel->r_offset
14075                   + input_section->output_offset
14076                   + input_section->output_section->vma);
14077
14078           relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
14079                                                   ? fdh->elf.other
14080                                                   : sym->st_other);
14081
14082           if (stub_entry != NULL
14083               && (stub_entry->stub_type == ppc_stub_long_branch
14084                   || stub_entry->stub_type == ppc_stub_plt_branch)
14085               && (r_type == R_PPC64_ADDR14_BRTAKEN
14086                   || r_type == R_PPC64_ADDR14_BRNTAKEN
14087                   || (relocation + addend - from + max_br_offset
14088                       < 2 * max_br_offset)))
14089             /* Don't use the stub if this branch is in range.  */
14090             stub_entry = NULL;
14091
14092           if (stub_entry != NULL)
14093             {
14094               /* Munge up the value and addend so that we call the stub
14095                  rather than the procedure directly.  */
14096               asection *stub_sec = stub_entry->group->stub_sec;
14097
14098               if (stub_entry->stub_type == ppc_stub_save_res)
14099                 relocation += (stub_sec->output_offset
14100                                + stub_sec->output_section->vma
14101                                + stub_sec->size - htab->sfpr->size
14102                                - htab->sfpr->output_offset
14103                                - htab->sfpr->output_section->vma);
14104               else
14105                 relocation = (stub_entry->stub_offset
14106                               + stub_sec->output_offset
14107                               + stub_sec->output_section->vma);
14108               addend = 0;
14109               reloc_dest = DEST_STUB;
14110
14111               if ((stub_entry->stub_type == ppc_stub_plt_call
14112                    || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14113                   && (ALWAYS_EMIT_R2SAVE
14114                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14115                   && rel + 1 < relend
14116                   && rel[1].r_offset == rel->r_offset + 4
14117                   && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
14118                 relocation += 4;
14119             }
14120
14121           if (insn != 0)
14122             {
14123               if (is_isa_v2)
14124                 {
14125                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
14126                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
14127                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
14128                   if ((insn & (0x14 << 21)) == (0x04 << 21))
14129                     insn |= 0x02 << 21;
14130                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
14131                     insn |= 0x08 << 21;
14132                   else
14133                     break;
14134                 }
14135               else
14136                 {
14137                   /* Invert 'y' bit if not the default.  */
14138                   if ((bfd_signed_vma) (relocation + addend - from) < 0)
14139                     insn ^= 0x01 << 21;
14140                 }
14141
14142               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
14143             }
14144
14145           /* NOP out calls to undefined weak functions.
14146              We can thus call a weak function without first
14147              checking whether the function is defined.  */
14148           else if (h != NULL
14149                    && h->elf.root.type == bfd_link_hash_undefweak
14150                    && h->elf.dynindx == -1
14151                    && r_type == R_PPC64_REL24
14152                    && relocation == 0
14153                    && addend == 0)
14154             {
14155               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
14156               goto copy_reloc;
14157             }
14158           break;
14159         }
14160
14161       /* Set `addend'.  */
14162       tls_type = 0;
14163       switch (r_type)
14164         {
14165         default:
14166           info->callbacks->einfo
14167             (_("%P: %B: unknown relocation type %d for `%T'\n"),
14168              input_bfd, (int) r_type, sym_name);
14169
14170           bfd_set_error (bfd_error_bad_value);
14171           ret = FALSE;
14172           goto copy_reloc;
14173
14174         case R_PPC64_NONE:
14175         case R_PPC64_TLS:
14176         case R_PPC64_TLSGD:
14177         case R_PPC64_TLSLD:
14178         case R_PPC64_TOCSAVE:
14179         case R_PPC64_GNU_VTINHERIT:
14180         case R_PPC64_GNU_VTENTRY:
14181           goto copy_reloc;
14182
14183           /* GOT16 relocations.  Like an ADDR16 using the symbol's
14184              address in the GOT as relocation value instead of the
14185              symbol's value itself.  Also, create a GOT entry for the
14186              symbol and put the symbol value there.  */
14187         case R_PPC64_GOT_TLSGD16:
14188         case R_PPC64_GOT_TLSGD16_LO:
14189         case R_PPC64_GOT_TLSGD16_HI:
14190         case R_PPC64_GOT_TLSGD16_HA:
14191           tls_type = TLS_TLS | TLS_GD;
14192           goto dogot;
14193
14194         case R_PPC64_GOT_TLSLD16:
14195         case R_PPC64_GOT_TLSLD16_LO:
14196         case R_PPC64_GOT_TLSLD16_HI:
14197         case R_PPC64_GOT_TLSLD16_HA:
14198           tls_type = TLS_TLS | TLS_LD;
14199           goto dogot;
14200
14201         case R_PPC64_GOT_TPREL16_DS:
14202         case R_PPC64_GOT_TPREL16_LO_DS:
14203         case R_PPC64_GOT_TPREL16_HI:
14204         case R_PPC64_GOT_TPREL16_HA:
14205           tls_type = TLS_TLS | TLS_TPREL;
14206           goto dogot;
14207
14208         case R_PPC64_GOT_DTPREL16_DS:
14209         case R_PPC64_GOT_DTPREL16_LO_DS:
14210         case R_PPC64_GOT_DTPREL16_HI:
14211         case R_PPC64_GOT_DTPREL16_HA:
14212           tls_type = TLS_TLS | TLS_DTPREL;
14213           goto dogot;
14214
14215         case R_PPC64_GOT16:
14216         case R_PPC64_GOT16_LO:
14217         case R_PPC64_GOT16_HI:
14218         case R_PPC64_GOT16_HA:
14219         case R_PPC64_GOT16_DS:
14220         case R_PPC64_GOT16_LO_DS:
14221         dogot:
14222           {
14223             /* Relocation is to the entry for this symbol in the global
14224                offset table.  */
14225             asection *got;
14226             bfd_vma *offp;
14227             bfd_vma off;
14228             unsigned long indx = 0;
14229             struct got_entry *ent;
14230
14231             if (tls_type == (TLS_TLS | TLS_LD)
14232                 && (h == NULL
14233                     || !h->elf.def_dynamic))
14234               ent = ppc64_tlsld_got (input_bfd);
14235             else
14236               {
14237
14238                 if (h != NULL)
14239                   {
14240                     bfd_boolean dyn = htab->elf.dynamic_sections_created;
14241                     if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info),
14242                                                           &h->elf)
14243                         || (bfd_link_pic (info)
14244                             && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
14245                       /* This is actually a static link, or it is a
14246                          -Bsymbolic link and the symbol is defined
14247                          locally, or the symbol was forced to be local
14248                          because of a version file.  */
14249                       ;
14250                     else
14251                       {
14252                         BFD_ASSERT (h->elf.dynindx != -1);
14253                         indx = h->elf.dynindx;
14254                         unresolved_reloc = FALSE;
14255                       }
14256                     ent = h->elf.got.glist;
14257                   }
14258                 else
14259                   {
14260                     if (local_got_ents == NULL)
14261                       abort ();
14262                     ent = local_got_ents[r_symndx];
14263                   }
14264
14265                 for (; ent != NULL; ent = ent->next)
14266                   if (ent->addend == orig_rel.r_addend
14267                       && ent->owner == input_bfd
14268                       && ent->tls_type == tls_type)
14269                     break;
14270               }
14271
14272             if (ent == NULL)
14273               abort ();
14274             if (ent->is_indirect)
14275               ent = ent->got.ent;
14276             offp = &ent->got.offset;
14277             got = ppc64_elf_tdata (ent->owner)->got;
14278             if (got == NULL)
14279               abort ();
14280
14281             /* The offset must always be a multiple of 8.  We use the
14282                least significant bit to record whether we have already
14283                processed this entry.  */
14284             off = *offp;
14285             if ((off & 1) != 0)
14286               off &= ~1;
14287             else
14288               {
14289                 /* Generate relocs for the dynamic linker, except in
14290                    the case of TLSLD where we'll use one entry per
14291                    module.  */
14292                 asection *relgot;
14293                 bfd_boolean ifunc;
14294
14295                 *offp = off | 1;
14296                 relgot = NULL;
14297                 ifunc = (h != NULL
14298                          ? h->elf.type == STT_GNU_IFUNC
14299                          : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
14300                 if (ifunc)
14301                   relgot = htab->elf.irelplt;
14302                 else if ((bfd_link_pic (info) || indx != 0)
14303                          && (h == NULL
14304                              || (tls_type == (TLS_TLS | TLS_LD)
14305                                  && !h->elf.def_dynamic)
14306                              || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14307                              || h->elf.root.type != bfd_link_hash_undefweak))
14308                   relgot = ppc64_elf_tdata (ent->owner)->relgot;
14309                 if (relgot != NULL)
14310                   {
14311                     outrel.r_offset = (got->output_section->vma
14312                                        + got->output_offset
14313                                        + off);
14314                     outrel.r_addend = addend;
14315                     if (tls_type & (TLS_LD | TLS_GD))
14316                       {
14317                         outrel.r_addend = 0;
14318                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
14319                         if (tls_type == (TLS_TLS | TLS_GD))
14320                           {
14321                             loc = relgot->contents;
14322                             loc += (relgot->reloc_count++
14323                                     * sizeof (Elf64_External_Rela));
14324                             bfd_elf64_swap_reloca_out (output_bfd,
14325                                                        &outrel, loc);
14326                             outrel.r_offset += 8;
14327                             outrel.r_addend = addend;
14328                             outrel.r_info
14329                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14330                           }
14331                       }
14332                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
14333                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14334                     else if (tls_type == (TLS_TLS | TLS_TPREL))
14335                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
14336                     else if (indx != 0)
14337                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
14338                     else
14339                       {
14340                         if (ifunc)
14341                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14342                         else
14343                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14344
14345                         /* Write the .got section contents for the sake
14346                            of prelink.  */
14347                         loc = got->contents + off;
14348                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
14349                                     loc);
14350                       }
14351
14352                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
14353                       {
14354                         outrel.r_addend += relocation;
14355                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
14356                           {
14357                             if (htab->elf.tls_sec == NULL)
14358                               outrel.r_addend = 0;
14359                             else
14360                               outrel.r_addend -= htab->elf.tls_sec->vma;
14361                           }
14362                       }
14363                     loc = relgot->contents;
14364                     loc += (relgot->reloc_count++
14365                             * sizeof (Elf64_External_Rela));
14366                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14367                   }
14368
14369                 /* Init the .got section contents here if we're not
14370                    emitting a reloc.  */
14371                 else
14372                   {
14373                     relocation += addend;
14374                     if (tls_type == (TLS_TLS | TLS_LD))
14375                       relocation = 1;
14376                     else if (tls_type != 0)
14377                       {
14378                         if (htab->elf.tls_sec == NULL)
14379                           relocation = 0;
14380                         else
14381                           {
14382                             relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
14383                             if (tls_type == (TLS_TLS | TLS_TPREL))
14384                               relocation += DTP_OFFSET - TP_OFFSET;
14385                           }
14386
14387                         if (tls_type == (TLS_TLS | TLS_GD))
14388                           {
14389                             bfd_put_64 (output_bfd, relocation,
14390                                         got->contents + off + 8);
14391                             relocation = 1;
14392                           }
14393                       }
14394
14395                     bfd_put_64 (output_bfd, relocation,
14396                                 got->contents + off);
14397                   }
14398               }
14399
14400             if (off >= (bfd_vma) -2)
14401               abort ();
14402
14403             relocation = got->output_section->vma + got->output_offset + off;
14404             addend = -(TOCstart + htab->sec_info[input_section->id].toc_off);
14405           }
14406           break;
14407
14408         case R_PPC64_PLT16_HA:
14409         case R_PPC64_PLT16_HI:
14410         case R_PPC64_PLT16_LO:
14411         case R_PPC64_PLT32:
14412         case R_PPC64_PLT64:
14413           /* Relocation is to the entry for this symbol in the
14414              procedure linkage table.  */
14415
14416           /* Resolve a PLT reloc against a local symbol directly,
14417              without using the procedure linkage table.  */
14418           if (h == NULL)
14419             break;
14420
14421           /* It's possible that we didn't make a PLT entry for this
14422              symbol.  This happens when statically linking PIC code,
14423              or when using -Bsymbolic.  Go find a match if there is a
14424              PLT entry.  */
14425           if (htab->elf.splt != NULL)
14426             {
14427               struct plt_entry *ent;
14428               for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)
14429                 if (ent->plt.offset != (bfd_vma) -1
14430                     && ent->addend == orig_rel.r_addend)
14431                   {
14432                     relocation = (htab->elf.splt->output_section->vma
14433                                   + htab->elf.splt->output_offset
14434                                   + ent->plt.offset);
14435                     unresolved_reloc = FALSE;
14436                     break;
14437                   }
14438             }
14439           break;
14440
14441         case R_PPC64_TOC:
14442           /* Relocation value is TOC base.  */
14443           relocation = TOCstart;
14444           if (r_symndx == STN_UNDEF)
14445             relocation += htab->sec_info[input_section->id].toc_off;
14446           else if (unresolved_reloc)
14447             ;
14448           else if (sec != NULL && sec->id < htab->sec_info_arr_size)
14449             relocation += htab->sec_info[sec->id].toc_off;
14450           else
14451             unresolved_reloc = TRUE;
14452           goto dodyn;
14453
14454           /* TOC16 relocs.  We want the offset relative to the TOC base,
14455              which is the address of the start of the TOC plus 0x8000.
14456              The TOC consists of sections .got, .toc, .tocbss, and .plt,
14457              in this order.  */
14458         case R_PPC64_TOC16:
14459         case R_PPC64_TOC16_LO:
14460         case R_PPC64_TOC16_HI:
14461         case R_PPC64_TOC16_DS:
14462         case R_PPC64_TOC16_LO_DS:
14463         case R_PPC64_TOC16_HA:
14464           addend -= TOCstart + htab->sec_info[input_section->id].toc_off;
14465           break;
14466
14467           /* Relocate against the beginning of the section.  */
14468         case R_PPC64_SECTOFF:
14469         case R_PPC64_SECTOFF_LO:
14470         case R_PPC64_SECTOFF_HI:
14471         case R_PPC64_SECTOFF_DS:
14472         case R_PPC64_SECTOFF_LO_DS:
14473         case R_PPC64_SECTOFF_HA:
14474           if (sec != NULL)
14475             addend -= sec->output_section->vma;
14476           break;
14477
14478         case R_PPC64_REL16:
14479         case R_PPC64_REL16_LO:
14480         case R_PPC64_REL16_HI:
14481         case R_PPC64_REL16_HA:
14482         case R_PPC64_REL16DX_HA:
14483           break;
14484
14485         case R_PPC64_REL14:
14486         case R_PPC64_REL14_BRNTAKEN:
14487         case R_PPC64_REL14_BRTAKEN:
14488         case R_PPC64_REL24:
14489           break;
14490
14491         case R_PPC64_TPREL16:
14492         case R_PPC64_TPREL16_LO:
14493         case R_PPC64_TPREL16_HI:
14494         case R_PPC64_TPREL16_HA:
14495         case R_PPC64_TPREL16_DS:
14496         case R_PPC64_TPREL16_LO_DS:
14497         case R_PPC64_TPREL16_HIGH:
14498         case R_PPC64_TPREL16_HIGHA:
14499         case R_PPC64_TPREL16_HIGHER:
14500         case R_PPC64_TPREL16_HIGHERA:
14501         case R_PPC64_TPREL16_HIGHEST:
14502         case R_PPC64_TPREL16_HIGHESTA:
14503           if (h != NULL
14504               && h->elf.root.type == bfd_link_hash_undefweak
14505               && h->elf.dynindx == -1)
14506             {
14507               /* Make this relocation against an undefined weak symbol
14508                  resolve to zero.  This is really just a tweak, since
14509                  code using weak externs ought to check that they are
14510                  defined before using them.  */
14511               bfd_byte *p = contents + rel->r_offset - d_offset;
14512
14513               insn = bfd_get_32 (output_bfd, p);
14514               insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14515               if (insn != 0)
14516                 bfd_put_32 (output_bfd, insn, p);
14517               break;
14518             }
14519           if (htab->elf.tls_sec != NULL)
14520             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14521           if (bfd_link_pic (info))
14522             /* The TPREL16 relocs shouldn't really be used in shared
14523                libs as they will result in DT_TEXTREL being set, but
14524                support them anyway.  */
14525             goto dodyn;
14526           break;
14527
14528         case R_PPC64_DTPREL16:
14529         case R_PPC64_DTPREL16_LO:
14530         case R_PPC64_DTPREL16_HI:
14531         case R_PPC64_DTPREL16_HA:
14532         case R_PPC64_DTPREL16_DS:
14533         case R_PPC64_DTPREL16_LO_DS:
14534         case R_PPC64_DTPREL16_HIGH:
14535         case R_PPC64_DTPREL16_HIGHA:
14536         case R_PPC64_DTPREL16_HIGHER:
14537         case R_PPC64_DTPREL16_HIGHERA:
14538         case R_PPC64_DTPREL16_HIGHEST:
14539         case R_PPC64_DTPREL16_HIGHESTA:
14540           if (htab->elf.tls_sec != NULL)
14541             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14542           break;
14543
14544         case R_PPC64_ADDR64_LOCAL:
14545           addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
14546                                               ? h->elf.other
14547                                               : sym->st_other);
14548           break;
14549
14550         case R_PPC64_DTPMOD64:
14551           relocation = 1;
14552           addend = 0;
14553           goto dodyn;
14554
14555         case R_PPC64_TPREL64:
14556           if (htab->elf.tls_sec != NULL)
14557             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14558           goto dodyn;
14559
14560         case R_PPC64_DTPREL64:
14561           if (htab->elf.tls_sec != NULL)
14562             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14563           /* Fall thru */
14564
14565           /* Relocations that may need to be propagated if this is a
14566              dynamic object.  */
14567         case R_PPC64_REL30:
14568         case R_PPC64_REL32:
14569         case R_PPC64_REL64:
14570         case R_PPC64_ADDR14:
14571         case R_PPC64_ADDR14_BRNTAKEN:
14572         case R_PPC64_ADDR14_BRTAKEN:
14573         case R_PPC64_ADDR16:
14574         case R_PPC64_ADDR16_DS:
14575         case R_PPC64_ADDR16_HA:
14576         case R_PPC64_ADDR16_HI:
14577         case R_PPC64_ADDR16_HIGH:
14578         case R_PPC64_ADDR16_HIGHA:
14579         case R_PPC64_ADDR16_HIGHER:
14580         case R_PPC64_ADDR16_HIGHERA:
14581         case R_PPC64_ADDR16_HIGHEST:
14582         case R_PPC64_ADDR16_HIGHESTA:
14583         case R_PPC64_ADDR16_LO:
14584         case R_PPC64_ADDR16_LO_DS:
14585         case R_PPC64_ADDR24:
14586         case R_PPC64_ADDR32:
14587         case R_PPC64_ADDR64:
14588         case R_PPC64_UADDR16:
14589         case R_PPC64_UADDR32:
14590         case R_PPC64_UADDR64:
14591         dodyn:
14592           if ((input_section->flags & SEC_ALLOC) == 0)
14593             break;
14594
14595           if (NO_OPD_RELOCS && is_opd)
14596             break;
14597
14598           if ((bfd_link_pic (info)
14599                && (h == NULL
14600                    || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14601                    || h->elf.root.type != bfd_link_hash_undefweak)
14602                && (must_be_dyn_reloc (info, r_type)
14603                    || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
14604               || (ELIMINATE_COPY_RELOCS
14605                   && !bfd_link_pic (info)
14606                   && h != NULL
14607                   && h->elf.dynindx != -1
14608                   && !h->elf.non_got_ref
14609                   && !h->elf.def_regular)
14610               || (!bfd_link_pic (info)
14611                   && (h != NULL
14612                       ? h->elf.type == STT_GNU_IFUNC
14613                       : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)))
14614             {
14615               bfd_boolean skip, relocate;
14616               asection *sreloc;
14617               bfd_vma out_off;
14618
14619               /* When generating a dynamic object, these relocations
14620                  are copied into the output file to be resolved at run
14621                  time.  */
14622
14623               skip = FALSE;
14624               relocate = FALSE;
14625
14626               out_off = _bfd_elf_section_offset (output_bfd, info,
14627                                                  input_section, rel->r_offset);
14628               if (out_off == (bfd_vma) -1)
14629                 skip = TRUE;
14630               else if (out_off == (bfd_vma) -2)
14631                 skip = TRUE, relocate = TRUE;
14632               out_off += (input_section->output_section->vma
14633                           + input_section->output_offset);
14634               outrel.r_offset = out_off;
14635               outrel.r_addend = rel->r_addend;
14636
14637               /* Optimize unaligned reloc use.  */
14638               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14639                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14640                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14641               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14642                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
14643                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
14644               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
14645                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
14646                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
14647
14648               if (skip)
14649                 memset (&outrel, 0, sizeof outrel);
14650               else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14651                        && !is_opd
14652                        && r_type != R_PPC64_TOC)
14653                 {
14654                   BFD_ASSERT (h->elf.dynindx != -1);
14655                   outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
14656                 }
14657               else
14658                 {
14659                   /* This symbol is local, or marked to become local,
14660                      or this is an opd section reloc which must point
14661                      at a local function.  */
14662                   outrel.r_addend += relocation;
14663                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
14664                     {
14665                       if (is_opd && h != NULL)
14666                         {
14667                           /* Lie about opd entries.  This case occurs
14668                              when building shared libraries and we
14669                              reference a function in another shared
14670                              lib.  The same thing happens for a weak
14671                              definition in an application that's
14672                              overridden by a strong definition in a
14673                              shared lib.  (I believe this is a generic
14674                              bug in binutils handling of weak syms.)
14675                              In these cases we won't use the opd
14676                              entry in this lib.  */
14677                           unresolved_reloc = FALSE;
14678                         }
14679                       if (!is_opd
14680                           && r_type == R_PPC64_ADDR64
14681                           && (h != NULL
14682                               ? h->elf.type == STT_GNU_IFUNC
14683                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14684                         outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14685                       else
14686                         {
14687                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14688
14689                           /* We need to relocate .opd contents for ld.so.
14690                              Prelink also wants simple and consistent rules
14691                              for relocs.  This make all RELATIVE relocs have
14692                              *r_offset equal to r_addend.  */
14693                           relocate = TRUE;
14694                         }
14695                     }
14696                   else
14697                     {
14698                       long indx = 0;
14699
14700                       if (h != NULL
14701                           ? h->elf.type == STT_GNU_IFUNC
14702                           : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14703                         {
14704                           info->callbacks->einfo
14705                             (_("%P: %H: %s for indirect "
14706                                "function `%T' unsupported\n"),
14707                              input_bfd, input_section, rel->r_offset,
14708                              ppc64_elf_howto_table[r_type]->name,
14709                              sym_name);
14710                           ret = FALSE;
14711                         }
14712                       else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
14713                         ;
14714                       else if (sec == NULL || sec->owner == NULL)
14715                         {
14716                           bfd_set_error (bfd_error_bad_value);
14717                           return FALSE;
14718                         }
14719                       else
14720                         {
14721                           asection *osec;
14722
14723                           osec = sec->output_section;
14724                           indx = elf_section_data (osec)->dynindx;
14725
14726                           if (indx == 0)
14727                             {
14728                               if ((osec->flags & SEC_READONLY) == 0
14729                                   && htab->elf.data_index_section != NULL)
14730                                 osec = htab->elf.data_index_section;
14731                               else
14732                                 osec = htab->elf.text_index_section;
14733                               indx = elf_section_data (osec)->dynindx;
14734                             }
14735                           BFD_ASSERT (indx != 0);
14736
14737                           /* We are turning this relocation into one
14738                              against a section symbol, so subtract out
14739                              the output section's address but not the
14740                              offset of the input section in the output
14741                              section.  */
14742                           outrel.r_addend -= osec->vma;
14743                         }
14744
14745                       outrel.r_info = ELF64_R_INFO (indx, r_type);
14746                     }
14747                 }
14748
14749               sreloc = elf_section_data (input_section)->sreloc;
14750               if (h != NULL
14751                   ? h->elf.type == STT_GNU_IFUNC
14752                   : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14753                 sreloc = htab->elf.irelplt;
14754               if (sreloc == NULL)
14755                 abort ();
14756
14757               if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
14758                   >= sreloc->size)
14759                 abort ();
14760               loc = sreloc->contents;
14761               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
14762               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14763
14764               /* If this reloc is against an external symbol, it will
14765                  be computed at runtime, so there's no need to do
14766                  anything now.  However, for the sake of prelink ensure
14767                  that the section contents are a known value.  */
14768               if (! relocate)
14769                 {
14770                   unresolved_reloc = FALSE;
14771                   /* The value chosen here is quite arbitrary as ld.so
14772                      ignores section contents except for the special
14773                      case of .opd where the contents might be accessed
14774                      before relocation.  Choose zero, as that won't
14775                      cause reloc overflow.  */
14776                   relocation = 0;
14777                   addend = 0;
14778                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
14779                      to improve backward compatibility with older
14780                      versions of ld.  */
14781                   if (r_type == R_PPC64_ADDR64)
14782                     addend = outrel.r_addend;
14783                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
14784                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
14785                     addend = (input_section->output_section->vma
14786                               + input_section->output_offset
14787                               + rel->r_offset);
14788                 }
14789             }
14790           break;
14791
14792         case R_PPC64_COPY:
14793         case R_PPC64_GLOB_DAT:
14794         case R_PPC64_JMP_SLOT:
14795         case R_PPC64_JMP_IREL:
14796         case R_PPC64_RELATIVE:
14797           /* We shouldn't ever see these dynamic relocs in relocatable
14798              files.  */
14799           /* Fall through.  */
14800
14801         case R_PPC64_PLTGOT16:
14802         case R_PPC64_PLTGOT16_DS:
14803         case R_PPC64_PLTGOT16_HA:
14804         case R_PPC64_PLTGOT16_HI:
14805         case R_PPC64_PLTGOT16_LO:
14806         case R_PPC64_PLTGOT16_LO_DS:
14807         case R_PPC64_PLTREL32:
14808         case R_PPC64_PLTREL64:
14809           /* These ones haven't been implemented yet.  */
14810
14811           info->callbacks->einfo
14812             (_("%P: %B: %s is not supported for `%T'\n"),
14813              input_bfd,
14814              ppc64_elf_howto_table[r_type]->name, sym_name);
14815
14816           bfd_set_error (bfd_error_invalid_operation);
14817           ret = FALSE;
14818           goto copy_reloc;
14819         }
14820
14821       /* Multi-instruction sequences that access the TOC can be
14822          optimized, eg. addis ra,r2,0; addi rb,ra,x;
14823          to             nop;           addi rb,r2,x;  */
14824       switch (r_type)
14825         {
14826         default:
14827           break;
14828
14829         case R_PPC64_GOT_TLSLD16_HI:
14830         case R_PPC64_GOT_TLSGD16_HI:
14831         case R_PPC64_GOT_TPREL16_HI:
14832         case R_PPC64_GOT_DTPREL16_HI:
14833         case R_PPC64_GOT16_HI:
14834         case R_PPC64_TOC16_HI:
14835           /* These relocs would only be useful if building up an
14836              offset to later add to r2, perhaps in an indexed
14837              addressing mode instruction.  Don't try to optimize.
14838              Unfortunately, the possibility of someone building up an
14839              offset like this or even with the HA relocs, means that
14840              we need to check the high insn when optimizing the low
14841              insn.  */
14842           break;
14843
14844         case R_PPC64_GOT_TLSLD16_HA:
14845         case R_PPC64_GOT_TLSGD16_HA:
14846         case R_PPC64_GOT_TPREL16_HA:
14847         case R_PPC64_GOT_DTPREL16_HA:
14848         case R_PPC64_GOT16_HA:
14849         case R_PPC64_TOC16_HA:
14850           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14851               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14852             {
14853               bfd_byte *p = contents + (rel->r_offset & ~3);
14854               bfd_put_32 (input_bfd, NOP, p);
14855             }
14856           break;
14857
14858         case R_PPC64_GOT_TLSLD16_LO:
14859         case R_PPC64_GOT_TLSGD16_LO:
14860         case R_PPC64_GOT_TPREL16_LO_DS:
14861         case R_PPC64_GOT_DTPREL16_LO_DS:
14862         case R_PPC64_GOT16_LO:
14863         case R_PPC64_GOT16_LO_DS:
14864         case R_PPC64_TOC16_LO:
14865         case R_PPC64_TOC16_LO_DS:
14866           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14867               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14868             {
14869               bfd_byte *p = contents + (rel->r_offset & ~3);
14870               insn = bfd_get_32 (input_bfd, p);
14871               if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
14872                 {
14873                   /* Transform addic to addi when we change reg.  */
14874                   insn &= ~((0x3f << 26) | (0x1f << 16));
14875                   insn |= (14u << 26) | (2 << 16);
14876                 }
14877               else
14878                 {
14879                   insn &= ~(0x1f << 16);
14880                   insn |= 2 << 16;
14881                 }
14882               bfd_put_32 (input_bfd, insn, p);
14883             }
14884           break;
14885         }
14886
14887       /* Do any further special processing.  */
14888       howto = ppc64_elf_howto_table[(int) r_type];
14889       switch (r_type)
14890         {
14891         default:
14892           break;
14893
14894         case R_PPC64_REL16_HA:
14895         case R_PPC64_REL16DX_HA:
14896         case R_PPC64_ADDR16_HA:
14897         case R_PPC64_ADDR16_HIGHA:
14898         case R_PPC64_ADDR16_HIGHERA:
14899         case R_PPC64_ADDR16_HIGHESTA:
14900         case R_PPC64_TOC16_HA:
14901         case R_PPC64_SECTOFF_HA:
14902         case R_PPC64_TPREL16_HA:
14903         case R_PPC64_TPREL16_HIGHA:
14904         case R_PPC64_TPREL16_HIGHERA:
14905         case R_PPC64_TPREL16_HIGHESTA:
14906         case R_PPC64_DTPREL16_HA:
14907         case R_PPC64_DTPREL16_HIGHA:
14908         case R_PPC64_DTPREL16_HIGHERA:
14909         case R_PPC64_DTPREL16_HIGHESTA:
14910           /* It's just possible that this symbol is a weak symbol
14911              that's not actually defined anywhere. In that case,
14912              'sec' would be NULL, and we should leave the symbol
14913              alone (it will be set to zero elsewhere in the link).  */
14914           if (sec == NULL)
14915             break;
14916           /* Fall thru */
14917
14918         case R_PPC64_GOT16_HA:
14919         case R_PPC64_PLTGOT16_HA:
14920         case R_PPC64_PLT16_HA:
14921         case R_PPC64_GOT_TLSGD16_HA:
14922         case R_PPC64_GOT_TLSLD16_HA:
14923         case R_PPC64_GOT_TPREL16_HA:
14924         case R_PPC64_GOT_DTPREL16_HA:
14925           /* Add 0x10000 if sign bit in 0:15 is set.
14926              Bits 0:15 are not used.  */
14927           addend += 0x8000;
14928           break;
14929
14930         case R_PPC64_ADDR16_DS:
14931         case R_PPC64_ADDR16_LO_DS:
14932         case R_PPC64_GOT16_DS:
14933         case R_PPC64_GOT16_LO_DS:
14934         case R_PPC64_PLT16_LO_DS:
14935         case R_PPC64_SECTOFF_DS:
14936         case R_PPC64_SECTOFF_LO_DS:
14937         case R_PPC64_TOC16_DS:
14938         case R_PPC64_TOC16_LO_DS:
14939         case R_PPC64_PLTGOT16_DS:
14940         case R_PPC64_PLTGOT16_LO_DS:
14941         case R_PPC64_GOT_TPREL16_DS:
14942         case R_PPC64_GOT_TPREL16_LO_DS:
14943         case R_PPC64_GOT_DTPREL16_DS:
14944         case R_PPC64_GOT_DTPREL16_LO_DS:
14945         case R_PPC64_TPREL16_DS:
14946         case R_PPC64_TPREL16_LO_DS:
14947         case R_PPC64_DTPREL16_DS:
14948         case R_PPC64_DTPREL16_LO_DS:
14949           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
14950           mask = 3;
14951           /* If this reloc is against an lq, lxv, or stxv insn, then
14952              the value must be a multiple of 16.  This is somewhat of
14953              a hack, but the "correct" way to do this by defining _DQ
14954              forms of all the _DS relocs bloats all reloc switches in
14955              this file.  It doesn't make much sense to use these
14956              relocs in data, so testing the insn should be safe.  */
14957           if ((insn & (0x3f << 26)) == (56u << 26)
14958               || ((insn & (0x3f << 26)) == (61u << 26) && (insn & 3) == 1))
14959             mask = 15;
14960           relocation += addend;
14961           addend = insn & (mask ^ 3);
14962           if ((relocation & mask) != 0)
14963             {
14964               relocation ^= relocation & mask;
14965               info->callbacks->einfo
14966                 (_("%P: %H: error: %s not a multiple of %u\n"),
14967                  input_bfd, input_section, rel->r_offset,
14968                  howto->name,
14969                  mask + 1);
14970               bfd_set_error (bfd_error_bad_value);
14971               ret = FALSE;
14972               goto copy_reloc;
14973             }
14974           break;
14975         }
14976
14977       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
14978          because such sections are not SEC_ALLOC and thus ld.so will
14979          not process them.  */
14980       if (unresolved_reloc
14981           && !((input_section->flags & SEC_DEBUGGING) != 0
14982                && h->elf.def_dynamic)
14983           && _bfd_elf_section_offset (output_bfd, info, input_section,
14984                                       rel->r_offset) != (bfd_vma) -1)
14985         {
14986           info->callbacks->einfo
14987             (_("%P: %H: unresolvable %s against `%T'\n"),
14988              input_bfd, input_section, rel->r_offset,
14989              howto->name,
14990              h->elf.root.root.string);
14991           ret = FALSE;
14992         }
14993
14994       /* 16-bit fields in insns mostly have signed values, but a
14995          few insns have 16-bit unsigned values.  Really, we should
14996          have different reloc types.  */
14997       if (howto->complain_on_overflow != complain_overflow_dont
14998           && howto->dst_mask == 0xffff
14999           && (input_section->flags & SEC_CODE) != 0)
15000         {
15001           enum complain_overflow complain = complain_overflow_signed;
15002
15003           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15004           if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
15005             complain = complain_overflow_bitfield;
15006           else if (howto->rightshift == 0
15007                    ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
15008                       || (insn & (0x3f << 26)) == 24u << 26 /* ori */
15009                       || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
15010                    : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
15011                       || (insn & (0x3f << 26)) == 25u << 26 /* oris */
15012                       || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
15013             complain = complain_overflow_unsigned;
15014           if (howto->complain_on_overflow != complain)
15015             {
15016               alt_howto = *howto;
15017               alt_howto.complain_on_overflow = complain;
15018               howto = &alt_howto;
15019             }
15020         }
15021
15022       if (r_type == R_PPC64_REL16DX_HA)
15023         {
15024           /* Split field reloc isn't handled by _bfd_final_link_relocate.  */
15025           if (rel->r_offset + 4 > input_section->size)
15026             r = bfd_reloc_outofrange;
15027           else
15028             {
15029               relocation += addend;
15030               relocation -= (rel->r_offset
15031                              + input_section->output_offset
15032                              + input_section->output_section->vma);
15033               relocation = (bfd_signed_vma) relocation >> 16;
15034               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
15035               insn &= ~0x1fffc1;
15036               insn |= (relocation & 0xffc1) | ((relocation & 0x3e) << 15);
15037               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
15038               r = bfd_reloc_ok;
15039               if (relocation + 0x8000 > 0xffff)
15040                 r = bfd_reloc_overflow;
15041             }
15042         }
15043       else
15044         r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
15045                                       rel->r_offset, relocation, addend);
15046
15047       if (r != bfd_reloc_ok)
15048         {
15049           char *more_info = NULL;
15050           const char *reloc_name = howto->name;
15051
15052           if (reloc_dest != DEST_NORMAL)
15053             {
15054               more_info = bfd_malloc (strlen (reloc_name) + 8);
15055               if (more_info != NULL)
15056                 {
15057                   strcpy (more_info, reloc_name);
15058                   strcat (more_info, (reloc_dest == DEST_OPD
15059                                       ? " (OPD)" : " (stub)"));
15060                   reloc_name = more_info;
15061                 }
15062             }
15063
15064           if (r == bfd_reloc_overflow)
15065             {
15066               /* On code like "if (foo) foo();" don't report overflow
15067                  on a branch to zero when foo is undefined.  */
15068               if (!warned
15069                   && (reloc_dest == DEST_STUB
15070                       || !(h != NULL
15071                            && (h->elf.root.type == bfd_link_hash_undefweak
15072                                || h->elf.root.type == bfd_link_hash_undefined)
15073                            && is_branch_reloc (r_type))))
15074                 {
15075                   if (!((*info->callbacks->reloc_overflow)
15076                         (info, &h->elf.root, sym_name,
15077                          reloc_name, orig_rel.r_addend,
15078                          input_bfd, input_section, rel->r_offset)))
15079                     return FALSE;
15080                 }
15081             }
15082           else
15083             {
15084               info->callbacks->einfo
15085                 (_("%P: %H: %s against `%T': error %d\n"),
15086                  input_bfd, input_section, rel->r_offset,
15087                  reloc_name, sym_name, (int) r);
15088               ret = FALSE;
15089             }
15090           if (more_info != NULL)
15091             free (more_info);
15092         }
15093     copy_reloc:
15094       if (wrel != rel)
15095         *wrel = *rel;
15096     }
15097
15098   if (wrel != rel)
15099     {
15100       Elf_Internal_Shdr *rel_hdr;
15101       size_t deleted = rel - wrel;
15102
15103       rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
15104       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15105       if (rel_hdr->sh_size == 0)
15106         {
15107           /* It is too late to remove an empty reloc section.  Leave
15108              one NONE reloc.
15109              ??? What is wrong with an empty section???  */
15110           rel_hdr->sh_size = rel_hdr->sh_entsize;
15111           deleted -= 1;
15112         }
15113       rel_hdr = _bfd_elf_single_rel_hdr (input_section);
15114       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15115       input_section->reloc_count -= deleted;
15116     }
15117
15118   /* If we're emitting relocations, then shortly after this function
15119      returns, reloc offsets and addends for this section will be
15120      adjusted.  Worse, reloc symbol indices will be for the output
15121      file rather than the input.  Save a copy of the relocs for
15122      opd_entry_value.  */
15123   if (is_opd && (info->emitrelocations || bfd_link_relocatable (info)))
15124     {
15125       bfd_size_type amt;
15126       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
15127       rel = bfd_alloc (input_bfd, amt);
15128       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
15129       ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
15130       if (rel == NULL)
15131         return FALSE;
15132       memcpy (rel, relocs, amt);
15133     }
15134   return ret;
15135 }
15136
15137 /* Adjust the value of any local symbols in opd sections.  */
15138
15139 static int
15140 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
15141                               const char *name ATTRIBUTE_UNUSED,
15142                               Elf_Internal_Sym *elfsym,
15143                               asection *input_sec,
15144                               struct elf_link_hash_entry *h)
15145 {
15146   struct _opd_sec_data *opd;
15147   long adjust;
15148   bfd_vma value;
15149
15150   if (h != NULL)
15151     return 1;
15152
15153   opd = get_opd_info (input_sec);
15154   if (opd == NULL || opd->adjust == NULL)
15155     return 1;
15156
15157   value = elfsym->st_value - input_sec->output_offset;
15158   if (!bfd_link_relocatable (info))
15159     value -= input_sec->output_section->vma;
15160
15161   adjust = opd->adjust[OPD_NDX (value)];
15162   if (adjust == -1)
15163     return 2;
15164
15165   elfsym->st_value += adjust;
15166   return 1;
15167 }
15168
15169 /* Finish up dynamic symbol handling.  We set the contents of various
15170    dynamic sections here.  */
15171
15172 static bfd_boolean
15173 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
15174                                  struct bfd_link_info *info,
15175                                  struct elf_link_hash_entry *h,
15176                                  Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
15177 {
15178   struct ppc_link_hash_table *htab;
15179   struct plt_entry *ent;
15180   Elf_Internal_Rela rela;
15181   bfd_byte *loc;
15182
15183   htab = ppc_hash_table (info);
15184   if (htab == NULL)
15185     return FALSE;
15186
15187   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
15188     if (ent->plt.offset != (bfd_vma) -1)
15189       {
15190         /* This symbol has an entry in the procedure linkage
15191            table.  Set it up.  */
15192         if (!htab->elf.dynamic_sections_created
15193             || h->dynindx == -1)
15194           {
15195             BFD_ASSERT (h->type == STT_GNU_IFUNC
15196                         && h->def_regular
15197                         && (h->root.type == bfd_link_hash_defined
15198                             || h->root.type == bfd_link_hash_defweak));
15199             rela.r_offset = (htab->elf.iplt->output_section->vma
15200                              + htab->elf.iplt->output_offset
15201                              + ent->plt.offset);
15202             if (htab->opd_abi)
15203               rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
15204             else
15205               rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15206             rela.r_addend = (h->root.u.def.value
15207                              + h->root.u.def.section->output_offset
15208                              + h->root.u.def.section->output_section->vma
15209                              + ent->addend);
15210             loc = (htab->elf.irelplt->contents
15211                    + (htab->elf.irelplt->reloc_count++
15212                       * sizeof (Elf64_External_Rela)));
15213           }
15214         else
15215           {
15216             rela.r_offset = (htab->elf.splt->output_section->vma
15217                              + htab->elf.splt->output_offset
15218                              + ent->plt.offset);
15219             rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
15220             rela.r_addend = ent->addend;
15221             loc = (htab->elf.srelplt->contents
15222                    + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
15223                       / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
15224           }
15225         bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15226
15227         if (!htab->opd_abi)
15228           {
15229             if (!h->def_regular)
15230               {
15231                 /* Mark the symbol as undefined, rather than as
15232                    defined in glink.  Leave the value if there were
15233                    any relocations where pointer equality matters
15234                    (this is a clue for the dynamic linker, to make
15235                    function pointer comparisons work between an
15236                    application and shared library), otherwise set it
15237                    to zero.  */
15238                 sym->st_shndx = SHN_UNDEF;
15239                 if (!h->pointer_equality_needed)
15240                   sym->st_value = 0;
15241                 else if (!h->ref_regular_nonweak)
15242                   {
15243                     /* This breaks function pointer comparisons, but
15244                        that is better than breaking tests for a NULL
15245                        function pointer.  */
15246                     sym->st_value = 0;
15247                   }
15248               }
15249           }
15250       }
15251
15252   if (h->needs_copy)
15253     {
15254       /* This symbol needs a copy reloc.  Set it up.  */
15255
15256       if (h->dynindx == -1
15257           || (h->root.type != bfd_link_hash_defined
15258               && h->root.type != bfd_link_hash_defweak)
15259           || htab->relbss == NULL)
15260         abort ();
15261
15262       rela.r_offset = (h->root.u.def.value
15263                        + h->root.u.def.section->output_section->vma
15264                        + h->root.u.def.section->output_offset);
15265       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
15266       rela.r_addend = 0;
15267       loc = htab->relbss->contents;
15268       loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
15269       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15270     }
15271
15272   return TRUE;
15273 }
15274
15275 /* Used to decide how to sort relocs in an optimal manner for the
15276    dynamic linker, before writing them out.  */
15277
15278 static enum elf_reloc_type_class
15279 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
15280                             const asection *rel_sec,
15281                             const Elf_Internal_Rela *rela)
15282 {
15283   enum elf_ppc64_reloc_type r_type;
15284   struct ppc_link_hash_table *htab = ppc_hash_table (info);
15285
15286   if (rel_sec == htab->elf.irelplt)
15287     return reloc_class_ifunc;
15288
15289   r_type = ELF64_R_TYPE (rela->r_info);
15290   switch (r_type)
15291     {
15292     case R_PPC64_RELATIVE:
15293       return reloc_class_relative;
15294     case R_PPC64_JMP_SLOT:
15295       return reloc_class_plt;
15296     case R_PPC64_COPY:
15297       return reloc_class_copy;
15298     default:
15299       return reloc_class_normal;
15300     }
15301 }
15302
15303 /* Finish up the dynamic sections.  */
15304
15305 static bfd_boolean
15306 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
15307                                    struct bfd_link_info *info)
15308 {
15309   struct ppc_link_hash_table *htab;
15310   bfd *dynobj;
15311   asection *sdyn;
15312
15313   htab = ppc_hash_table (info);
15314   if (htab == NULL)
15315     return FALSE;
15316
15317   dynobj = htab->elf.dynobj;
15318   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
15319
15320   if (htab->elf.dynamic_sections_created)
15321     {
15322       Elf64_External_Dyn *dyncon, *dynconend;
15323
15324       if (sdyn == NULL || htab->elf.sgot == NULL)
15325         abort ();
15326
15327       dyncon = (Elf64_External_Dyn *) sdyn->contents;
15328       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
15329       for (; dyncon < dynconend; dyncon++)
15330         {
15331           Elf_Internal_Dyn dyn;
15332           asection *s;
15333
15334           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
15335
15336           switch (dyn.d_tag)
15337             {
15338             default:
15339               continue;
15340
15341             case DT_PPC64_GLINK:
15342               s = htab->glink;
15343               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15344               /* We stupidly defined DT_PPC64_GLINK to be the start
15345                  of glink rather than the first entry point, which is
15346                  what ld.so needs, and now have a bigger stub to
15347                  support automatic multiple TOCs.  */
15348               dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
15349               break;
15350
15351             case DT_PPC64_OPD:
15352               s = bfd_get_section_by_name (output_bfd, ".opd");
15353               if (s == NULL)
15354                 continue;
15355               dyn.d_un.d_ptr = s->vma;
15356               break;
15357
15358             case DT_PPC64_OPT:
15359               if (htab->do_multi_toc && htab->multi_toc_needed)
15360                 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
15361               break;
15362
15363             case DT_PPC64_OPDSZ:
15364               s = bfd_get_section_by_name (output_bfd, ".opd");
15365               if (s == NULL)
15366                 continue;
15367               dyn.d_un.d_val = s->size;
15368               break;
15369
15370             case DT_PLTGOT:
15371               s = htab->elf.splt;
15372               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15373               break;
15374
15375             case DT_JMPREL:
15376               s = htab->elf.srelplt;
15377               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15378               break;
15379
15380             case DT_PLTRELSZ:
15381               dyn.d_un.d_val = htab->elf.srelplt->size;
15382               break;
15383
15384             case DT_RELASZ:
15385               /* Don't count procedure linkage table relocs in the
15386                  overall reloc count.  */
15387               s = htab->elf.srelplt;
15388               if (s == NULL)
15389                 continue;
15390               dyn.d_un.d_val -= s->size;
15391               break;
15392
15393             case DT_RELA:
15394               /* We may not be using the standard ELF linker script.
15395                  If .rela.plt is the first .rela section, we adjust
15396                  DT_RELA to not include it.  */
15397               s = htab->elf.srelplt;
15398               if (s == NULL)
15399                 continue;
15400               if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
15401                 continue;
15402               dyn.d_un.d_ptr += s->size;
15403               break;
15404             }
15405
15406           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
15407         }
15408     }
15409
15410   if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0)
15411     {
15412       /* Fill in the first entry in the global offset table.
15413          We use it to hold the link-time TOCbase.  */
15414       bfd_put_64 (output_bfd,
15415                   elf_gp (output_bfd) + TOC_BASE_OFF,
15416                   htab->elf.sgot->contents);
15417
15418       /* Set .got entry size.  */
15419       elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
15420     }
15421
15422   if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
15423     {
15424       /* Set .plt entry size.  */
15425       elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
15426         = PLT_ENTRY_SIZE (htab);
15427     }
15428
15429   /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
15430      brlt ourselves if emitrelocations.  */
15431   if (htab->brlt != NULL
15432       && htab->brlt->reloc_count != 0
15433       && !_bfd_elf_link_output_relocs (output_bfd,
15434                                        htab->brlt,
15435                                        elf_section_data (htab->brlt)->rela.hdr,
15436                                        elf_section_data (htab->brlt)->relocs,
15437                                        NULL))
15438     return FALSE;
15439
15440   if (htab->glink != NULL
15441       && htab->glink->reloc_count != 0
15442       && !_bfd_elf_link_output_relocs (output_bfd,
15443                                        htab->glink,
15444                                        elf_section_data (htab->glink)->rela.hdr,
15445                                        elf_section_data (htab->glink)->relocs,
15446                                        NULL))
15447     return FALSE;
15448
15449   if (htab->glink_eh_frame != NULL
15450       && htab->glink_eh_frame->size != 0)
15451     {
15452       bfd_vma val;
15453       bfd_byte *p;
15454       asection *stub_sec;
15455
15456       p = htab->glink_eh_frame->contents + sizeof (glink_eh_frame_cie);
15457       for (stub_sec = htab->params->stub_bfd->sections;
15458            stub_sec != NULL;
15459            stub_sec = stub_sec->next)
15460         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
15461           {
15462             /* FDE length.  */
15463             p += 4;
15464             /* CIE pointer.  */
15465             p += 4;
15466             /* Offset to stub section.  */
15467             val = (stub_sec->output_section->vma
15468                    + stub_sec->output_offset);
15469             val -= (htab->glink_eh_frame->output_section->vma
15470                     + htab->glink_eh_frame->output_offset
15471                     + (p - htab->glink_eh_frame->contents));
15472             if (val + 0x80000000 > 0xffffffff)
15473               {
15474                 info->callbacks->einfo
15475                   (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15476                    stub_sec->name);
15477                 return FALSE;
15478               }
15479             bfd_put_32 (dynobj, val, p);
15480             p += 4;
15481             /* stub section size.  */
15482             p += 4;
15483             /* Augmentation.  */
15484             p += 1;
15485             /* Pad.  */
15486             p += 7;
15487           }
15488       if (htab->glink != NULL && htab->glink->size != 0)
15489         {
15490           /* FDE length.  */
15491           p += 4;
15492           /* CIE pointer.  */
15493           p += 4;
15494           /* Offset to .glink.  */
15495           val = (htab->glink->output_section->vma
15496                  + htab->glink->output_offset
15497                  + 8);
15498           val -= (htab->glink_eh_frame->output_section->vma
15499                   + htab->glink_eh_frame->output_offset
15500                   + (p - htab->glink_eh_frame->contents));
15501           if (val + 0x80000000 > 0xffffffff)
15502             {
15503               info->callbacks->einfo
15504                 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15505                  htab->glink->name);
15506               return FALSE;
15507             }
15508           bfd_put_32 (dynobj, val, p);
15509           p += 4;
15510           /* .glink size.  */
15511           p += 4;
15512           /* Augmentation.  */
15513           p += 1;
15514           /* Ops.  */
15515           p += 7;
15516         }
15517
15518       if (htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
15519           && !_bfd_elf_write_section_eh_frame (output_bfd, info,
15520                                                htab->glink_eh_frame,
15521                                                htab->glink_eh_frame->contents))
15522         return FALSE;
15523     }
15524
15525   /* We need to handle writing out multiple GOT sections ourselves,
15526      since we didn't add them to DYNOBJ.  We know dynobj is the first
15527      bfd.  */
15528   while ((dynobj = dynobj->link.next) != NULL)
15529     {
15530       asection *s;
15531
15532       if (!is_ppc64_elf (dynobj))
15533         continue;
15534
15535       s = ppc64_elf_tdata (dynobj)->got;
15536       if (s != NULL
15537           && s->size != 0
15538           && s->output_section != bfd_abs_section_ptr
15539           && !bfd_set_section_contents (output_bfd, s->output_section,
15540                                         s->contents, s->output_offset,
15541                                         s->size))
15542         return FALSE;
15543       s = ppc64_elf_tdata (dynobj)->relgot;
15544       if (s != NULL
15545           && s->size != 0
15546           && s->output_section != bfd_abs_section_ptr
15547           && !bfd_set_section_contents (output_bfd, s->output_section,
15548                                         s->contents, s->output_offset,
15549                                         s->size))
15550         return FALSE;
15551     }
15552
15553   return TRUE;
15554 }
15555
15556 #include "elf64-target.h"
15557
15558 /* FreeBSD support */
15559
15560 #undef  TARGET_LITTLE_SYM
15561 #undef  TARGET_LITTLE_NAME
15562
15563 #undef  TARGET_BIG_SYM
15564 #define TARGET_BIG_SYM  powerpc_elf64_fbsd_vec
15565 #undef  TARGET_BIG_NAME
15566 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15567
15568 #undef  ELF_OSABI
15569 #define ELF_OSABI       ELFOSABI_FREEBSD
15570
15571 #undef  elf64_bed
15572 #define elf64_bed       elf64_powerpc_fbsd_bed
15573
15574 #include "elf64-target.h"
15575