bfd/elf64-ppc.c

   1 /* PowerPC64-specific support for 64-bit ELF.
   2    Copyright (C) 1999-2016 Free Software Foundation, Inc.
   3    Written by Linus Nordberg, Swox AB <info@swox.com>,
   4    based on elf32-ppc.c by Ian Lance Taylor.
   5    Largely rewritten by Alan Modra.
   6
   7    This file is part of BFD, the Binary File Descriptor library.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License along
  20    with this program; if not, write to the Free Software Foundation, Inc.,
  21    51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
  22
  23
  24 /* The 64-bit PowerPC ELF ABI may be found at
  25    http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and
  26    http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html  */
  27
  28 #include "sysdep.h"
  29 #include <stdarg.h>
  30 #include "bfd.h"
  31 #include "bfdlink.h"
  32 #include "libbfd.h"
  33 #include "elf-bfd.h"
  34 #include "elf/ppc64.h"
  35 #include "elf64-ppc.h"
  36 #include "dwarf2.h"
  37
  38 static bfd_reloc_status_type ppc64_elf_ha_reloc
  39   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  40 static bfd_reloc_status_type ppc64_elf_branch_reloc
  41   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  42 static bfd_reloc_status_type ppc64_elf_brtaken_reloc
  43   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  44 static bfd_reloc_status_type ppc64_elf_sectoff_reloc
  45   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  46 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
  47   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  48 static bfd_reloc_status_type ppc64_elf_toc_reloc
  49   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  50 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
  51   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  52 static bfd_reloc_status_type ppc64_elf_toc64_reloc
  53   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  54 static bfd_reloc_status_type ppc64_elf_unhandled_reloc
  55   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  56 static bfd_vma opd_entry_value
  57   (asection *, bfd_vma, asection **, bfd_vma *, bfd_boolean);
  58
  59 #define TARGET_LITTLE_SYM       powerpc_elf64_le_vec
  60 #define TARGET_LITTLE_NAME      "elf64-powerpcle"
  61 #define TARGET_BIG_SYM          powerpc_elf64_vec
  62 #define TARGET_BIG_NAME         "elf64-powerpc"
  63 #define ELF_ARCH                bfd_arch_powerpc
  64 #define ELF_TARGET_ID           PPC64_ELF_DATA
  65 #define ELF_MACHINE_CODE        EM_PPC64
  66 #define ELF_MAXPAGESIZE         0x10000
  67 #define ELF_COMMONPAGESIZE      0x10000
  68 #define elf_info_to_howto       ppc64_elf_info_to_howto
  69
  70 #define elf_backend_want_got_sym 0
  71 #define elf_backend_want_plt_sym 0
  72 #define elf_backend_plt_alignment 3
  73 #define elf_backend_plt_not_loaded 1
  74 #define elf_backend_got_header_size 8
  75 #define elf_backend_can_gc_sections 1
  76 #define elf_backend_can_refcount 1
  77 #define elf_backend_rela_normal 1
  78 #define elf_backend_default_execstack 0
  79
  80 #define bfd_elf64_mkobject                    ppc64_elf_mkobject
  81 #define bfd_elf64_bfd_reloc_type_lookup       ppc64_elf_reloc_type_lookup
  82 #define bfd_elf64_bfd_reloc_name_lookup       ppc64_elf_reloc_name_lookup
  83 #define bfd_elf64_bfd_merge_private_bfd_data  ppc64_elf_merge_private_bfd_data
  84 #define bfd_elf64_bfd_print_private_bfd_data  ppc64_elf_print_private_bfd_data
  85 #define bfd_elf64_new_section_hook            ppc64_elf_new_section_hook
  86 #define bfd_elf64_bfd_link_hash_table_create  ppc64_elf_link_hash_table_create
  87 #define bfd_elf64_get_synthetic_symtab        ppc64_elf_get_synthetic_symtab
  88 #define bfd_elf64_bfd_link_just_syms          ppc64_elf_link_just_syms
  89
  90 #define elf_backend_object_p                  ppc64_elf_object_p
  91 #define elf_backend_grok_prstatus             ppc64_elf_grok_prstatus
  92 #define elf_backend_grok_psinfo               ppc64_elf_grok_psinfo
  93 #define elf_backend_write_core_note           ppc64_elf_write_core_note
  94 #define elf_backend_create_dynamic_sections   ppc64_elf_create_dynamic_sections
  95 #define elf_backend_copy_indirect_symbol      ppc64_elf_copy_indirect_symbol
  96 #define elf_backend_add_symbol_hook           ppc64_elf_add_symbol_hook
  97 #define elf_backend_check_directives          ppc64_elf_before_check_relocs
  98 #define elf_backend_notice_as_needed          ppc64_elf_notice_as_needed
  99 #define elf_backend_archive_symbol_lookup     ppc64_elf_archive_symbol_lookup
 100 #define elf_backend_check_relocs              ppc64_elf_check_relocs
 101 #define elf_backend_gc_keep                   ppc64_elf_gc_keep
 102 #define elf_backend_gc_mark_dynamic_ref       ppc64_elf_gc_mark_dynamic_ref
 103 #define elf_backend_gc_mark_hook              ppc64_elf_gc_mark_hook
 104 #define elf_backend_gc_sweep_hook             ppc64_elf_gc_sweep_hook
 105 #define elf_backend_adjust_dynamic_symbol     ppc64_elf_adjust_dynamic_symbol
 106 #define elf_backend_hide_symbol               ppc64_elf_hide_symbol
 107 #define elf_backend_maybe_function_sym        ppc64_elf_maybe_function_sym
 108 #define elf_backend_always_size_sections      ppc64_elf_func_desc_adjust
 109 #define elf_backend_size_dynamic_sections     ppc64_elf_size_dynamic_sections
 110 #define elf_backend_hash_symbol               ppc64_elf_hash_symbol
 111 #define elf_backend_init_index_section        _bfd_elf_init_2_index_sections
 112 #define elf_backend_action_discarded          ppc64_elf_action_discarded
 113 #define elf_backend_relocate_section          ppc64_elf_relocate_section
 114 #define elf_backend_finish_dynamic_symbol     ppc64_elf_finish_dynamic_symbol
 115 #define elf_backend_reloc_type_class          ppc64_elf_reloc_type_class
 116 #define elf_backend_finish_dynamic_sections   ppc64_elf_finish_dynamic_sections
 117 #define elf_backend_link_output_symbol_hook   ppc64_elf_output_symbol_hook
 118 #define elf_backend_special_sections          ppc64_elf_special_sections
 119 #define elf_backend_merge_symbol_attribute    ppc64_elf_merge_symbol_attribute
 120
 121 /* The name of the dynamic interpreter.  This is put in the .interp
 122    section.  */
 123 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
 124
 125 /* The size in bytes of an entry in the procedure linkage table.  */
 126 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
 127
 128 /* The initial size of the plt reserved for the dynamic linker.  */
 129 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
 130
 131 /* Offsets to some stack save slots.  */
 132 #define STK_LR 16
 133 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
 134 /* This one is dodgy.  ELFv2 does not have a linker word, so use the
 135    CR save slot.  Used only by optimised __tls_get_addr call stub,
 136    relying on __tls_get_addr_opt not saving CR..  */
 137 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
 138
 139 /* TOC base pointers offset from start of TOC.  */
 140 #define TOC_BASE_OFF    0x8000
 141 /* TOC base alignment.  */
 142 #define TOC_BASE_ALIGN  256
 143
 144 /* Offset of tp and dtp pointers from start of TLS block.  */
 145 #define TP_OFFSET       0x7000
 146 #define DTP_OFFSET      0x8000
 147
 148 /* .plt call stub instructions.  The normal stub is like this, but
 149    sometimes the .plt entry crosses a 64k boundary and we need to
 150    insert an addi to adjust r11.  */
 151 #define STD_R2_0R1      0xf8410000      /* std   %r2,0+40(%r1)       */
 152 #define ADDIS_R11_R2    0x3d620000      /* addis %r11,%r2,xxx@ha     */
 153 #define LD_R12_0R11     0xe98b0000      /* ld    %r12,xxx+0@l(%r11)  */
 154 #define MTCTR_R12       0x7d8903a6      /* mtctr %r12                */
 155 #define LD_R2_0R11      0xe84b0000      /* ld    %r2,xxx+8@l(%r11)   */
 156 #define LD_R11_0R11     0xe96b0000      /* ld    %r11,xxx+16@l(%r11) */
 157 #define BCTR            0x4e800420      /* bctr                      */
 158
 159 #define ADDI_R11_R11    0x396b0000      /* addi %r11,%r11,off@l  */
 160 #define ADDIS_R2_R2     0x3c420000      /* addis %r2,%r2,off@ha  */
 161 #define ADDI_R2_R2      0x38420000      /* addi  %r2,%r2,off@l   */
 162
 163 #define XOR_R2_R12_R12  0x7d826278      /* xor   %r2,%r12,%r12   */
 164 #define ADD_R11_R11_R2  0x7d6b1214      /* add   %r11,%r11,%r2   */
 165 #define XOR_R11_R12_R12 0x7d8b6278      /* xor   %r11,%r12,%r12  */
 166 #define ADD_R2_R2_R11   0x7c425a14      /* add   %r2,%r2,%r11    */
 167 #define CMPLDI_R2_0     0x28220000      /* cmpldi %r2,0          */
 168 #define BNECTR          0x4ca20420      /* bnectr+               */
 169 #define BNECTR_P4       0x4ce20420      /* bnectr+               */
 170
 171 #define LD_R12_0R2      0xe9820000      /* ld    %r12,xxx+0(%r2) */
 172 #define LD_R11_0R2      0xe9620000      /* ld    %r11,xxx+0(%r2) */
 173 #define LD_R2_0R2       0xe8420000      /* ld    %r2,xxx+0(%r2)  */
 174
 175 #define LD_R2_0R1       0xe8410000      /* ld    %r2,0(%r1)      */
 176 #define LD_R2_0R12      0xe84c0000      /* ld    %r2,0(%r12)     */
 177 #define ADD_R2_R2_R12   0x7c426214      /* add   %r2,%r2,%r12    */
 178
 179 #define LIS_R2          0x3c400000      /* lis %r2,xxx@ha         */
 180 #define ADDIS_R2_R12    0x3c4c0000      /* addis %r2,%r12,xxx@ha  */
 181 #define ADDIS_R12_R2    0x3d820000      /* addis %r12,%r2,xxx@ha  */
 182 #define ADDIS_R12_R12   0x3d8c0000      /* addis %r12,%r12,xxx@ha */
 183 #define LD_R12_0R12     0xe98c0000      /* ld    %r12,xxx@l(%r12) */
 184
 185 /* glink call stub instructions.  We enter with the index in R0.  */
 186 #define GLINK_CALL_STUB_SIZE (16*4)
 187                                         /* 0:                           */
 188                                         /*  .quad plt0-1f               */
 189                                         /* __glink:                     */
 190 #define MFLR_R12        0x7d8802a6      /*  mflr %12                    */
 191 #define BCL_20_31       0x429f0005      /*  bcl 20,31,1f                */
 192                                         /* 1:                           */
 193 #define MFLR_R11        0x7d6802a6      /*  mflr %11                    */
 194                                         /*  ld %2,(0b-1b)(%11)          */
 195 #define MTLR_R12        0x7d8803a6      /*  mtlr %12                    */
 196 #define ADD_R11_R2_R11  0x7d625a14      /*  add %11,%2,%11              */
 197                                         /*  ld %12,0(%11)               */
 198                                         /*  ld %2,8(%11)                */
 199                                         /*  mtctr %12                   */
 200                                         /*  ld %11,16(%11)              */
 201                                         /*  bctr                        */
 202 #define MFLR_R0         0x7c0802a6      /*  mflr %r0                    */
 203 #define MTLR_R0         0x7c0803a6      /*  mtlr %r0                    */
 204 #define SUB_R12_R12_R11 0x7d8b6050      /*  subf %r12,%r11,%r12         */
 205 #define ADDI_R0_R12     0x380c0000      /*  addi %r0,%r12,0             */
 206 #define SRDI_R0_R0_2    0x7800f082      /*  rldicl %r0,%r0,62,2         */
 207
 208 /* Pad with this.  */
 209 #define NOP             0x60000000
 210
 211 /* Some other nops.  */
 212 #define CROR_151515     0x4def7b82
 213 #define CROR_313131     0x4ffffb82
 214
 215 /* .glink entries for the first 32k functions are two instructions.  */
 216 #define LI_R0_0         0x38000000      /* li    %r0,0          */
 217 #define B_DOT           0x48000000      /* b     .              */
 218
 219 /* After that, we need two instructions to load the index, followed by
 220    a branch.  */
 221 #define LIS_R0_0        0x3c000000      /* lis   %r0,0          */
 222 #define ORI_R0_R0_0     0x60000000      /* ori   %r0,%r0,0      */
 223
 224 /* Instructions used by the save and restore reg functions.  */
 225 #define STD_R0_0R1      0xf8010000      /* std   %r0,0(%r1)     */
 226 #define STD_R0_0R12     0xf80c0000      /* std   %r0,0(%r12)    */
 227 #define LD_R0_0R1       0xe8010000      /* ld    %r0,0(%r1)     */
 228 #define LD_R0_0R12      0xe80c0000      /* ld    %r0,0(%r12)    */
 229 #define STFD_FR0_0R1    0xd8010000      /* stfd  %fr0,0(%r1)    */
 230 #define LFD_FR0_0R1     0xc8010000      /* lfd   %fr0,0(%r1)    */
 231 #define LI_R12_0        0x39800000      /* li    %r12,0         */
 232 #define STVX_VR0_R12_R0 0x7c0c01ce      /* stvx  %v0,%r12,%r0   */
 233 #define LVX_VR0_R12_R0  0x7c0c00ce      /* lvx   %v0,%r12,%r0   */
 234 #define MTLR_R0         0x7c0803a6      /* mtlr  %r0            */
 235 #define BLR             0x4e800020      /* blr                  */
 236
 237 /* Since .opd is an array of descriptors and each entry will end up
 238    with identical R_PPC64_RELATIVE relocs, there is really no need to
 239    propagate .opd relocs;  The dynamic linker should be taught to
 240    relocate .opd without reloc entries.  */
 241 #ifndef NO_OPD_RELOCS
 242 #define NO_OPD_RELOCS 0
 243 #endif
 244
 245 #ifndef ARRAY_SIZE
 246 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
 247 #endif
 248
 249 static inline int
 250 abiversion (bfd *abfd)
 251 {
 252   return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
 253 }
 254
 255 static inline void
 256 set_abiversion (bfd *abfd, int ver)
 257 {
 258   elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
 259   elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
 260 }
 261 \f
 262 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
 263
 264 /* Relocation HOWTO's.  */
 265 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
 266
 267 static reloc_howto_type ppc64_elf_howto_raw[] = {
 268   /* This reloc does nothing.  */
 269   HOWTO (R_PPC64_NONE,          /* type */
 270          0,                     /* rightshift */
 271          3,                     /* size (0 = byte, 1 = short, 2 = long) */
 272          0,                     /* bitsize */
 273          FALSE,                 /* pc_relative */
 274          0,                     /* bitpos */
 275          complain_overflow_dont, /* complain_on_overflow */
 276          bfd_elf_generic_reloc, /* special_function */
 277          "R_PPC64_NONE",        /* name */
 278          FALSE,                 /* partial_inplace */
 279          0,                     /* src_mask */
 280          0,                     /* dst_mask */
 281          FALSE),                /* pcrel_offset */
 282
 283   /* A standard 32 bit relocation.  */
 284   HOWTO (R_PPC64_ADDR32,        /* type */
 285          0,                     /* rightshift */
 286          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 287          32,                    /* bitsize */
 288          FALSE,                 /* pc_relative */
 289          0,                     /* bitpos */
 290          complain_overflow_bitfield, /* complain_on_overflow */
 291          bfd_elf_generic_reloc, /* special_function */
 292          "R_PPC64_ADDR32",      /* name */
 293          FALSE,                 /* partial_inplace */
 294          0,                     /* src_mask */
 295          0xffffffff,            /* dst_mask */
 296          FALSE),                /* pcrel_offset */
 297
 298   /* An absolute 26 bit branch; the lower two bits must be zero.
 299      FIXME: we don't check that, we just clear them.  */
 300   HOWTO (R_PPC64_ADDR24,        /* type */
 301          0,                     /* rightshift */
 302          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 303          26,                    /* bitsize */
 304          FALSE,                 /* pc_relative */
 305          0,                     /* bitpos */
 306          complain_overflow_bitfield, /* complain_on_overflow */
 307          bfd_elf_generic_reloc, /* special_function */
 308          "R_PPC64_ADDR24",      /* name */
 309          FALSE,                 /* partial_inplace */
 310          0,                     /* src_mask */
 311          0x03fffffc,            /* dst_mask */
 312          FALSE),                /* pcrel_offset */
 313
 314   /* A standard 16 bit relocation.  */
 315   HOWTO (R_PPC64_ADDR16,        /* type */
 316          0,                     /* rightshift */
 317          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 318          16,                    /* bitsize */
 319          FALSE,                 /* pc_relative */
 320          0,                     /* bitpos */
 321          complain_overflow_bitfield, /* complain_on_overflow */
 322          bfd_elf_generic_reloc, /* special_function */
 323          "R_PPC64_ADDR16",      /* name */
 324          FALSE,                 /* partial_inplace */
 325          0,                     /* src_mask */
 326          0xffff,                /* dst_mask */
 327          FALSE),                /* pcrel_offset */
 328
 329   /* A 16 bit relocation without overflow.  */
 330   HOWTO (R_PPC64_ADDR16_LO,     /* type */
 331          0,                     /* rightshift */
 332          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 333          16,                    /* bitsize */
 334          FALSE,                 /* pc_relative */
 335          0,                     /* bitpos */
 336          complain_overflow_dont,/* complain_on_overflow */
 337          bfd_elf_generic_reloc, /* special_function */
 338          "R_PPC64_ADDR16_LO",   /* name */
 339          FALSE,                 /* partial_inplace */
 340          0,                     /* src_mask */
 341          0xffff,                /* dst_mask */
 342          FALSE),                /* pcrel_offset */
 343
 344   /* Bits 16-31 of an address.  */
 345   HOWTO (R_PPC64_ADDR16_HI,     /* type */
 346          16,                    /* rightshift */
 347          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 348          16,                    /* bitsize */
 349          FALSE,                 /* pc_relative */
 350          0,                     /* bitpos */
 351          complain_overflow_signed, /* complain_on_overflow */
 352          bfd_elf_generic_reloc, /* special_function */
 353          "R_PPC64_ADDR16_HI",   /* name */
 354          FALSE,                 /* partial_inplace */
 355          0,                     /* src_mask */
 356          0xffff,                /* dst_mask */
 357          FALSE),                /* pcrel_offset */
 358
 359   /* Bits 16-31 of an address, plus 1 if the contents of the low 16
 360      bits, treated as a signed number, is negative.  */
 361   HOWTO (R_PPC64_ADDR16_HA,     /* type */
 362          16,                    /* rightshift */
 363          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 364          16,                    /* bitsize */
 365          FALSE,                 /* pc_relative */
 366          0,                     /* bitpos */
 367          complain_overflow_signed, /* complain_on_overflow */
 368          ppc64_elf_ha_reloc,    /* special_function */
 369          "R_PPC64_ADDR16_HA",   /* name */
 370          FALSE,                 /* partial_inplace */
 371          0,                     /* src_mask */
 372          0xffff,                /* dst_mask */
 373          FALSE),                /* pcrel_offset */
 374
 375   /* An absolute 16 bit branch; the lower two bits must be zero.
 376      FIXME: we don't check that, we just clear them.  */
 377   HOWTO (R_PPC64_ADDR14,        /* type */
 378          0,                     /* rightshift */
 379          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 380          16,                    /* bitsize */
 381          FALSE,                 /* pc_relative */
 382          0,                     /* bitpos */
 383          complain_overflow_signed, /* complain_on_overflow */
 384          ppc64_elf_branch_reloc, /* special_function */
 385          "R_PPC64_ADDR14",      /* name */
 386          FALSE,                 /* partial_inplace */
 387          0,                     /* src_mask */
 388          0x0000fffc,            /* dst_mask */
 389          FALSE),                /* pcrel_offset */
 390
 391   /* An absolute 16 bit branch, for which bit 10 should be set to
 392      indicate that the branch is expected to be taken.  The lower two
 393      bits must be zero.  */
 394   HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
 395          0,                     /* rightshift */
 396          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 397          16,                    /* bitsize */
 398          FALSE,                 /* pc_relative */
 399          0,                     /* bitpos */
 400          complain_overflow_signed, /* complain_on_overflow */
 401          ppc64_elf_brtaken_reloc, /* special_function */
 402          "R_PPC64_ADDR14_BRTAKEN",/* name */
 403          FALSE,                 /* partial_inplace */
 404          0,                     /* src_mask */
 405          0x0000fffc,            /* dst_mask */
 406          FALSE),                /* pcrel_offset */
 407
 408   /* An absolute 16 bit branch, for which bit 10 should be set to
 409      indicate that the branch is not expected to be taken.  The lower
 410      two bits must be zero.  */
 411   HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
 412          0,                     /* rightshift */
 413          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 414          16,                    /* bitsize */
 415          FALSE,                 /* pc_relative */
 416          0,                     /* bitpos */
 417          complain_overflow_signed, /* complain_on_overflow */
 418          ppc64_elf_brtaken_reloc, /* special_function */
 419          "R_PPC64_ADDR14_BRNTAKEN",/* name */
 420          FALSE,                 /* partial_inplace */
 421          0,                     /* src_mask */
 422          0x0000fffc,            /* dst_mask */
 423          FALSE),                /* pcrel_offset */
 424
 425   /* A relative 26 bit branch; the lower two bits must be zero.  */
 426   HOWTO (R_PPC64_REL24,         /* type */
 427          0,                     /* rightshift */
 428          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 429          26,                    /* bitsize */
 430          TRUE,                  /* pc_relative */
 431          0,                     /* bitpos */
 432          complain_overflow_signed, /* complain_on_overflow */
 433          ppc64_elf_branch_reloc, /* special_function */
 434          "R_PPC64_REL24",       /* name */
 435          FALSE,                 /* partial_inplace */
 436          0,                     /* src_mask */
 437          0x03fffffc,            /* dst_mask */
 438          TRUE),                 /* pcrel_offset */
 439
 440   /* A relative 16 bit branch; the lower two bits must be zero.  */
 441   HOWTO (R_PPC64_REL14,         /* type */
 442          0,                     /* rightshift */
 443          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 444          16,                    /* bitsize */
 445          TRUE,                  /* pc_relative */
 446          0,                     /* bitpos */
 447          complain_overflow_signed, /* complain_on_overflow */
 448          ppc64_elf_branch_reloc, /* special_function */
 449          "R_PPC64_REL14",       /* name */
 450          FALSE,                 /* partial_inplace */
 451          0,                     /* src_mask */
 452          0x0000fffc,            /* dst_mask */
 453          TRUE),                 /* pcrel_offset */
 454
 455   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 456      the branch is expected to be taken.  The lower two bits must be
 457      zero.  */
 458   HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
 459          0,                     /* rightshift */
 460          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 461          16,                    /* bitsize */
 462          TRUE,                  /* pc_relative */
 463          0,                     /* bitpos */
 464          complain_overflow_signed, /* complain_on_overflow */
 465          ppc64_elf_brtaken_reloc, /* special_function */
 466          "R_PPC64_REL14_BRTAKEN", /* name */
 467          FALSE,                 /* partial_inplace */
 468          0,                     /* src_mask */
 469          0x0000fffc,            /* dst_mask */
 470          TRUE),                 /* pcrel_offset */
 471
 472   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 473      the branch is not expected to be taken.  The lower two bits must
 474      be zero.  */
 475   HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
 476          0,                     /* rightshift */
 477          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 478          16,                    /* bitsize */
 479          TRUE,                  /* pc_relative */
 480          0,                     /* bitpos */
 481          complain_overflow_signed, /* complain_on_overflow */
 482          ppc64_elf_brtaken_reloc, /* special_function */
 483          "R_PPC64_REL14_BRNTAKEN",/* name */
 484          FALSE,                 /* partial_inplace */
 485          0,                     /* src_mask */
 486          0x0000fffc,            /* dst_mask */
 487          TRUE),                 /* pcrel_offset */
 488
 489   /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
 490      symbol.  */
 491   HOWTO (R_PPC64_GOT16,         /* type */
 492          0,                     /* rightshift */
 493          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 494          16,                    /* bitsize */
 495          FALSE,                 /* pc_relative */
 496          0,                     /* bitpos */
 497          complain_overflow_signed, /* complain_on_overflow */
 498          ppc64_elf_unhandled_reloc, /* special_function */
 499          "R_PPC64_GOT16",       /* name */
 500          FALSE,                 /* partial_inplace */
 501          0,                     /* src_mask */
 502          0xffff,                /* dst_mask */
 503          FALSE),                /* pcrel_offset */
 504
 505   /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
 506      the symbol.  */
 507   HOWTO (R_PPC64_GOT16_LO,      /* type */
 508          0,                     /* rightshift */
 509          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 510          16,                    /* bitsize */
 511          FALSE,                 /* pc_relative */
 512          0,                     /* bitpos */
 513          complain_overflow_dont, /* complain_on_overflow */
 514          ppc64_elf_unhandled_reloc, /* special_function */
 515          "R_PPC64_GOT16_LO",    /* name */
 516          FALSE,                 /* partial_inplace */
 517          0,                     /* src_mask */
 518          0xffff,                /* dst_mask */
 519          FALSE),                /* pcrel_offset */
 520
 521   /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
 522      the symbol.  */
 523   HOWTO (R_PPC64_GOT16_HI,      /* type */
 524          16,                    /* rightshift */
 525          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 526          16,                    /* bitsize */
 527          FALSE,                 /* pc_relative */
 528          0,                     /* bitpos */
 529          complain_overflow_signed,/* complain_on_overflow */
 530          ppc64_elf_unhandled_reloc, /* special_function */
 531          "R_PPC64_GOT16_HI",    /* name */
 532          FALSE,                 /* partial_inplace */
 533          0,                     /* src_mask */
 534          0xffff,                /* dst_mask */
 535          FALSE),                /* pcrel_offset */
 536
 537   /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
 538      the symbol.  */
 539   HOWTO (R_PPC64_GOT16_HA,      /* type */
 540          16,                    /* rightshift */
 541          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 542          16,                    /* bitsize */
 543          FALSE,                 /* pc_relative */
 544          0,                     /* bitpos */
 545          complain_overflow_signed,/* complain_on_overflow */
 546          ppc64_elf_unhandled_reloc, /* special_function */
 547          "R_PPC64_GOT16_HA",    /* name */
 548          FALSE,                 /* partial_inplace */
 549          0,                     /* src_mask */
 550          0xffff,                /* dst_mask */
 551          FALSE),                /* pcrel_offset */
 552
 553   /* This is used only by the dynamic linker.  The symbol should exist
 554      both in the object being run and in some shared library.  The
 555      dynamic linker copies the data addressed by the symbol from the
 556      shared library into the object, because the object being
 557      run has to have the data at some particular address.  */
 558   HOWTO (R_PPC64_COPY,          /* type */
 559          0,                     /* rightshift */
 560          0,                     /* this one is variable size */
 561          0,                     /* bitsize */
 562          FALSE,                 /* pc_relative */
 563          0,                     /* bitpos */
 564          complain_overflow_dont, /* complain_on_overflow */
 565          ppc64_elf_unhandled_reloc, /* special_function */
 566          "R_PPC64_COPY",        /* name */
 567          FALSE,                 /* partial_inplace */
 568          0,                     /* src_mask */
 569          0,                     /* dst_mask */
 570          FALSE),                /* pcrel_offset */
 571
 572   /* Like R_PPC64_ADDR64, but used when setting global offset table
 573      entries.  */
 574   HOWTO (R_PPC64_GLOB_DAT,      /* type */
 575          0,                     /* rightshift */
 576          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 577          64,                    /* bitsize */
 578          FALSE,                 /* pc_relative */
 579          0,                     /* bitpos */
 580          complain_overflow_dont, /* complain_on_overflow */
 581          ppc64_elf_unhandled_reloc,  /* special_function */
 582          "R_PPC64_GLOB_DAT",    /* name */
 583          FALSE,                 /* partial_inplace */
 584          0,                     /* src_mask */
 585          ONES (64),             /* dst_mask */
 586          FALSE),                /* pcrel_offset */
 587
 588   /* Created by the link editor.  Marks a procedure linkage table
 589      entry for a symbol.  */
 590   HOWTO (R_PPC64_JMP_SLOT,      /* type */
 591          0,                     /* rightshift */
 592          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 593          0,                     /* bitsize */
 594          FALSE,                 /* pc_relative */
 595          0,                     /* bitpos */
 596          complain_overflow_dont, /* complain_on_overflow */
 597          ppc64_elf_unhandled_reloc, /* special_function */
 598          "R_PPC64_JMP_SLOT",    /* name */
 599          FALSE,                 /* partial_inplace */
 600          0,                     /* src_mask */
 601          0,                     /* dst_mask */
 602          FALSE),                /* pcrel_offset */
 603
 604   /* Used only by the dynamic linker.  When the object is run, this
 605      doubleword64 is set to the load address of the object, plus the
 606      addend.  */
 607   HOWTO (R_PPC64_RELATIVE,      /* type */
 608          0,                     /* rightshift */
 609          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 610          64,                    /* bitsize */
 611          FALSE,                 /* pc_relative */
 612          0,                     /* bitpos */
 613          complain_overflow_dont, /* complain_on_overflow */
 614          bfd_elf_generic_reloc, /* special_function */
 615          "R_PPC64_RELATIVE",    /* name */
 616          FALSE,                 /* partial_inplace */
 617          0,                     /* src_mask */
 618          ONES (64),             /* dst_mask */
 619          FALSE),                /* pcrel_offset */
 620
 621   /* Like R_PPC64_ADDR32, but may be unaligned.  */
 622   HOWTO (R_PPC64_UADDR32,       /* type */
 623          0,                     /* rightshift */
 624          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 625          32,                    /* bitsize */
 626          FALSE,                 /* pc_relative */
 627          0,                     /* bitpos */
 628          complain_overflow_bitfield, /* complain_on_overflow */
 629          bfd_elf_generic_reloc, /* special_function */
 630          "R_PPC64_UADDR32",     /* name */
 631          FALSE,                 /* partial_inplace */
 632          0,                     /* src_mask */
 633          0xffffffff,            /* dst_mask */
 634          FALSE),                /* pcrel_offset */
 635
 636   /* Like R_PPC64_ADDR16, but may be unaligned.  */
 637   HOWTO (R_PPC64_UADDR16,       /* type */
 638          0,                     /* rightshift */
 639          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 640          16,                    /* bitsize */
 641          FALSE,                 /* pc_relative */
 642          0,                     /* bitpos */
 643          complain_overflow_bitfield, /* complain_on_overflow */
 644          bfd_elf_generic_reloc, /* special_function */
 645          "R_PPC64_UADDR16",     /* name */
 646          FALSE,                 /* partial_inplace */
 647          0,                     /* src_mask */
 648          0xffff,                /* dst_mask */
 649          FALSE),                /* pcrel_offset */
 650
 651   /* 32-bit PC relative.  */
 652   HOWTO (R_PPC64_REL32,         /* type */
 653          0,                     /* rightshift */
 654          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 655          32,                    /* bitsize */
 656          TRUE,                  /* pc_relative */
 657          0,                     /* bitpos */
 658          complain_overflow_signed, /* complain_on_overflow */
 659          bfd_elf_generic_reloc, /* special_function */
 660          "R_PPC64_REL32",       /* name */
 661          FALSE,                 /* partial_inplace */
 662          0,                     /* src_mask */
 663          0xffffffff,            /* dst_mask */
 664          TRUE),                 /* pcrel_offset */
 665
 666   /* 32-bit relocation to the symbol's procedure linkage table.  */
 667   HOWTO (R_PPC64_PLT32,         /* type */
 668          0,                     /* rightshift */
 669          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 670          32,                    /* bitsize */
 671          FALSE,                 /* pc_relative */
 672          0,                     /* bitpos */
 673          complain_overflow_bitfield, /* complain_on_overflow */
 674          ppc64_elf_unhandled_reloc, /* special_function */
 675          "R_PPC64_PLT32",       /* name */
 676          FALSE,                 /* partial_inplace */
 677          0,                     /* src_mask */
 678          0xffffffff,            /* dst_mask */
 679          FALSE),                /* pcrel_offset */
 680
 681   /* 32-bit PC relative relocation to the symbol's procedure linkage table.
 682      FIXME: R_PPC64_PLTREL32 not supported.  */
 683   HOWTO (R_PPC64_PLTREL32,      /* type */
 684          0,                     /* rightshift */
 685          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 686          32,                    /* bitsize */
 687          TRUE,                  /* pc_relative */
 688          0,                     /* bitpos */
 689          complain_overflow_signed, /* complain_on_overflow */
 690          bfd_elf_generic_reloc, /* special_function */
 691          "R_PPC64_PLTREL32",    /* name */
 692          FALSE,                 /* partial_inplace */
 693          0,                     /* src_mask */
 694          0xffffffff,            /* dst_mask */
 695          TRUE),                 /* pcrel_offset */
 696
 697   /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
 698      the symbol.  */
 699   HOWTO (R_PPC64_PLT16_LO,      /* type */
 700          0,                     /* rightshift */
 701          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 702          16,                    /* bitsize */
 703          FALSE,                 /* pc_relative */
 704          0,                     /* bitpos */
 705          complain_overflow_dont, /* complain_on_overflow */
 706          ppc64_elf_unhandled_reloc, /* special_function */
 707          "R_PPC64_PLT16_LO",    /* name */
 708          FALSE,                 /* partial_inplace */
 709          0,                     /* src_mask */
 710          0xffff,                /* dst_mask */
 711          FALSE),                /* pcrel_offset */
 712
 713   /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
 714      the symbol.  */
 715   HOWTO (R_PPC64_PLT16_HI,      /* type */
 716          16,                    /* rightshift */
 717          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 718          16,                    /* bitsize */
 719          FALSE,                 /* pc_relative */
 720          0,                     /* bitpos */
 721          complain_overflow_signed, /* complain_on_overflow */
 722          ppc64_elf_unhandled_reloc, /* special_function */
 723          "R_PPC64_PLT16_HI",    /* name */
 724          FALSE,                 /* partial_inplace */
 725          0,                     /* src_mask */
 726          0xffff,                /* dst_mask */
 727          FALSE),                /* pcrel_offset */
 728
 729   /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
 730      the symbol.  */
 731   HOWTO (R_PPC64_PLT16_HA,      /* type */
 732          16,                    /* rightshift */
 733          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 734          16,                    /* bitsize */
 735          FALSE,                 /* pc_relative */
 736          0,                     /* bitpos */
 737          complain_overflow_signed, /* complain_on_overflow */
 738          ppc64_elf_unhandled_reloc, /* special_function */
 739          "R_PPC64_PLT16_HA",    /* name */
 740          FALSE,                 /* partial_inplace */
 741          0,                     /* src_mask */
 742          0xffff,                /* dst_mask */
 743          FALSE),                /* pcrel_offset */
 744
 745   /* 16-bit section relative relocation.  */
 746   HOWTO (R_PPC64_SECTOFF,       /* type */
 747          0,                     /* rightshift */
 748          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 749          16,                    /* bitsize */
 750          FALSE,                 /* pc_relative */
 751          0,                     /* bitpos */
 752          complain_overflow_signed, /* complain_on_overflow */
 753          ppc64_elf_sectoff_reloc, /* special_function */
 754          "R_PPC64_SECTOFF",     /* name */
 755          FALSE,                 /* partial_inplace */
 756          0,                     /* src_mask */
 757          0xffff,                /* dst_mask */
 758          FALSE),                /* pcrel_offset */
 759
 760   /* Like R_PPC64_SECTOFF, but no overflow warning.  */
 761   HOWTO (R_PPC64_SECTOFF_LO,    /* type */
 762          0,                     /* rightshift */
 763          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 764          16,                    /* bitsize */
 765          FALSE,                 /* pc_relative */
 766          0,                     /* bitpos */
 767          complain_overflow_dont, /* complain_on_overflow */
 768          ppc64_elf_sectoff_reloc, /* special_function */
 769          "R_PPC64_SECTOFF_LO",  /* name */
 770          FALSE,                 /* partial_inplace */
 771          0,                     /* src_mask */
 772          0xffff,                /* dst_mask */
 773          FALSE),                /* pcrel_offset */
 774
 775   /* 16-bit upper half section relative relocation.  */
 776   HOWTO (R_PPC64_SECTOFF_HI,    /* type */
 777          16,                    /* rightshift */
 778          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 779          16,                    /* bitsize */
 780          FALSE,                 /* pc_relative */
 781          0,                     /* bitpos */
 782          complain_overflow_signed, /* complain_on_overflow */
 783          ppc64_elf_sectoff_reloc, /* special_function */
 784          "R_PPC64_SECTOFF_HI",  /* name */
 785          FALSE,                 /* partial_inplace */
 786          0,                     /* src_mask */
 787          0xffff,                /* dst_mask */
 788          FALSE),                /* pcrel_offset */
 789
 790   /* 16-bit upper half adjusted section relative relocation.  */
 791   HOWTO (R_PPC64_SECTOFF_HA,    /* type */
 792          16,                    /* rightshift */
 793          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 794          16,                    /* bitsize */
 795          FALSE,                 /* pc_relative */
 796          0,                     /* bitpos */
 797          complain_overflow_signed, /* complain_on_overflow */
 798          ppc64_elf_sectoff_ha_reloc, /* special_function */
 799          "R_PPC64_SECTOFF_HA",  /* name */
 800          FALSE,                 /* partial_inplace */
 801          0,                     /* src_mask */
 802          0xffff,                /* dst_mask */
 803          FALSE),                /* pcrel_offset */
 804
 805   /* Like R_PPC64_REL24 without touching the two least significant bits.  */
 806   HOWTO (R_PPC64_REL30,         /* type */
 807          2,                     /* rightshift */
 808          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 809          30,                    /* bitsize */
 810          TRUE,                  /* pc_relative */
 811          0,                     /* bitpos */
 812          complain_overflow_dont, /* complain_on_overflow */
 813          bfd_elf_generic_reloc, /* special_function */
 814          "R_PPC64_REL30",       /* name */
 815          FALSE,                 /* partial_inplace */
 816          0,                     /* src_mask */
 817          0xfffffffc,            /* dst_mask */
 818          TRUE),                 /* pcrel_offset */
 819
 820   /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI.  */
 821
 822   /* A standard 64-bit relocation.  */
 823   HOWTO (R_PPC64_ADDR64,        /* type */
 824          0,                     /* rightshift */
 825          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 826          64,                    /* bitsize */
 827          FALSE,                 /* pc_relative */
 828          0,                     /* bitpos */
 829          complain_overflow_dont, /* complain_on_overflow */
 830          bfd_elf_generic_reloc, /* special_function */
 831          "R_PPC64_ADDR64",      /* name */
 832          FALSE,                 /* partial_inplace */
 833          0,                     /* src_mask */
 834          ONES (64),             /* dst_mask */
 835          FALSE),                /* pcrel_offset */
 836
 837   /* The bits 32-47 of an address.  */
 838   HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
 839          32,                    /* rightshift */
 840          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 841          16,                    /* bitsize */
 842          FALSE,                 /* pc_relative */
 843          0,                     /* bitpos */
 844          complain_overflow_dont, /* complain_on_overflow */
 845          bfd_elf_generic_reloc, /* special_function */
 846          "R_PPC64_ADDR16_HIGHER", /* name */
 847          FALSE,                 /* partial_inplace */
 848          0,                     /* src_mask */
 849          0xffff,                /* dst_mask */
 850          FALSE),                /* pcrel_offset */
 851
 852   /* The bits 32-47 of an address, plus 1 if the contents of the low
 853      16 bits, treated as a signed number, is negative.  */
 854   HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
 855          32,                    /* rightshift */
 856          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 857          16,                    /* bitsize */
 858          FALSE,                 /* pc_relative */
 859          0,                     /* bitpos */
 860          complain_overflow_dont, /* complain_on_overflow */
 861          ppc64_elf_ha_reloc,    /* special_function */
 862          "R_PPC64_ADDR16_HIGHERA", /* name */
 863          FALSE,                 /* partial_inplace */
 864          0,                     /* src_mask */
 865          0xffff,                /* dst_mask */
 866          FALSE),                /* pcrel_offset */
 867
 868   /* The bits 48-63 of an address.  */
 869   HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
 870          48,                    /* rightshift */
 871          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 872          16,                    /* bitsize */
 873          FALSE,                 /* pc_relative */
 874          0,                     /* bitpos */
 875          complain_overflow_dont, /* complain_on_overflow */
 876          bfd_elf_generic_reloc, /* special_function */
 877          "R_PPC64_ADDR16_HIGHEST", /* name */
 878          FALSE,                 /* partial_inplace */
 879          0,                     /* src_mask */
 880          0xffff,                /* dst_mask */
 881          FALSE),                /* pcrel_offset */
 882
 883   /* The bits 48-63 of an address, plus 1 if the contents of the low
 884      16 bits, treated as a signed number, is negative.  */
 885   HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
 886          48,                    /* rightshift */
 887          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 888          16,                    /* bitsize */
 889          FALSE,                 /* pc_relative */
 890          0,                     /* bitpos */
 891          complain_overflow_dont, /* complain_on_overflow */
 892          ppc64_elf_ha_reloc,    /* special_function */
 893          "R_PPC64_ADDR16_HIGHESTA", /* name */
 894          FALSE,                 /* partial_inplace */
 895          0,                     /* src_mask */
 896          0xffff,                /* dst_mask */
 897          FALSE),                /* pcrel_offset */
 898
 899   /* Like ADDR64, but may be unaligned.  */
 900   HOWTO (R_PPC64_UADDR64,       /* type */
 901          0,                     /* rightshift */
 902          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 903          64,                    /* bitsize */
 904          FALSE,                 /* pc_relative */
 905          0,                     /* bitpos */
 906          complain_overflow_dont, /* complain_on_overflow */
 907          bfd_elf_generic_reloc, /* special_function */
 908          "R_PPC64_UADDR64",     /* name */
 909          FALSE,                 /* partial_inplace */
 910          0,                     /* src_mask */
 911          ONES (64),             /* dst_mask */
 912          FALSE),                /* pcrel_offset */
 913
 914   /* 64-bit relative relocation.  */
 915   HOWTO (R_PPC64_REL64,         /* type */
 916          0,                     /* rightshift */
 917          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 918          64,                    /* bitsize */
 919          TRUE,                  /* pc_relative */
 920          0,                     /* bitpos */
 921          complain_overflow_dont, /* complain_on_overflow */
 922          bfd_elf_generic_reloc, /* special_function */
 923          "R_PPC64_REL64",       /* name */
 924          FALSE,                 /* partial_inplace */
 925          0,                     /* src_mask */
 926          ONES (64),             /* dst_mask */
 927          TRUE),                 /* pcrel_offset */
 928
 929   /* 64-bit relocation to the symbol's procedure linkage table.  */
 930   HOWTO (R_PPC64_PLT64,         /* type */
 931          0,                     /* rightshift */
 932          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 933          64,                    /* bitsize */
 934          FALSE,                 /* pc_relative */
 935          0,                     /* bitpos */
 936          complain_overflow_dont, /* complain_on_overflow */
 937          ppc64_elf_unhandled_reloc, /* special_function */
 938          "R_PPC64_PLT64",       /* name */
 939          FALSE,                 /* partial_inplace */
 940          0,                     /* src_mask */
 941          ONES (64),             /* dst_mask */
 942          FALSE),                /* pcrel_offset */
 943
 944   /* 64-bit PC relative relocation to the symbol's procedure linkage
 945      table.  */
 946   /* FIXME: R_PPC64_PLTREL64 not supported.  */
 947   HOWTO (R_PPC64_PLTREL64,      /* type */
 948          0,                     /* rightshift */
 949          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 950          64,                    /* bitsize */
 951          TRUE,                  /* pc_relative */
 952          0,                     /* bitpos */
 953          complain_overflow_dont, /* complain_on_overflow */
 954          ppc64_elf_unhandled_reloc, /* special_function */
 955          "R_PPC64_PLTREL64",    /* name */
 956          FALSE,                 /* partial_inplace */
 957          0,                     /* src_mask */
 958          ONES (64),             /* dst_mask */
 959          TRUE),                 /* pcrel_offset */
 960
 961   /* 16 bit TOC-relative relocation.  */
 962
 963   /* R_PPC64_TOC16        47       half16*      S + A - .TOC.  */
 964   HOWTO (R_PPC64_TOC16,         /* type */
 965          0,                     /* rightshift */
 966          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 967          16,                    /* bitsize */
 968          FALSE,                 /* pc_relative */
 969          0,                     /* bitpos */
 970          complain_overflow_signed, /* complain_on_overflow */
 971          ppc64_elf_toc_reloc,   /* special_function */
 972          "R_PPC64_TOC16",       /* name */
 973          FALSE,                 /* partial_inplace */
 974          0,                     /* src_mask */
 975          0xffff,                /* dst_mask */
 976          FALSE),                /* pcrel_offset */
 977
 978   /* 16 bit TOC-relative relocation without overflow.  */
 979
 980   /* R_PPC64_TOC16_LO     48       half16        #lo (S + A - .TOC.)  */
 981   HOWTO (R_PPC64_TOC16_LO,      /* type */
 982          0,                     /* rightshift */
 983          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 984          16,                    /* bitsize */
 985          FALSE,                 /* pc_relative */
 986          0,                     /* bitpos */
 987          complain_overflow_dont, /* complain_on_overflow */
 988          ppc64_elf_toc_reloc,   /* special_function */
 989          "R_PPC64_TOC16_LO",    /* name */
 990          FALSE,                 /* partial_inplace */
 991          0,                     /* src_mask */
 992          0xffff,                /* dst_mask */
 993          FALSE),                /* pcrel_offset */
 994
 995   /* 16 bit TOC-relative relocation, high 16 bits.  */
 996
 997   /* R_PPC64_TOC16_HI     49       half16        #hi (S + A - .TOC.)  */
 998   HOWTO (R_PPC64_TOC16_HI,      /* type */
 999          16,                    /* rightshift */
1000          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1001          16,                    /* bitsize */
1002          FALSE,                 /* pc_relative */
1003          0,                     /* bitpos */
1004          complain_overflow_signed, /* complain_on_overflow */
1005          ppc64_elf_toc_reloc,   /* special_function */
1006          "R_PPC64_TOC16_HI",    /* name */
1007          FALSE,                 /* partial_inplace */
1008          0,                     /* src_mask */
1009          0xffff,                /* dst_mask */
1010          FALSE),                /* pcrel_offset */
1011
1012   /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
1013      contents of the low 16 bits, treated as a signed number, is
1014      negative.  */
1015
1016   /* R_PPC64_TOC16_HA     50       half16        #ha (S + A - .TOC.)  */
1017   HOWTO (R_PPC64_TOC16_HA,      /* type */
1018          16,                    /* rightshift */
1019          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1020          16,                    /* bitsize */
1021          FALSE,                 /* pc_relative */
1022          0,                     /* bitpos */
1023          complain_overflow_signed, /* complain_on_overflow */
1024          ppc64_elf_toc_ha_reloc, /* special_function */
1025          "R_PPC64_TOC16_HA",    /* name */
1026          FALSE,                 /* partial_inplace */
1027          0,                     /* src_mask */
1028          0xffff,                /* dst_mask */
1029          FALSE),                /* pcrel_offset */
1030
1031   /* 64-bit relocation; insert value of TOC base (.TOC.).  */
1032
1033   /* R_PPC64_TOC                  51       doubleword64  .TOC.  */
1034   HOWTO (R_PPC64_TOC,           /* type */
1035          0,                     /* rightshift */
1036          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1037          64,                    /* bitsize */
1038          FALSE,                 /* pc_relative */
1039          0,                     /* bitpos */
1040          complain_overflow_dont, /* complain_on_overflow */
1041          ppc64_elf_toc64_reloc, /* special_function */
1042          "R_PPC64_TOC",         /* name */
1043          FALSE,                 /* partial_inplace */
1044          0,                     /* src_mask */
1045          ONES (64),             /* dst_mask */
1046          FALSE),                /* pcrel_offset */
1047
1048   /* Like R_PPC64_GOT16, but also informs the link editor that the
1049      value to relocate may (!) refer to a PLT entry which the link
1050      editor (a) may replace with the symbol value.  If the link editor
1051      is unable to fully resolve the symbol, it may (b) create a PLT
1052      entry and store the address to the new PLT entry in the GOT.
1053      This permits lazy resolution of function symbols at run time.
1054      The link editor may also skip all of this and just (c) emit a
1055      R_PPC64_GLOB_DAT to tie the symbol to the GOT entry.  */
1056   /* FIXME: R_PPC64_PLTGOT16 not implemented.  */
1057     HOWTO (R_PPC64_PLTGOT16,    /* type */
1058          0,                     /* rightshift */
1059          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1060          16,                    /* bitsize */
1061          FALSE,                 /* pc_relative */
1062          0,                     /* bitpos */
1063          complain_overflow_signed, /* complain_on_overflow */
1064          ppc64_elf_unhandled_reloc, /* special_function */
1065          "R_PPC64_PLTGOT16",    /* name */
1066          FALSE,                 /* partial_inplace */
1067          0,                     /* src_mask */
1068          0xffff,                /* dst_mask */
1069          FALSE),                /* pcrel_offset */
1070
1071   /* Like R_PPC64_PLTGOT16, but without overflow.  */
1072   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1073   HOWTO (R_PPC64_PLTGOT16_LO,   /* type */
1074          0,                     /* rightshift */
1075          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1076          16,                    /* bitsize */
1077          FALSE,                 /* pc_relative */
1078          0,                     /* bitpos */
1079          complain_overflow_dont, /* complain_on_overflow */
1080          ppc64_elf_unhandled_reloc, /* special_function */
1081          "R_PPC64_PLTGOT16_LO", /* name */
1082          FALSE,                 /* partial_inplace */
1083          0,                     /* src_mask */
1084          0xffff,                /* dst_mask */
1085          FALSE),                /* pcrel_offset */
1086
1087   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address.  */
1088   /* FIXME: R_PPC64_PLTGOT16_HI not implemented.  */
1089   HOWTO (R_PPC64_PLTGOT16_HI,   /* type */
1090          16,                    /* rightshift */
1091          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1092          16,                    /* bitsize */
1093          FALSE,                 /* pc_relative */
1094          0,                     /* bitpos */
1095          complain_overflow_signed, /* complain_on_overflow */
1096          ppc64_elf_unhandled_reloc, /* special_function */
1097          "R_PPC64_PLTGOT16_HI", /* name */
1098          FALSE,                 /* partial_inplace */
1099          0,                     /* src_mask */
1100          0xffff,                /* dst_mask */
1101          FALSE),                /* pcrel_offset */
1102
1103   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1104      1 if the contents of the low 16 bits, treated as a signed number,
1105      is negative.  */
1106   /* FIXME: R_PPC64_PLTGOT16_HA not implemented.  */
1107   HOWTO (R_PPC64_PLTGOT16_HA,   /* type */
1108          16,                    /* rightshift */
1109          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1110          16,                    /* bitsize */
1111          FALSE,                 /* pc_relative */
1112          0,                     /* bitpos */
1113          complain_overflow_signed, /* complain_on_overflow */
1114          ppc64_elf_unhandled_reloc, /* special_function */
1115          "R_PPC64_PLTGOT16_HA", /* name */
1116          FALSE,                 /* partial_inplace */
1117          0,                     /* src_mask */
1118          0xffff,                /* dst_mask */
1119          FALSE),                /* pcrel_offset */
1120
1121   /* Like R_PPC64_ADDR16, but for instructions with a DS field.  */
1122   HOWTO (R_PPC64_ADDR16_DS,     /* type */
1123          0,                     /* rightshift */
1124          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1125          16,                    /* bitsize */
1126          FALSE,                 /* pc_relative */
1127          0,                     /* bitpos */
1128          complain_overflow_signed, /* complain_on_overflow */
1129          bfd_elf_generic_reloc, /* special_function */
1130          "R_PPC64_ADDR16_DS",   /* name */
1131          FALSE,                 /* partial_inplace */
1132          0,                     /* src_mask */
1133          0xfffc,                /* dst_mask */
1134          FALSE),                /* pcrel_offset */
1135
1136   /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field.  */
1137   HOWTO (R_PPC64_ADDR16_LO_DS,  /* type */
1138          0,                     /* rightshift */
1139          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1140          16,                    /* bitsize */
1141          FALSE,                 /* pc_relative */
1142          0,                     /* bitpos */
1143          complain_overflow_dont,/* complain_on_overflow */
1144          bfd_elf_generic_reloc, /* special_function */
1145          "R_PPC64_ADDR16_LO_DS",/* name */
1146          FALSE,                 /* partial_inplace */
1147          0,                     /* src_mask */
1148          0xfffc,                /* dst_mask */
1149          FALSE),                /* pcrel_offset */
1150
1151   /* Like R_PPC64_GOT16, but for instructions with a DS field.  */
1152   HOWTO (R_PPC64_GOT16_DS,      /* type */
1153          0,                     /* rightshift */
1154          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1155          16,                    /* bitsize */
1156          FALSE,                 /* pc_relative */
1157          0,                     /* bitpos */
1158          complain_overflow_signed, /* complain_on_overflow */
1159          ppc64_elf_unhandled_reloc, /* special_function */
1160          "R_PPC64_GOT16_DS",    /* name */
1161          FALSE,                 /* partial_inplace */
1162          0,                     /* src_mask */
1163          0xfffc,                /* dst_mask */
1164          FALSE),                /* pcrel_offset */
1165
1166   /* Like R_PPC64_GOT16_LO, but for instructions with a DS field.  */
1167   HOWTO (R_PPC64_GOT16_LO_DS,   /* type */
1168          0,                     /* rightshift */
1169          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1170          16,                    /* bitsize */
1171          FALSE,                 /* pc_relative */
1172          0,                     /* bitpos */
1173          complain_overflow_dont, /* complain_on_overflow */
1174          ppc64_elf_unhandled_reloc, /* special_function */
1175          "R_PPC64_GOT16_LO_DS", /* name */
1176          FALSE,                 /* partial_inplace */
1177          0,                     /* src_mask */
1178          0xfffc,                /* dst_mask */
1179          FALSE),                /* pcrel_offset */
1180
1181   /* Like R_PPC64_PLT16_LO, but for instructions with a DS field.  */
1182   HOWTO (R_PPC64_PLT16_LO_DS,   /* type */
1183          0,                     /* rightshift */
1184          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1185          16,                    /* bitsize */
1186          FALSE,                 /* pc_relative */
1187          0,                     /* bitpos */
1188          complain_overflow_dont, /* complain_on_overflow */
1189          ppc64_elf_unhandled_reloc, /* special_function */
1190          "R_PPC64_PLT16_LO_DS", /* name */
1191          FALSE,                 /* partial_inplace */
1192          0,                     /* src_mask */
1193          0xfffc,                /* dst_mask */
1194          FALSE),                /* pcrel_offset */
1195
1196   /* Like R_PPC64_SECTOFF, but for instructions with a DS field.  */
1197   HOWTO (R_PPC64_SECTOFF_DS,    /* type */
1198          0,                     /* rightshift */
1199          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1200          16,                    /* bitsize */
1201          FALSE,                 /* pc_relative */
1202          0,                     /* bitpos */
1203          complain_overflow_signed, /* complain_on_overflow */
1204          ppc64_elf_sectoff_reloc, /* special_function */
1205          "R_PPC64_SECTOFF_DS",  /* name */
1206          FALSE,                 /* partial_inplace */
1207          0,                     /* src_mask */
1208          0xfffc,                /* dst_mask */
1209          FALSE),                /* pcrel_offset */
1210
1211   /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field.  */
1212   HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1213          0,                     /* rightshift */
1214          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1215          16,                    /* bitsize */
1216          FALSE,                 /* pc_relative */
1217          0,                     /* bitpos */
1218          complain_overflow_dont, /* complain_on_overflow */
1219          ppc64_elf_sectoff_reloc, /* special_function */
1220          "R_PPC64_SECTOFF_LO_DS",/* name */
1221          FALSE,                 /* partial_inplace */
1222          0,                     /* src_mask */
1223          0xfffc,                /* dst_mask */
1224          FALSE),                /* pcrel_offset */
1225
1226   /* Like R_PPC64_TOC16, but for instructions with a DS field.  */
1227   HOWTO (R_PPC64_TOC16_DS,      /* type */
1228          0,                     /* rightshift */
1229          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1230          16,                    /* bitsize */
1231          FALSE,                 /* pc_relative */
1232          0,                     /* bitpos */
1233          complain_overflow_signed, /* complain_on_overflow */
1234          ppc64_elf_toc_reloc,   /* special_function */
1235          "R_PPC64_TOC16_DS",    /* name */
1236          FALSE,                 /* partial_inplace */
1237          0,                     /* src_mask */
1238          0xfffc,                /* dst_mask */
1239          FALSE),                /* pcrel_offset */
1240
1241   /* Like R_PPC64_TOC16_LO, but for instructions with a DS field.  */
1242   HOWTO (R_PPC64_TOC16_LO_DS,   /* type */
1243          0,                     /* rightshift */
1244          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1245          16,                    /* bitsize */
1246          FALSE,                 /* pc_relative */
1247          0,                     /* bitpos */
1248          complain_overflow_dont, /* complain_on_overflow */
1249          ppc64_elf_toc_reloc,   /* special_function */
1250          "R_PPC64_TOC16_LO_DS", /* name */
1251          FALSE,                 /* partial_inplace */
1252          0,                     /* src_mask */
1253          0xfffc,                /* dst_mask */
1254          FALSE),                /* pcrel_offset */
1255
1256   /* Like R_PPC64_PLTGOT16, but for instructions with a DS field.  */
1257   /* FIXME: R_PPC64_PLTGOT16_DS not implemented.  */
1258   HOWTO (R_PPC64_PLTGOT16_DS,   /* type */
1259          0,                     /* rightshift */
1260          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1261          16,                    /* bitsize */
1262          FALSE,                 /* pc_relative */
1263          0,                     /* bitpos */
1264          complain_overflow_signed, /* complain_on_overflow */
1265          ppc64_elf_unhandled_reloc, /* special_function */
1266          "R_PPC64_PLTGOT16_DS", /* name */
1267          FALSE,                 /* partial_inplace */
1268          0,                     /* src_mask */
1269          0xfffc,                /* dst_mask */
1270          FALSE),                /* pcrel_offset */
1271
1272   /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field.  */
1273   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1274   HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1275          0,                     /* rightshift */
1276          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1277          16,                    /* bitsize */
1278          FALSE,                 /* pc_relative */
1279          0,                     /* bitpos */
1280          complain_overflow_dont, /* complain_on_overflow */
1281          ppc64_elf_unhandled_reloc, /* special_function */
1282          "R_PPC64_PLTGOT16_LO_DS",/* name */
1283          FALSE,                 /* partial_inplace */
1284          0,                     /* src_mask */
1285          0xfffc,                /* dst_mask */
1286          FALSE),                /* pcrel_offset */
1287
1288   /* Marker relocs for TLS.  */
1289   HOWTO (R_PPC64_TLS,
1290          0,                     /* rightshift */
1291          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1292          32,                    /* bitsize */
1293          FALSE,                 /* pc_relative */
1294          0,                     /* bitpos */
1295          complain_overflow_dont, /* complain_on_overflow */
1296          bfd_elf_generic_reloc, /* special_function */
1297          "R_PPC64_TLS",         /* name */
1298          FALSE,                 /* partial_inplace */
1299          0,                     /* src_mask */
1300          0,                     /* dst_mask */
1301          FALSE),                /* pcrel_offset */
1302
1303   HOWTO (R_PPC64_TLSGD,
1304          0,                     /* rightshift */
1305          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1306          32,                    /* bitsize */
1307          FALSE,                 /* pc_relative */
1308          0,                     /* bitpos */
1309          complain_overflow_dont, /* complain_on_overflow */
1310          bfd_elf_generic_reloc, /* special_function */
1311          "R_PPC64_TLSGD",       /* name */
1312          FALSE,                 /* partial_inplace */
1313          0,                     /* src_mask */
1314          0,                     /* dst_mask */
1315          FALSE),                /* pcrel_offset */
1316
1317   HOWTO (R_PPC64_TLSLD,
1318          0,                     /* rightshift */
1319          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1320          32,                    /* bitsize */
1321          FALSE,                 /* pc_relative */
1322          0,                     /* bitpos */
1323          complain_overflow_dont, /* complain_on_overflow */
1324          bfd_elf_generic_reloc, /* special_function */
1325          "R_PPC64_TLSLD",       /* name */
1326          FALSE,                 /* partial_inplace */
1327          0,                     /* src_mask */
1328          0,                     /* dst_mask */
1329          FALSE),                /* pcrel_offset */
1330
1331   HOWTO (R_PPC64_TOCSAVE,
1332          0,                     /* rightshift */
1333          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1334          32,                    /* bitsize */
1335          FALSE,                 /* pc_relative */
1336          0,                     /* bitpos */
1337          complain_overflow_dont, /* complain_on_overflow */
1338          bfd_elf_generic_reloc, /* special_function */
1339          "R_PPC64_TOCSAVE",     /* name */
1340          FALSE,                 /* partial_inplace */
1341          0,                     /* src_mask */
1342          0,                     /* dst_mask */
1343          FALSE),                /* pcrel_offset */
1344
1345   /* Computes the load module index of the load module that contains the
1346      definition of its TLS sym.  */
1347   HOWTO (R_PPC64_DTPMOD64,
1348          0,                     /* rightshift */
1349          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1350          64,                    /* bitsize */
1351          FALSE,                 /* pc_relative */
1352          0,                     /* bitpos */
1353          complain_overflow_dont, /* complain_on_overflow */
1354          ppc64_elf_unhandled_reloc, /* special_function */
1355          "R_PPC64_DTPMOD64",    /* name */
1356          FALSE,                 /* partial_inplace */
1357          0,                     /* src_mask */
1358          ONES (64),             /* dst_mask */
1359          FALSE),                /* pcrel_offset */
1360
1361   /* Computes a dtv-relative displacement, the difference between the value
1362      of sym+add and the base address of the thread-local storage block that
1363      contains the definition of sym, minus 0x8000.  */
1364   HOWTO (R_PPC64_DTPREL64,
1365          0,                     /* rightshift */
1366          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1367          64,                    /* bitsize */
1368          FALSE,                 /* pc_relative */
1369          0,                     /* bitpos */
1370          complain_overflow_dont, /* complain_on_overflow */
1371          ppc64_elf_unhandled_reloc, /* special_function */
1372          "R_PPC64_DTPREL64",    /* name */
1373          FALSE,                 /* partial_inplace */
1374          0,                     /* src_mask */
1375          ONES (64),             /* dst_mask */
1376          FALSE),                /* pcrel_offset */
1377
1378   /* A 16 bit dtprel reloc.  */
1379   HOWTO (R_PPC64_DTPREL16,
1380          0,                     /* rightshift */
1381          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1382          16,                    /* bitsize */
1383          FALSE,                 /* pc_relative */
1384          0,                     /* bitpos */
1385          complain_overflow_signed, /* complain_on_overflow */
1386          ppc64_elf_unhandled_reloc, /* special_function */
1387          "R_PPC64_DTPREL16",    /* name */
1388          FALSE,                 /* partial_inplace */
1389          0,                     /* src_mask */
1390          0xffff,                /* dst_mask */
1391          FALSE),                /* pcrel_offset */
1392
1393   /* Like DTPREL16, but no overflow.  */
1394   HOWTO (R_PPC64_DTPREL16_LO,
1395          0,                     /* rightshift */
1396          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1397          16,                    /* bitsize */
1398          FALSE,                 /* pc_relative */
1399          0,                     /* bitpos */
1400          complain_overflow_dont, /* complain_on_overflow */
1401          ppc64_elf_unhandled_reloc, /* special_function */
1402          "R_PPC64_DTPREL16_LO", /* name */
1403          FALSE,                 /* partial_inplace */
1404          0,                     /* src_mask */
1405          0xffff,                /* dst_mask */
1406          FALSE),                /* pcrel_offset */
1407
1408   /* Like DTPREL16_LO, but next higher group of 16 bits.  */
1409   HOWTO (R_PPC64_DTPREL16_HI,
1410          16,                    /* rightshift */
1411          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1412          16,                    /* bitsize */
1413          FALSE,                 /* pc_relative */
1414          0,                     /* bitpos */
1415          complain_overflow_signed, /* complain_on_overflow */
1416          ppc64_elf_unhandled_reloc, /* special_function */
1417          "R_PPC64_DTPREL16_HI", /* name */
1418          FALSE,                 /* partial_inplace */
1419          0,                     /* src_mask */
1420          0xffff,                /* dst_mask */
1421          FALSE),                /* pcrel_offset */
1422
1423   /* Like DTPREL16_HI, but adjust for low 16 bits.  */
1424   HOWTO (R_PPC64_DTPREL16_HA,
1425          16,                    /* rightshift */
1426          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1427          16,                    /* bitsize */
1428          FALSE,                 /* pc_relative */
1429          0,                     /* bitpos */
1430          complain_overflow_signed, /* complain_on_overflow */
1431          ppc64_elf_unhandled_reloc, /* special_function */
1432          "R_PPC64_DTPREL16_HA", /* name */
1433          FALSE,                 /* partial_inplace */
1434          0,                     /* src_mask */
1435          0xffff,                /* dst_mask */
1436          FALSE),                /* pcrel_offset */
1437
1438   /* Like DTPREL16_HI, but next higher group of 16 bits.  */
1439   HOWTO (R_PPC64_DTPREL16_HIGHER,
1440          32,                    /* rightshift */
1441          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1442          16,                    /* bitsize */
1443          FALSE,                 /* pc_relative */
1444          0,                     /* bitpos */
1445          complain_overflow_dont, /* complain_on_overflow */
1446          ppc64_elf_unhandled_reloc, /* special_function */
1447          "R_PPC64_DTPREL16_HIGHER", /* name */
1448          FALSE,                 /* partial_inplace */
1449          0,                     /* src_mask */
1450          0xffff,                /* dst_mask */
1451          FALSE),                /* pcrel_offset */
1452
1453   /* Like DTPREL16_HIGHER, but adjust for low 16 bits.  */
1454   HOWTO (R_PPC64_DTPREL16_HIGHERA,
1455          32,                    /* rightshift */
1456          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1457          16,                    /* bitsize */
1458          FALSE,                 /* pc_relative */
1459          0,                     /* bitpos */
1460          complain_overflow_dont, /* complain_on_overflow */
1461          ppc64_elf_unhandled_reloc, /* special_function */
1462          "R_PPC64_DTPREL16_HIGHERA", /* name */
1463          FALSE,                 /* partial_inplace */
1464          0,                     /* src_mask */
1465          0xffff,                /* dst_mask */
1466          FALSE),                /* pcrel_offset */
1467
1468   /* Like DTPREL16_HIGHER, but next higher group of 16 bits.  */
1469   HOWTO (R_PPC64_DTPREL16_HIGHEST,
1470          48,                    /* rightshift */
1471          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1472          16,                    /* bitsize */
1473          FALSE,                 /* pc_relative */
1474          0,                     /* bitpos */
1475          complain_overflow_dont, /* complain_on_overflow */
1476          ppc64_elf_unhandled_reloc, /* special_function */
1477          "R_PPC64_DTPREL16_HIGHEST", /* name */
1478          FALSE,                 /* partial_inplace */
1479          0,                     /* src_mask */
1480          0xffff,                /* dst_mask */
1481          FALSE),                /* pcrel_offset */
1482
1483   /* Like DTPREL16_HIGHEST, but adjust for low 16 bits.  */
1484   HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1485          48,                    /* rightshift */
1486          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1487          16,                    /* bitsize */
1488          FALSE,                 /* pc_relative */
1489          0,                     /* bitpos */
1490          complain_overflow_dont, /* complain_on_overflow */
1491          ppc64_elf_unhandled_reloc, /* special_function */
1492          "R_PPC64_DTPREL16_HIGHESTA", /* name */
1493          FALSE,                 /* partial_inplace */
1494          0,                     /* src_mask */
1495          0xffff,                /* dst_mask */
1496          FALSE),                /* pcrel_offset */
1497
1498   /* Like DTPREL16, but for insns with a DS field.  */
1499   HOWTO (R_PPC64_DTPREL16_DS,
1500          0,                     /* rightshift */
1501          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1502          16,                    /* bitsize */
1503          FALSE,                 /* pc_relative */
1504          0,                     /* bitpos */
1505          complain_overflow_signed, /* complain_on_overflow */
1506          ppc64_elf_unhandled_reloc, /* special_function */
1507          "R_PPC64_DTPREL16_DS", /* name */
1508          FALSE,                 /* partial_inplace */
1509          0,                     /* src_mask */
1510          0xfffc,                /* dst_mask */
1511          FALSE),                /* pcrel_offset */
1512
1513   /* Like DTPREL16_DS, but no overflow.  */
1514   HOWTO (R_PPC64_DTPREL16_LO_DS,
1515          0,                     /* rightshift */
1516          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1517          16,                    /* bitsize */
1518          FALSE,                 /* pc_relative */
1519          0,                     /* bitpos */
1520          complain_overflow_dont, /* complain_on_overflow */
1521          ppc64_elf_unhandled_reloc, /* special_function */
1522          "R_PPC64_DTPREL16_LO_DS", /* name */
1523          FALSE,                 /* partial_inplace */
1524          0,                     /* src_mask */
1525          0xfffc,                /* dst_mask */
1526          FALSE),                /* pcrel_offset */
1527
1528   /* Computes a tp-relative displacement, the difference between the value of
1529      sym+add and the value of the thread pointer (r13).  */
1530   HOWTO (R_PPC64_TPREL64,
1531          0,                     /* rightshift */
1532          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1533          64,                    /* bitsize */
1534          FALSE,                 /* pc_relative */
1535          0,                     /* bitpos */
1536          complain_overflow_dont, /* complain_on_overflow */
1537          ppc64_elf_unhandled_reloc, /* special_function */
1538          "R_PPC64_TPREL64",     /* name */
1539          FALSE,                 /* partial_inplace */
1540          0,                     /* src_mask */
1541          ONES (64),             /* dst_mask */
1542          FALSE),                /* pcrel_offset */
1543
1544   /* A 16 bit tprel reloc.  */
1545   HOWTO (R_PPC64_TPREL16,
1546          0,                     /* rightshift */
1547          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1548          16,                    /* bitsize */
1549          FALSE,                 /* pc_relative */
1550          0,                     /* bitpos */
1551          complain_overflow_signed, /* complain_on_overflow */
1552          ppc64_elf_unhandled_reloc, /* special_function */
1553          "R_PPC64_TPREL16",     /* name */
1554          FALSE,                 /* partial_inplace */
1555          0,                     /* src_mask */
1556          0xffff,                /* dst_mask */
1557          FALSE),                /* pcrel_offset */
1558
1559   /* Like TPREL16, but no overflow.  */
1560   HOWTO (R_PPC64_TPREL16_LO,
1561          0,                     /* rightshift */
1562          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1563          16,                    /* bitsize */
1564          FALSE,                 /* pc_relative */
1565          0,                     /* bitpos */
1566          complain_overflow_dont, /* complain_on_overflow */
1567          ppc64_elf_unhandled_reloc, /* special_function */
1568          "R_PPC64_TPREL16_LO",  /* name */
1569          FALSE,                 /* partial_inplace */
1570          0,                     /* src_mask */
1571          0xffff,                /* dst_mask */
1572          FALSE),                /* pcrel_offset */
1573
1574   /* Like TPREL16_LO, but next higher group of 16 bits.  */
1575   HOWTO (R_PPC64_TPREL16_HI,
1576          16,                    /* rightshift */
1577          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1578          16,                    /* bitsize */
1579          FALSE,                 /* pc_relative */
1580          0,                     /* bitpos */
1581          complain_overflow_signed, /* complain_on_overflow */
1582          ppc64_elf_unhandled_reloc, /* special_function */
1583          "R_PPC64_TPREL16_HI",  /* name */
1584          FALSE,                 /* partial_inplace */
1585          0,                     /* src_mask */
1586          0xffff,                /* dst_mask */
1587          FALSE),                /* pcrel_offset */
1588
1589   /* Like TPREL16_HI, but adjust for low 16 bits.  */
1590   HOWTO (R_PPC64_TPREL16_HA,
1591          16,                    /* rightshift */
1592          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1593          16,                    /* bitsize */
1594          FALSE,                 /* pc_relative */
1595          0,                     /* bitpos */
1596          complain_overflow_signed, /* complain_on_overflow */
1597          ppc64_elf_unhandled_reloc, /* special_function */
1598          "R_PPC64_TPREL16_HA",  /* name */
1599          FALSE,                 /* partial_inplace */
1600          0,                     /* src_mask */
1601          0xffff,                /* dst_mask */
1602          FALSE),                /* pcrel_offset */
1603
1604   /* Like TPREL16_HI, but next higher group of 16 bits.  */
1605   HOWTO (R_PPC64_TPREL16_HIGHER,
1606          32,                    /* rightshift */
1607          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1608          16,                    /* bitsize */
1609          FALSE,                 /* pc_relative */
1610          0,                     /* bitpos */
1611          complain_overflow_dont, /* complain_on_overflow */
1612          ppc64_elf_unhandled_reloc, /* special_function */
1613          "R_PPC64_TPREL16_HIGHER",      /* name */
1614          FALSE,                 /* partial_inplace */
1615          0,                     /* src_mask */
1616          0xffff,                /* dst_mask */
1617          FALSE),                /* pcrel_offset */
1618
1619   /* Like TPREL16_HIGHER, but adjust for low 16 bits.  */
1620   HOWTO (R_PPC64_TPREL16_HIGHERA,
1621          32,                    /* rightshift */
1622          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1623          16,                    /* bitsize */
1624          FALSE,                 /* pc_relative */
1625          0,                     /* bitpos */
1626          complain_overflow_dont, /* complain_on_overflow */
1627          ppc64_elf_unhandled_reloc, /* special_function */
1628          "R_PPC64_TPREL16_HIGHERA", /* name */
1629          FALSE,                 /* partial_inplace */
1630          0,                     /* src_mask */
1631          0xffff,                /* dst_mask */
1632          FALSE),                /* pcrel_offset */
1633
1634   /* Like TPREL16_HIGHER, but next higher group of 16 bits.  */
1635   HOWTO (R_PPC64_TPREL16_HIGHEST,
1636          48,                    /* rightshift */
1637          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1638          16,                    /* bitsize */
1639          FALSE,                 /* pc_relative */
1640          0,                     /* bitpos */
1641          complain_overflow_dont, /* complain_on_overflow */
1642          ppc64_elf_unhandled_reloc, /* special_function */
1643          "R_PPC64_TPREL16_HIGHEST", /* name */
1644          FALSE,                 /* partial_inplace */
1645          0,                     /* src_mask */
1646          0xffff,                /* dst_mask */
1647          FALSE),                /* pcrel_offset */
1648
1649   /* Like TPREL16_HIGHEST, but adjust for low 16 bits.  */
1650   HOWTO (R_PPC64_TPREL16_HIGHESTA,
1651          48,                    /* rightshift */
1652          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1653          16,                    /* bitsize */
1654          FALSE,                 /* pc_relative */
1655          0,                     /* bitpos */
1656          complain_overflow_dont, /* complain_on_overflow */
1657          ppc64_elf_unhandled_reloc, /* special_function */
1658          "R_PPC64_TPREL16_HIGHESTA", /* name */
1659          FALSE,                 /* partial_inplace */
1660          0,                     /* src_mask */
1661          0xffff,                /* dst_mask */
1662          FALSE),                /* pcrel_offset */
1663
1664   /* Like TPREL16, but for insns with a DS field.  */
1665   HOWTO (R_PPC64_TPREL16_DS,
1666          0,                     /* rightshift */
1667          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1668          16,                    /* bitsize */
1669          FALSE,                 /* pc_relative */
1670          0,                     /* bitpos */
1671          complain_overflow_signed, /* complain_on_overflow */
1672          ppc64_elf_unhandled_reloc, /* special_function */
1673          "R_PPC64_TPREL16_DS",  /* name */
1674          FALSE,                 /* partial_inplace */
1675          0,                     /* src_mask */
1676          0xfffc,                /* dst_mask */
1677          FALSE),                /* pcrel_offset */
1678
1679   /* Like TPREL16_DS, but no overflow.  */
1680   HOWTO (R_PPC64_TPREL16_LO_DS,
1681          0,                     /* rightshift */
1682          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1683          16,                    /* bitsize */
1684          FALSE,                 /* pc_relative */
1685          0,                     /* bitpos */
1686          complain_overflow_dont, /* complain_on_overflow */
1687          ppc64_elf_unhandled_reloc, /* special_function */
1688          "R_PPC64_TPREL16_LO_DS", /* name */
1689          FALSE,                 /* partial_inplace */
1690          0,                     /* src_mask */
1691          0xfffc,                /* dst_mask */
1692          FALSE),                /* pcrel_offset */
1693
1694   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1695      with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1696      to the first entry relative to the TOC base (r2).  */
1697   HOWTO (R_PPC64_GOT_TLSGD16,
1698          0,                     /* rightshift */
1699          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1700          16,                    /* bitsize */
1701          FALSE,                 /* pc_relative */
1702          0,                     /* bitpos */
1703          complain_overflow_signed, /* complain_on_overflow */
1704          ppc64_elf_unhandled_reloc, /* special_function */
1705          "R_PPC64_GOT_TLSGD16", /* name */
1706          FALSE,                 /* partial_inplace */
1707          0,                     /* src_mask */
1708          0xffff,                /* dst_mask */
1709          FALSE),                /* pcrel_offset */
1710
1711   /* Like GOT_TLSGD16, but no overflow.  */
1712   HOWTO (R_PPC64_GOT_TLSGD16_LO,
1713          0,                     /* rightshift */
1714          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1715          16,                    /* bitsize */
1716          FALSE,                 /* pc_relative */
1717          0,                     /* bitpos */
1718          complain_overflow_dont, /* complain_on_overflow */
1719          ppc64_elf_unhandled_reloc, /* special_function */
1720          "R_PPC64_GOT_TLSGD16_LO", /* name */
1721          FALSE,                 /* partial_inplace */
1722          0,                     /* src_mask */
1723          0xffff,                /* dst_mask */
1724          FALSE),                /* pcrel_offset */
1725
1726   /* Like GOT_TLSGD16_LO, but next higher group of 16 bits.  */
1727   HOWTO (R_PPC64_GOT_TLSGD16_HI,
1728          16,                    /* rightshift */
1729          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1730          16,                    /* bitsize */
1731          FALSE,                 /* pc_relative */
1732          0,                     /* bitpos */
1733          complain_overflow_signed, /* complain_on_overflow */
1734          ppc64_elf_unhandled_reloc, /* special_function */
1735          "R_PPC64_GOT_TLSGD16_HI", /* name */
1736          FALSE,                 /* partial_inplace */
1737          0,                     /* src_mask */
1738          0xffff,                /* dst_mask */
1739          FALSE),                /* pcrel_offset */
1740
1741   /* Like GOT_TLSGD16_HI, but adjust for low 16 bits.  */
1742   HOWTO (R_PPC64_GOT_TLSGD16_HA,
1743          16,                    /* rightshift */
1744          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1745          16,                    /* bitsize */
1746          FALSE,                 /* pc_relative */
1747          0,                     /* bitpos */
1748          complain_overflow_signed, /* complain_on_overflow */
1749          ppc64_elf_unhandled_reloc, /* special_function */
1750          "R_PPC64_GOT_TLSGD16_HA", /* name */
1751          FALSE,                 /* partial_inplace */
1752          0,                     /* src_mask */
1753          0xffff,                /* dst_mask */
1754          FALSE),                /* pcrel_offset */
1755
1756   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1757      with values (sym+add)@dtpmod and zero, and computes the offset to the
1758      first entry relative to the TOC base (r2).  */
1759   HOWTO (R_PPC64_GOT_TLSLD16,
1760          0,                     /* rightshift */
1761          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1762          16,                    /* bitsize */
1763          FALSE,                 /* pc_relative */
1764          0,                     /* bitpos */
1765          complain_overflow_signed, /* complain_on_overflow */
1766          ppc64_elf_unhandled_reloc, /* special_function */
1767          "R_PPC64_GOT_TLSLD16", /* name */
1768          FALSE,                 /* partial_inplace */
1769          0,                     /* src_mask */
1770          0xffff,                /* dst_mask */
1771          FALSE),                /* pcrel_offset */
1772
1773   /* Like GOT_TLSLD16, but no overflow.  */
1774   HOWTO (R_PPC64_GOT_TLSLD16_LO,
1775          0,                     /* rightshift */
1776          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1777          16,                    /* bitsize */
1778          FALSE,                 /* pc_relative */
1779          0,                     /* bitpos */
1780          complain_overflow_dont, /* complain_on_overflow */
1781          ppc64_elf_unhandled_reloc, /* special_function */
1782          "R_PPC64_GOT_TLSLD16_LO", /* name */
1783          FALSE,                 /* partial_inplace */
1784          0,                     /* src_mask */
1785          0xffff,                /* dst_mask */
1786          FALSE),                /* pcrel_offset */
1787
1788   /* Like GOT_TLSLD16_LO, but next higher group of 16 bits.  */
1789   HOWTO (R_PPC64_GOT_TLSLD16_HI,
1790          16,                    /* rightshift */
1791          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1792          16,                    /* bitsize */
1793          FALSE,                 /* pc_relative */
1794          0,                     /* bitpos */
1795          complain_overflow_signed, /* complain_on_overflow */
1796          ppc64_elf_unhandled_reloc, /* special_function */
1797          "R_PPC64_GOT_TLSLD16_HI", /* name */
1798          FALSE,                 /* partial_inplace */
1799          0,                     /* src_mask */
1800          0xffff,                /* dst_mask */
1801          FALSE),                /* pcrel_offset */
1802
1803   /* Like GOT_TLSLD16_HI, but adjust for low 16 bits.  */
1804   HOWTO (R_PPC64_GOT_TLSLD16_HA,
1805          16,                    /* rightshift */
1806          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1807          16,                    /* bitsize */
1808          FALSE,                 /* pc_relative */
1809          0,                     /* bitpos */
1810          complain_overflow_signed, /* complain_on_overflow */
1811          ppc64_elf_unhandled_reloc, /* special_function */
1812          "R_PPC64_GOT_TLSLD16_HA", /* name */
1813          FALSE,                 /* partial_inplace */
1814          0,                     /* src_mask */
1815          0xffff,                /* dst_mask */
1816          FALSE),                /* pcrel_offset */
1817
1818   /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1819      the offset to the entry relative to the TOC base (r2).  */
1820   HOWTO (R_PPC64_GOT_DTPREL16_DS,
1821          0,                     /* rightshift */
1822          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1823          16,                    /* bitsize */
1824          FALSE,                 /* pc_relative */
1825          0,                     /* bitpos */
1826          complain_overflow_signed, /* complain_on_overflow */
1827          ppc64_elf_unhandled_reloc, /* special_function */
1828          "R_PPC64_GOT_DTPREL16_DS", /* name */
1829          FALSE,                 /* partial_inplace */
1830          0,                     /* src_mask */
1831          0xfffc,                /* dst_mask */
1832          FALSE),                /* pcrel_offset */
1833
1834   /* Like GOT_DTPREL16_DS, but no overflow.  */
1835   HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1836          0,                     /* rightshift */
1837          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1838          16,                    /* bitsize */
1839          FALSE,                 /* pc_relative */
1840          0,                     /* bitpos */
1841          complain_overflow_dont, /* complain_on_overflow */
1842          ppc64_elf_unhandled_reloc, /* special_function */
1843          "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1844          FALSE,                 /* partial_inplace */
1845          0,                     /* src_mask */
1846          0xfffc,                /* dst_mask */
1847          FALSE),                /* pcrel_offset */
1848
1849   /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits.  */
1850   HOWTO (R_PPC64_GOT_DTPREL16_HI,
1851          16,                    /* rightshift */
1852          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1853          16,                    /* bitsize */
1854          FALSE,                 /* pc_relative */
1855          0,                     /* bitpos */
1856          complain_overflow_signed, /* complain_on_overflow */
1857          ppc64_elf_unhandled_reloc, /* special_function */
1858          "R_PPC64_GOT_DTPREL16_HI", /* name */
1859          FALSE,                 /* partial_inplace */
1860          0,                     /* src_mask */
1861          0xffff,                /* dst_mask */
1862          FALSE),                /* pcrel_offset */
1863
1864   /* Like GOT_DTPREL16_HI, but adjust for low 16 bits.  */
1865   HOWTO (R_PPC64_GOT_DTPREL16_HA,
1866          16,                    /* rightshift */
1867          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1868          16,                    /* bitsize */
1869          FALSE,                 /* pc_relative */
1870          0,                     /* bitpos */
1871          complain_overflow_signed, /* complain_on_overflow */
1872          ppc64_elf_unhandled_reloc, /* special_function */
1873          "R_PPC64_GOT_DTPREL16_HA", /* name */
1874          FALSE,                 /* partial_inplace */
1875          0,                     /* src_mask */
1876          0xffff,                /* dst_mask */
1877          FALSE),                /* pcrel_offset */
1878
1879   /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1880      offset to the entry relative to the TOC base (r2).  */
1881   HOWTO (R_PPC64_GOT_TPREL16_DS,
1882          0,                     /* rightshift */
1883          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1884          16,                    /* bitsize */
1885          FALSE,                 /* pc_relative */
1886          0,                     /* bitpos */
1887          complain_overflow_signed, /* complain_on_overflow */
1888          ppc64_elf_unhandled_reloc, /* special_function */
1889          "R_PPC64_GOT_TPREL16_DS", /* name */
1890          FALSE,                 /* partial_inplace */
1891          0,                     /* src_mask */
1892          0xfffc,                /* dst_mask */
1893          FALSE),                /* pcrel_offset */
1894
1895   /* Like GOT_TPREL16_DS, but no overflow.  */
1896   HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1897          0,                     /* rightshift */
1898          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1899          16,                    /* bitsize */
1900          FALSE,                 /* pc_relative */
1901          0,                     /* bitpos */
1902          complain_overflow_dont, /* complain_on_overflow */
1903          ppc64_elf_unhandled_reloc, /* special_function */
1904          "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1905          FALSE,                 /* partial_inplace */
1906          0,                     /* src_mask */
1907          0xfffc,                /* dst_mask */
1908          FALSE),                /* pcrel_offset */
1909
1910   /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits.  */
1911   HOWTO (R_PPC64_GOT_TPREL16_HI,
1912          16,                    /* rightshift */
1913          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1914          16,                    /* bitsize */
1915          FALSE,                 /* pc_relative */
1916          0,                     /* bitpos */
1917          complain_overflow_signed, /* complain_on_overflow */
1918          ppc64_elf_unhandled_reloc, /* special_function */
1919          "R_PPC64_GOT_TPREL16_HI", /* name */
1920          FALSE,                 /* partial_inplace */
1921          0,                     /* src_mask */
1922          0xffff,                /* dst_mask */
1923          FALSE),                /* pcrel_offset */
1924
1925   /* Like GOT_TPREL16_HI, but adjust for low 16 bits.  */
1926   HOWTO (R_PPC64_GOT_TPREL16_HA,
1927          16,                    /* rightshift */
1928          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1929          16,                    /* bitsize */
1930          FALSE,                 /* pc_relative */
1931          0,                     /* bitpos */
1932          complain_overflow_signed, /* complain_on_overflow */
1933          ppc64_elf_unhandled_reloc, /* special_function */
1934          "R_PPC64_GOT_TPREL16_HA", /* name */
1935          FALSE,                 /* partial_inplace */
1936          0,                     /* src_mask */
1937          0xffff,                /* dst_mask */
1938          FALSE),                /* pcrel_offset */
1939
1940   HOWTO (R_PPC64_JMP_IREL,      /* type */
1941          0,                     /* rightshift */
1942          0,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1943          0,                     /* bitsize */
1944          FALSE,                 /* pc_relative */
1945          0,                     /* bitpos */
1946          complain_overflow_dont, /* complain_on_overflow */
1947          ppc64_elf_unhandled_reloc, /* special_function */
1948          "R_PPC64_JMP_IREL",    /* name */
1949          FALSE,                 /* partial_inplace */
1950          0,                     /* src_mask */
1951          0,                     /* dst_mask */
1952          FALSE),                /* pcrel_offset */
1953
1954   HOWTO (R_PPC64_IRELATIVE,     /* type */
1955          0,                     /* rightshift */
1956          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1957          64,                    /* bitsize */
1958          FALSE,                 /* pc_relative */
1959          0,                     /* bitpos */
1960          complain_overflow_dont, /* complain_on_overflow */
1961          bfd_elf_generic_reloc, /* special_function */
1962          "R_PPC64_IRELATIVE",   /* name */
1963          FALSE,                 /* partial_inplace */
1964          0,                     /* src_mask */
1965          ONES (64),             /* dst_mask */
1966          FALSE),                /* pcrel_offset */
1967
1968   /* A 16 bit relative relocation.  */
1969   HOWTO (R_PPC64_REL16,         /* type */
1970          0,                     /* rightshift */
1971          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1972          16,                    /* bitsize */
1973          TRUE,                  /* pc_relative */
1974          0,                     /* bitpos */
1975          complain_overflow_signed, /* complain_on_overflow */
1976          bfd_elf_generic_reloc, /* special_function */
1977          "R_PPC64_REL16",       /* name */
1978          FALSE,                 /* partial_inplace */
1979          0,                     /* src_mask */
1980          0xffff,                /* dst_mask */
1981          TRUE),                 /* pcrel_offset */
1982
1983   /* A 16 bit relative relocation without overflow.  */
1984   HOWTO (R_PPC64_REL16_LO,      /* type */
1985          0,                     /* rightshift */
1986          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1987          16,                    /* bitsize */
1988          TRUE,                  /* pc_relative */
1989          0,                     /* bitpos */
1990          complain_overflow_dont,/* complain_on_overflow */
1991          bfd_elf_generic_reloc, /* special_function */
1992          "R_PPC64_REL16_LO",    /* name */
1993          FALSE,                 /* partial_inplace */
1994          0,                     /* src_mask */
1995          0xffff,                /* dst_mask */
1996          TRUE),                 /* pcrel_offset */
1997
1998   /* The high order 16 bits of a relative address.  */
1999   HOWTO (R_PPC64_REL16_HI,      /* type */
2000          16,                    /* rightshift */
2001          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2002          16,                    /* bitsize */
2003          TRUE,                  /* pc_relative */
2004          0,                     /* bitpos */
2005          complain_overflow_signed, /* complain_on_overflow */
2006          bfd_elf_generic_reloc, /* special_function */
2007          "R_PPC64_REL16_HI",    /* name */
2008          FALSE,                 /* partial_inplace */
2009          0,                     /* src_mask */
2010          0xffff,                /* dst_mask */
2011          TRUE),                 /* pcrel_offset */
2012
2013   /* The high order 16 bits of a relative address, plus 1 if the contents of
2014      the low 16 bits, treated as a signed number, is negative.  */
2015   HOWTO (R_PPC64_REL16_HA,      /* type */
2016          16,                    /* rightshift */
2017          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2018          16,                    /* bitsize */
2019          TRUE,                  /* pc_relative */
2020          0,                     /* bitpos */
2021          complain_overflow_signed, /* complain_on_overflow */
2022          ppc64_elf_ha_reloc,    /* special_function */
2023          "R_PPC64_REL16_HA",    /* name */
2024          FALSE,                 /* partial_inplace */
2025          0,                     /* src_mask */
2026          0xffff,                /* dst_mask */
2027          TRUE),                 /* pcrel_offset */
2028
2029   /* Like R_PPC64_REL16_HA but for split field in addpcis.  */
2030   HOWTO (R_PPC64_REL16DX_HA,    /* type */
2031          16,                    /* rightshift */
2032          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2033          16,                    /* bitsize */
2034          TRUE,                  /* pc_relative */
2035          0,                     /* bitpos */
2036          complain_overflow_signed, /* complain_on_overflow */
2037          ppc64_elf_ha_reloc,    /* special_function */
2038          "R_PPC64_REL16DX_HA",  /* name */
2039          FALSE,                 /* partial_inplace */
2040          0,                     /* src_mask */
2041          0x1fffc1,              /* dst_mask */
2042          TRUE),                 /* pcrel_offset */
2043
2044   /* Like R_PPC64_ADDR16_HI, but no overflow.  */
2045   HOWTO (R_PPC64_ADDR16_HIGH,   /* type */
2046          16,                    /* rightshift */
2047          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2048          16,                    /* bitsize */
2049          FALSE,                 /* pc_relative */
2050          0,                     /* bitpos */
2051          complain_overflow_dont, /* complain_on_overflow */
2052          bfd_elf_generic_reloc, /* special_function */
2053          "R_PPC64_ADDR16_HIGH", /* name */
2054          FALSE,                 /* partial_inplace */
2055          0,                     /* src_mask */
2056          0xffff,                /* dst_mask */
2057          FALSE),                /* pcrel_offset */
2058
2059   /* Like R_PPC64_ADDR16_HA, but no overflow.  */
2060   HOWTO (R_PPC64_ADDR16_HIGHA,  /* type */
2061          16,                    /* rightshift */
2062          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2063          16,                    /* bitsize */
2064          FALSE,                 /* pc_relative */
2065          0,                     /* bitpos */
2066          complain_overflow_dont, /* complain_on_overflow */
2067          ppc64_elf_ha_reloc,    /* special_function */
2068          "R_PPC64_ADDR16_HIGHA",        /* name */
2069          FALSE,                 /* partial_inplace */
2070          0,                     /* src_mask */
2071          0xffff,                /* dst_mask */
2072          FALSE),                /* pcrel_offset */
2073
2074   /* Like R_PPC64_DTPREL16_HI, but no overflow.  */
2075   HOWTO (R_PPC64_DTPREL16_HIGH,
2076          16,                    /* rightshift */
2077          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2078          16,                    /* bitsize */
2079          FALSE,                 /* pc_relative */
2080          0,                     /* bitpos */
2081          complain_overflow_dont, /* complain_on_overflow */
2082          ppc64_elf_unhandled_reloc, /* special_function */
2083          "R_PPC64_DTPREL16_HIGH", /* name */
2084          FALSE,                 /* partial_inplace */
2085          0,                     /* src_mask */
2086          0xffff,                /* dst_mask */
2087          FALSE),                /* pcrel_offset */
2088
2089   /* Like R_PPC64_DTPREL16_HA, but no overflow.  */
2090   HOWTO (R_PPC64_DTPREL16_HIGHA,
2091          16,                    /* rightshift */
2092          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2093          16,                    /* bitsize */
2094          FALSE,                 /* pc_relative */
2095          0,                     /* bitpos */
2096          complain_overflow_dont, /* complain_on_overflow */
2097          ppc64_elf_unhandled_reloc, /* special_function */
2098          "R_PPC64_DTPREL16_HIGHA", /* name */
2099          FALSE,                 /* partial_inplace */
2100          0,                     /* src_mask */
2101          0xffff,                /* dst_mask */
2102          FALSE),                /* pcrel_offset */
2103
2104   /* Like R_PPC64_TPREL16_HI, but no overflow.  */
2105   HOWTO (R_PPC64_TPREL16_HIGH,
2106          16,                    /* rightshift */
2107          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2108          16,                    /* bitsize */
2109          FALSE,                 /* pc_relative */
2110          0,                     /* bitpos */
2111          complain_overflow_dont, /* complain_on_overflow */
2112          ppc64_elf_unhandled_reloc, /* special_function */
2113          "R_PPC64_TPREL16_HIGH",        /* name */
2114          FALSE,                 /* partial_inplace */
2115          0,                     /* src_mask */
2116          0xffff,                /* dst_mask */
2117          FALSE),                /* pcrel_offset */
2118
2119   /* Like R_PPC64_TPREL16_HA, but no overflow.  */
2120   HOWTO (R_PPC64_TPREL16_HIGHA,
2121          16,                    /* rightshift */
2122          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2123          16,                    /* bitsize */
2124          FALSE,                 /* pc_relative */
2125          0,                     /* bitpos */
2126          complain_overflow_dont, /* complain_on_overflow */
2127          ppc64_elf_unhandled_reloc, /* special_function */
2128          "R_PPC64_TPREL16_HIGHA",       /* name */
2129          FALSE,                 /* partial_inplace */
2130          0,                     /* src_mask */
2131          0xffff,                /* dst_mask */
2132          FALSE),                /* pcrel_offset */
2133
2134   /* Marker reloc on ELFv2 large-model function entry.  */
2135   HOWTO (R_PPC64_ENTRY,
2136          0,                     /* rightshift */
2137          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2138          32,                    /* bitsize */
2139          FALSE,                 /* pc_relative */
2140          0,                     /* bitpos */
2141          complain_overflow_dont, /* complain_on_overflow */
2142          bfd_elf_generic_reloc, /* special_function */
2143          "R_PPC64_ENTRY",       /* name */
2144          FALSE,                 /* partial_inplace */
2145          0,                     /* src_mask */
2146          0,                     /* dst_mask */
2147          FALSE),                /* pcrel_offset */
2148
2149   /* Like ADDR64, but use local entry point of function.  */
2150   HOWTO (R_PPC64_ADDR64_LOCAL,  /* type */
2151          0,                     /* rightshift */
2152          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2153          64,                    /* bitsize */
2154          FALSE,                 /* pc_relative */
2155          0,                     /* bitpos */
2156          complain_overflow_dont, /* complain_on_overflow */
2157          bfd_elf_generic_reloc, /* special_function */
2158          "R_PPC64_ADDR64_LOCAL", /* name */
2159          FALSE,                 /* partial_inplace */
2160          0,                     /* src_mask */
2161          ONES (64),             /* dst_mask */
2162          FALSE),                /* pcrel_offset */
2163
2164   /* GNU extension to record C++ vtable hierarchy.  */
2165   HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2166          0,                     /* rightshift */
2167          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2168          0,                     /* bitsize */
2169          FALSE,                 /* pc_relative */
2170          0,                     /* bitpos */
2171          complain_overflow_dont, /* complain_on_overflow */
2172          NULL,                  /* special_function */
2173          "R_PPC64_GNU_VTINHERIT", /* name */
2174          FALSE,                 /* partial_inplace */
2175          0,                     /* src_mask */
2176          0,                     /* dst_mask */
2177          FALSE),                /* pcrel_offset */
2178
2179   /* GNU extension to record C++ vtable member usage.  */
2180   HOWTO (R_PPC64_GNU_VTENTRY,   /* type */
2181          0,                     /* rightshift */
2182          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2183          0,                     /* bitsize */
2184          FALSE,                 /* pc_relative */
2185          0,                     /* bitpos */
2186          complain_overflow_dont, /* complain_on_overflow */
2187          NULL,                  /* special_function */
2188          "R_PPC64_GNU_VTENTRY", /* name */
2189          FALSE,                 /* partial_inplace */
2190          0,                     /* src_mask */
2191          0,                     /* dst_mask */
2192          FALSE),                /* pcrel_offset */
2193 };
2194
2195 \f
2196 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2197    be done.  */
2198
2199 static void
2200 ppc_howto_init (void)
2201 {
2202   unsigned int i, type;
2203
2204   for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2205     {
2206       type = ppc64_elf_howto_raw[i].type;
2207       BFD_ASSERT (type < ARRAY_SIZE (ppc64_elf_howto_table));
2208       ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2209     }
2210 }
2211
2212 static reloc_howto_type *
2213 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2214                              bfd_reloc_code_real_type code)
2215 {
2216   enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2217
2218   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2219     /* Initialize howto table if needed.  */
2220     ppc_howto_init ();
2221
2222   switch (code)
2223     {
2224     default:
2225       return NULL;
2226
2227     case BFD_RELOC_NONE:                        r = R_PPC64_NONE;
2228       break;
2229     case BFD_RELOC_32:                          r = R_PPC64_ADDR32;
2230       break;
2231     case BFD_RELOC_PPC_BA26:                    r = R_PPC64_ADDR24;
2232       break;
2233     case BFD_RELOC_16:                          r = R_PPC64_ADDR16;
2234       break;
2235     case BFD_RELOC_LO16:                        r = R_PPC64_ADDR16_LO;
2236       break;
2237     case BFD_RELOC_HI16:                        r = R_PPC64_ADDR16_HI;
2238       break;
2239     case BFD_RELOC_PPC64_ADDR16_HIGH:           r = R_PPC64_ADDR16_HIGH;
2240       break;
2241     case BFD_RELOC_HI16_S:                      r = R_PPC64_ADDR16_HA;
2242       break;
2243     case BFD_RELOC_PPC64_ADDR16_HIGHA:          r = R_PPC64_ADDR16_HIGHA;
2244       break;
2245     case BFD_RELOC_PPC_BA16:                    r = R_PPC64_ADDR14;
2246       break;
2247     case BFD_RELOC_PPC_BA16_BRTAKEN:            r = R_PPC64_ADDR14_BRTAKEN;
2248       break;
2249     case BFD_RELOC_PPC_BA16_BRNTAKEN:           r = R_PPC64_ADDR14_BRNTAKEN;
2250       break;
2251     case BFD_RELOC_PPC_B26:                     r = R_PPC64_REL24;
2252       break;
2253     case BFD_RELOC_PPC_B16:                     r = R_PPC64_REL14;
2254       break;
2255     case BFD_RELOC_PPC_B16_BRTAKEN:             r = R_PPC64_REL14_BRTAKEN;
2256       break;
2257     case BFD_RELOC_PPC_B16_BRNTAKEN:            r = R_PPC64_REL14_BRNTAKEN;
2258       break;
2259     case BFD_RELOC_16_GOTOFF:                   r = R_PPC64_GOT16;
2260       break;
2261     case BFD_RELOC_LO16_GOTOFF:                 r = R_PPC64_GOT16_LO;
2262       break;
2263     case BFD_RELOC_HI16_GOTOFF:                 r = R_PPC64_GOT16_HI;
2264       break;
2265     case BFD_RELOC_HI16_S_GOTOFF:               r = R_PPC64_GOT16_HA;
2266       break;
2267     case BFD_RELOC_PPC_COPY:                    r = R_PPC64_COPY;
2268       break;
2269     case BFD_RELOC_PPC_GLOB_DAT:                r = R_PPC64_GLOB_DAT;
2270       break;
2271     case BFD_RELOC_32_PCREL:                    r = R_PPC64_REL32;
2272       break;
2273     case BFD_RELOC_32_PLTOFF:                   r = R_PPC64_PLT32;
2274       break;
2275     case BFD_RELOC_32_PLT_PCREL:                r = R_PPC64_PLTREL32;
2276       break;
2277     case BFD_RELOC_LO16_PLTOFF:                 r = R_PPC64_PLT16_LO;
2278       break;
2279     case BFD_RELOC_HI16_PLTOFF:                 r = R_PPC64_PLT16_HI;
2280       break;
2281     case BFD_RELOC_HI16_S_PLTOFF:               r = R_PPC64_PLT16_HA;
2282       break;
2283     case BFD_RELOC_16_BASEREL:                  r = R_PPC64_SECTOFF;
2284       break;
2285     case BFD_RELOC_LO16_BASEREL:                r = R_PPC64_SECTOFF_LO;
2286       break;
2287     case BFD_RELOC_HI16_BASEREL:                r = R_PPC64_SECTOFF_HI;
2288       break;
2289     case BFD_RELOC_HI16_S_BASEREL:              r = R_PPC64_SECTOFF_HA;
2290       break;
2291     case BFD_RELOC_CTOR:                        r = R_PPC64_ADDR64;
2292       break;
2293     case BFD_RELOC_64:                          r = R_PPC64_ADDR64;
2294       break;
2295     case BFD_RELOC_PPC64_HIGHER:                r = R_PPC64_ADDR16_HIGHER;
2296       break;
2297     case BFD_RELOC_PPC64_HIGHER_S:              r = R_PPC64_ADDR16_HIGHERA;
2298       break;
2299     case BFD_RELOC_PPC64_HIGHEST:               r = R_PPC64_ADDR16_HIGHEST;
2300       break;
2301     case BFD_RELOC_PPC64_HIGHEST_S:             r = R_PPC64_ADDR16_HIGHESTA;
2302       break;
2303     case BFD_RELOC_64_PCREL:                    r = R_PPC64_REL64;
2304       break;
2305     case BFD_RELOC_64_PLTOFF:                   r = R_PPC64_PLT64;
2306       break;
2307     case BFD_RELOC_64_PLT_PCREL:                r = R_PPC64_PLTREL64;
2308       break;
2309     case BFD_RELOC_PPC_TOC16:                   r = R_PPC64_TOC16;
2310       break;
2311     case BFD_RELOC_PPC64_TOC16_LO:              r = R_PPC64_TOC16_LO;
2312       break;
2313     case BFD_RELOC_PPC64_TOC16_HI:              r = R_PPC64_TOC16_HI;
2314       break;
2315     case BFD_RELOC_PPC64_TOC16_HA:              r = R_PPC64_TOC16_HA;
2316       break;
2317     case BFD_RELOC_PPC64_TOC:                   r = R_PPC64_TOC;
2318       break;
2319     case BFD_RELOC_PPC64_PLTGOT16:              r = R_PPC64_PLTGOT16;
2320       break;
2321     case BFD_RELOC_PPC64_PLTGOT16_LO:           r = R_PPC64_PLTGOT16_LO;
2322       break;
2323     case BFD_RELOC_PPC64_PLTGOT16_HI:           r = R_PPC64_PLTGOT16_HI;
2324       break;
2325     case BFD_RELOC_PPC64_PLTGOT16_HA:           r = R_PPC64_PLTGOT16_HA;
2326       break;
2327     case BFD_RELOC_PPC64_ADDR16_DS:             r = R_PPC64_ADDR16_DS;
2328       break;
2329     case BFD_RELOC_PPC64_ADDR16_LO_DS:          r = R_PPC64_ADDR16_LO_DS;
2330       break;
2331     case BFD_RELOC_PPC64_GOT16_DS:              r = R_PPC64_GOT16_DS;
2332       break;
2333     case BFD_RELOC_PPC64_GOT16_LO_DS:           r = R_PPC64_GOT16_LO_DS;
2334       break;
2335     case BFD_RELOC_PPC64_PLT16_LO_DS:           r = R_PPC64_PLT16_LO_DS;
2336       break;
2337     case BFD_RELOC_PPC64_SECTOFF_DS:            r = R_PPC64_SECTOFF_DS;
2338       break;
2339     case BFD_RELOC_PPC64_SECTOFF_LO_DS:         r = R_PPC64_SECTOFF_LO_DS;
2340       break;
2341     case BFD_RELOC_PPC64_TOC16_DS:              r = R_PPC64_TOC16_DS;
2342       break;
2343     case BFD_RELOC_PPC64_TOC16_LO_DS:           r = R_PPC64_TOC16_LO_DS;
2344       break;
2345     case BFD_RELOC_PPC64_PLTGOT16_DS:           r = R_PPC64_PLTGOT16_DS;
2346       break;
2347     case BFD_RELOC_PPC64_PLTGOT16_LO_DS:        r = R_PPC64_PLTGOT16_LO_DS;
2348       break;
2349     case BFD_RELOC_PPC_TLS:                     r = R_PPC64_TLS;
2350       break;
2351     case BFD_RELOC_PPC_TLSGD:                   r = R_PPC64_TLSGD;
2352       break;
2353     case BFD_RELOC_PPC_TLSLD:                   r = R_PPC64_TLSLD;
2354       break;
2355     case BFD_RELOC_PPC_DTPMOD:                  r = R_PPC64_DTPMOD64;
2356       break;
2357     case BFD_RELOC_PPC_TPREL16:                 r = R_PPC64_TPREL16;
2358       break;
2359     case BFD_RELOC_PPC_TPREL16_LO:              r = R_PPC64_TPREL16_LO;
2360       break;
2361     case BFD_RELOC_PPC_TPREL16_HI:              r = R_PPC64_TPREL16_HI;
2362       break;
2363     case BFD_RELOC_PPC64_TPREL16_HIGH:          r = R_PPC64_TPREL16_HIGH;
2364       break;
2365     case BFD_RELOC_PPC_TPREL16_HA:              r = R_PPC64_TPREL16_HA;
2366       break;
2367     case BFD_RELOC_PPC64_TPREL16_HIGHA:         r = R_PPC64_TPREL16_HIGHA;
2368       break;
2369     case BFD_RELOC_PPC_TPREL:                   r = R_PPC64_TPREL64;
2370       break;
2371     case BFD_RELOC_PPC_DTPREL16:                r = R_PPC64_DTPREL16;
2372       break;
2373     case BFD_RELOC_PPC_DTPREL16_LO:             r = R_PPC64_DTPREL16_LO;
2374       break;
2375     case BFD_RELOC_PPC_DTPREL16_HI:             r = R_PPC64_DTPREL16_HI;
2376       break;
2377     case BFD_RELOC_PPC64_DTPREL16_HIGH:         r = R_PPC64_DTPREL16_HIGH;
2378       break;
2379     case BFD_RELOC_PPC_DTPREL16_HA:             r = R_PPC64_DTPREL16_HA;
2380       break;
2381     case BFD_RELOC_PPC64_DTPREL16_HIGHA:        r = R_PPC64_DTPREL16_HIGHA;
2382       break;
2383     case BFD_RELOC_PPC_DTPREL:                  r = R_PPC64_DTPREL64;
2384       break;
2385     case BFD_RELOC_PPC_GOT_TLSGD16:             r = R_PPC64_GOT_TLSGD16;
2386       break;
2387     case BFD_RELOC_PPC_GOT_TLSGD16_LO:          r = R_PPC64_GOT_TLSGD16_LO;
2388       break;
2389     case BFD_RELOC_PPC_GOT_TLSGD16_HI:          r = R_PPC64_GOT_TLSGD16_HI;
2390       break;
2391     case BFD_RELOC_PPC_GOT_TLSGD16_HA:          r = R_PPC64_GOT_TLSGD16_HA;
2392       break;
2393     case BFD_RELOC_PPC_GOT_TLSLD16:             r = R_PPC64_GOT_TLSLD16;
2394       break;
2395     case BFD_RELOC_PPC_GOT_TLSLD16_LO:          r = R_PPC64_GOT_TLSLD16_LO;
2396       break;
2397     case BFD_RELOC_PPC_GOT_TLSLD16_HI:          r = R_PPC64_GOT_TLSLD16_HI;
2398       break;
2399     case BFD_RELOC_PPC_GOT_TLSLD16_HA:          r = R_PPC64_GOT_TLSLD16_HA;
2400       break;
2401     case BFD_RELOC_PPC_GOT_TPREL16:             r = R_PPC64_GOT_TPREL16_DS;
2402       break;
2403     case BFD_RELOC_PPC_GOT_TPREL16_LO:          r = R_PPC64_GOT_TPREL16_LO_DS;
2404       break;
2405     case BFD_RELOC_PPC_GOT_TPREL16_HI:          r = R_PPC64_GOT_TPREL16_HI;
2406       break;
2407     case BFD_RELOC_PPC_GOT_TPREL16_HA:          r = R_PPC64_GOT_TPREL16_HA;
2408       break;
2409     case BFD_RELOC_PPC_GOT_DTPREL16:            r = R_PPC64_GOT_DTPREL16_DS;
2410       break;
2411     case BFD_RELOC_PPC_GOT_DTPREL16_LO:         r = R_PPC64_GOT_DTPREL16_LO_DS;
2412       break;
2413     case BFD_RELOC_PPC_GOT_DTPREL16_HI:         r = R_PPC64_GOT_DTPREL16_HI;
2414       break;
2415     case BFD_RELOC_PPC_GOT_DTPREL16_HA:         r = R_PPC64_GOT_DTPREL16_HA;
2416       break;
2417     case BFD_RELOC_PPC64_TPREL16_DS:            r = R_PPC64_TPREL16_DS;
2418       break;
2419     case BFD_RELOC_PPC64_TPREL16_LO_DS:         r = R_PPC64_TPREL16_LO_DS;
2420       break;
2421     case BFD_RELOC_PPC64_TPREL16_HIGHER:        r = R_PPC64_TPREL16_HIGHER;
2422       break;
2423     case BFD_RELOC_PPC64_TPREL16_HIGHERA:       r = R_PPC64_TPREL16_HIGHERA;
2424       break;
2425     case BFD_RELOC_PPC64_TPREL16_HIGHEST:       r = R_PPC64_TPREL16_HIGHEST;
2426       break;
2427     case BFD_RELOC_PPC64_TPREL16_HIGHESTA:      r = R_PPC64_TPREL16_HIGHESTA;
2428       break;
2429     case BFD_RELOC_PPC64_DTPREL16_DS:           r = R_PPC64_DTPREL16_DS;
2430       break;
2431     case BFD_RELOC_PPC64_DTPREL16_LO_DS:        r = R_PPC64_DTPREL16_LO_DS;
2432       break;
2433     case BFD_RELOC_PPC64_DTPREL16_HIGHER:       r = R_PPC64_DTPREL16_HIGHER;
2434       break;
2435     case BFD_RELOC_PPC64_DTPREL16_HIGHERA:      r = R_PPC64_DTPREL16_HIGHERA;
2436       break;
2437     case BFD_RELOC_PPC64_DTPREL16_HIGHEST:      r = R_PPC64_DTPREL16_HIGHEST;
2438       break;
2439     case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:     r = R_PPC64_DTPREL16_HIGHESTA;
2440       break;
2441     case BFD_RELOC_16_PCREL:                    r = R_PPC64_REL16;
2442       break;
2443     case BFD_RELOC_LO16_PCREL:                  r = R_PPC64_REL16_LO;
2444       break;
2445     case BFD_RELOC_HI16_PCREL:                  r = R_PPC64_REL16_HI;
2446       break;
2447     case BFD_RELOC_HI16_S_PCREL:                r = R_PPC64_REL16_HA;
2448       break;
2449     case BFD_RELOC_PPC_REL16DX_HA:              r = R_PPC64_REL16DX_HA;
2450       break;
2451     case BFD_RELOC_PPC64_ENTRY:                 r = R_PPC64_ENTRY;
2452       break;
2453     case BFD_RELOC_PPC64_ADDR64_LOCAL:          r = R_PPC64_ADDR64_LOCAL;
2454       break;
2455     case BFD_RELOC_VTABLE_INHERIT:              r = R_PPC64_GNU_VTINHERIT;
2456       break;
2457     case BFD_RELOC_VTABLE_ENTRY:                r = R_PPC64_GNU_VTENTRY;
2458       break;
2459     }
2460
2461   return ppc64_elf_howto_table[r];
2462 };
2463
2464 static reloc_howto_type *
2465 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2466                              const char *r_name)
2467 {
2468   unsigned int i;
2469
2470   for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2471     if (ppc64_elf_howto_raw[i].name != NULL
2472         && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2473       return &ppc64_elf_howto_raw[i];
2474
2475   return NULL;
2476 }
2477
2478 /* Set the howto pointer for a PowerPC ELF reloc.  */
2479
2480 static void
2481 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2482                          Elf_Internal_Rela *dst)
2483 {
2484   unsigned int type;
2485
2486   /* Initialize howto table if needed.  */
2487   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2488     ppc_howto_init ();
2489
2490   type = ELF64_R_TYPE (dst->r_info);
2491   if (type >= ARRAY_SIZE (ppc64_elf_howto_table))
2492     {
2493       (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
2494                              abfd, (int) type);
2495       type = R_PPC64_NONE;
2496     }
2497   cache_ptr->howto = ppc64_elf_howto_table[type];
2498 }
2499
2500 /* Handle the R_PPC64_ADDR16_HA and similar relocs.  */
2501
2502 static bfd_reloc_status_type
2503 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2504                     void *data, asection *input_section,
2505                     bfd *output_bfd, char **error_message)
2506 {
2507   enum elf_ppc64_reloc_type r_type;
2508   long insn;
2509   bfd_size_type octets;
2510   bfd_vma value;
2511
2512   /* If this is a relocatable link (output_bfd test tells us), just
2513      call the generic function.  Any adjustment will be done at final
2514      link time.  */
2515   if (output_bfd != NULL)
2516     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2517                                   input_section, output_bfd, error_message);
2518
2519   /* Adjust the addend for sign extension of the low 16 bits.
2520      We won't actually be using the low 16 bits, so trashing them
2521      doesn't matter.  */
2522   reloc_entry->addend += 0x8000;
2523   r_type = reloc_entry->howto->type;
2524   if (r_type != R_PPC64_REL16DX_HA)
2525     return bfd_reloc_continue;
2526
2527   value = 0;
2528   if (!bfd_is_com_section (symbol->section))
2529     value = symbol->value;
2530   value += (reloc_entry->addend
2531             + symbol->section->output_offset
2532             + symbol->section->output_section->vma);
2533   value -= (reloc_entry->address
2534             + input_section->output_offset
2535             + input_section->output_section->vma);
2536   value = (bfd_signed_vma) value >> 16;
2537
2538   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2539   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2540   insn &= ~0x1fffc1;
2541   insn |= (value & 0xffc1) | ((value & 0x3e) << 15);
2542   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2543   if (value + 0x8000 > 0xffff)
2544     return bfd_reloc_overflow;
2545   return bfd_reloc_ok;
2546 }
2547
2548 static bfd_reloc_status_type
2549 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2550                         void *data, asection *input_section,
2551                         bfd *output_bfd, char **error_message)
2552 {
2553   if (output_bfd != NULL)
2554     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2555                                   input_section, output_bfd, error_message);
2556
2557   if (strcmp (symbol->section->name, ".opd") == 0
2558       && (symbol->section->owner->flags & DYNAMIC) == 0)
2559     {
2560       bfd_vma dest = opd_entry_value (symbol->section,
2561                                       symbol->value + reloc_entry->addend,
2562                                       NULL, NULL, FALSE);
2563       if (dest != (bfd_vma) -1)
2564         reloc_entry->addend = dest - (symbol->value
2565                                       + symbol->section->output_section->vma
2566                                       + symbol->section->output_offset);
2567     }
2568   else
2569     {
2570       elf_symbol_type *elfsym = (elf_symbol_type *) symbol;
2571
2572       if (symbol->section->owner != abfd
2573           && abiversion (symbol->section->owner) >= 2)
2574         {
2575           unsigned int i;
2576
2577           for (i = 0; i < symbol->section->owner->symcount; ++i)
2578             {
2579               asymbol *symdef = symbol->section->owner->outsymbols[i];
2580
2581               if (strcmp (symdef->name, symbol->name) == 0)
2582                 {
2583                   elfsym = (elf_symbol_type *) symdef;
2584                   break;
2585                 }
2586             }
2587         }
2588       reloc_entry->addend
2589         += PPC64_LOCAL_ENTRY_OFFSET (elfsym->internal_elf_sym.st_other);
2590     }
2591   return bfd_reloc_continue;
2592 }
2593
2594 static bfd_reloc_status_type
2595 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2596                          void *data, asection *input_section,
2597                          bfd *output_bfd, char **error_message)
2598 {
2599   long insn;
2600   enum elf_ppc64_reloc_type r_type;
2601   bfd_size_type octets;
2602   /* Assume 'at' branch hints.  */
2603   bfd_boolean is_isa_v2 = TRUE;
2604
2605   /* If this is a relocatable link (output_bfd test tells us), just
2606      call the generic function.  Any adjustment will be done at final
2607      link time.  */
2608   if (output_bfd != NULL)
2609     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2610                                   input_section, output_bfd, error_message);
2611
2612   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2613   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2614   insn &= ~(0x01 << 21);
2615   r_type = reloc_entry->howto->type;
2616   if (r_type == R_PPC64_ADDR14_BRTAKEN
2617       || r_type == R_PPC64_REL14_BRTAKEN)
2618     insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
2619
2620   if (is_isa_v2)
2621     {
2622       /* Set 'a' bit.  This is 0b00010 in BO field for branch
2623          on CR(BI) insns (BO == 001at or 011at), and 0b01000
2624          for branch on CTR insns (BO == 1a00t or 1a01t).  */
2625       if ((insn & (0x14 << 21)) == (0x04 << 21))
2626         insn |= 0x02 << 21;
2627       else if ((insn & (0x14 << 21)) == (0x10 << 21))
2628         insn |= 0x08 << 21;
2629       else
2630         goto out;
2631     }
2632   else
2633     {
2634       bfd_vma target = 0;
2635       bfd_vma from;
2636
2637       if (!bfd_is_com_section (symbol->section))
2638         target = symbol->value;
2639       target += symbol->section->output_section->vma;
2640       target += symbol->section->output_offset;
2641       target += reloc_entry->addend;
2642
2643       from = (reloc_entry->address
2644               + input_section->output_offset
2645               + input_section->output_section->vma);
2646
2647       /* Invert 'y' bit if not the default.  */
2648       if ((bfd_signed_vma) (target - from) < 0)
2649         insn ^= 0x01 << 21;
2650     }
2651   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2652  out:
2653   return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2654                                  input_section, output_bfd, error_message);
2655 }
2656
2657 static bfd_reloc_status_type
2658 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2659                          void *data, asection *input_section,
2660                          bfd *output_bfd, char **error_message)
2661 {
2662   /* If this is a relocatable link (output_bfd test tells us), just
2663      call the generic function.  Any adjustment will be done at final
2664      link time.  */
2665   if (output_bfd != NULL)
2666     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2667                                   input_section, output_bfd, error_message);
2668
2669   /* Subtract the symbol section base address.  */
2670   reloc_entry->addend -= symbol->section->output_section->vma;
2671   return bfd_reloc_continue;
2672 }
2673
2674 static bfd_reloc_status_type
2675 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2676                             void *data, asection *input_section,
2677                             bfd *output_bfd, char **error_message)
2678 {
2679   /* If this is a relocatable link (output_bfd test tells us), just
2680      call the generic function.  Any adjustment will be done at final
2681      link time.  */
2682   if (output_bfd != NULL)
2683     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2684                                   input_section, output_bfd, error_message);
2685
2686   /* Subtract the symbol section base address.  */
2687   reloc_entry->addend -= symbol->section->output_section->vma;
2688
2689   /* Adjust the addend for sign extension of the low 16 bits.  */
2690   reloc_entry->addend += 0x8000;
2691   return bfd_reloc_continue;
2692 }
2693
2694 static bfd_reloc_status_type
2695 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2696                      void *data, asection *input_section,
2697                      bfd *output_bfd, char **error_message)
2698 {
2699   bfd_vma TOCstart;
2700
2701   /* If this is a relocatable link (output_bfd test tells us), just
2702      call the generic function.  Any adjustment will be done at final
2703      link time.  */
2704   if (output_bfd != NULL)
2705     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2706                                   input_section, output_bfd, error_message);
2707
2708   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2709   if (TOCstart == 0)
2710     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2711
2712   /* Subtract the TOC base address.  */
2713   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2714   return bfd_reloc_continue;
2715 }
2716
2717 static bfd_reloc_status_type
2718 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2719                         void *data, asection *input_section,
2720                         bfd *output_bfd, char **error_message)
2721 {
2722   bfd_vma TOCstart;
2723
2724   /* If this is a relocatable link (output_bfd test tells us), just
2725      call the generic function.  Any adjustment will be done at final
2726      link time.  */
2727   if (output_bfd != NULL)
2728     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2729                                   input_section, output_bfd, error_message);
2730
2731   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2732   if (TOCstart == 0)
2733     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2734
2735   /* Subtract the TOC base address.  */
2736   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2737
2738   /* Adjust the addend for sign extension of the low 16 bits.  */
2739   reloc_entry->addend += 0x8000;
2740   return bfd_reloc_continue;
2741 }
2742
2743 static bfd_reloc_status_type
2744 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2745                        void *data, asection *input_section,
2746                        bfd *output_bfd, char **error_message)
2747 {
2748   bfd_vma TOCstart;
2749   bfd_size_type octets;
2750
2751   /* If this is a relocatable link (output_bfd test tells us), just
2752      call the generic function.  Any adjustment will be done at final
2753      link time.  */
2754   if (output_bfd != NULL)
2755     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2756                                   input_section, output_bfd, error_message);
2757
2758   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2759   if (TOCstart == 0)
2760     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2761
2762   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2763   bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2764   return bfd_reloc_ok;
2765 }
2766
2767 static bfd_reloc_status_type
2768 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2769                            void *data, asection *input_section,
2770                            bfd *output_bfd, char **error_message)
2771 {
2772   /* If this is a relocatable link (output_bfd test tells us), just
2773      call the generic function.  Any adjustment will be done at final
2774      link time.  */
2775   if (output_bfd != NULL)
2776     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2777                                   input_section, output_bfd, error_message);
2778
2779   if (error_message != NULL)
2780     {
2781       static char buf[60];
2782       sprintf (buf, "generic linker can't handle %s",
2783                reloc_entry->howto->name);
2784       *error_message = buf;
2785     }
2786   return bfd_reloc_dangerous;
2787 }
2788
2789 /* Track GOT entries needed for a given symbol.  We might need more
2790    than one got entry per symbol.  */
2791 struct got_entry
2792 {
2793   struct got_entry *next;
2794
2795   /* The symbol addend that we'll be placing in the GOT.  */
2796   bfd_vma addend;
2797
2798   /* Unlike other ELF targets, we use separate GOT entries for the same
2799      symbol referenced from different input files.  This is to support
2800      automatic multiple TOC/GOT sections, where the TOC base can vary
2801      from one input file to another.  After partitioning into TOC groups
2802      we merge entries within the group.
2803
2804      Point to the BFD owning this GOT entry.  */
2805   bfd *owner;
2806
2807   /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2808      TLS_TPREL or TLS_DTPREL for tls entries.  */
2809   unsigned char tls_type;
2810
2811   /* Non-zero if got.ent points to real entry.  */
2812   unsigned char is_indirect;
2813
2814   /* Reference count until size_dynamic_sections, GOT offset thereafter.  */
2815   union
2816     {
2817       bfd_signed_vma refcount;
2818       bfd_vma offset;
2819       struct got_entry *ent;
2820     } got;
2821 };
2822
2823 /* The same for PLT.  */
2824 struct plt_entry
2825 {
2826   struct plt_entry *next;
2827
2828   bfd_vma addend;
2829
2830   union
2831     {
2832       bfd_signed_vma refcount;
2833       bfd_vma offset;
2834     } plt;
2835 };
2836
2837 struct ppc64_elf_obj_tdata
2838 {
2839   struct elf_obj_tdata elf;
2840
2841   /* Shortcuts to dynamic linker sections.  */
2842   asection *got;
2843   asection *relgot;
2844
2845   /* Used during garbage collection.  We attach global symbols defined
2846      on removed .opd entries to this section so that the sym is removed.  */
2847   asection *deleted_section;
2848
2849   /* TLS local dynamic got entry handling.  Support for multiple GOT
2850      sections means we potentially need one of these for each input bfd.  */
2851   struct got_entry tlsld_got;
2852
2853   union {
2854     /* A copy of relocs before they are modified for --emit-relocs.  */
2855     Elf_Internal_Rela *relocs;
2856
2857     /* Section contents.  */
2858     bfd_byte *contents;
2859   } opd;
2860
2861   /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2862      the reloc to be in the range -32768 to 32767.  */
2863   unsigned int has_small_toc_reloc : 1;
2864
2865   /* Set if toc/got ha relocs detected not using r2, or lo reloc
2866      instruction not one we handle.  */
2867   unsigned int unexpected_toc_insn : 1;
2868 };
2869
2870 #define ppc64_elf_tdata(bfd) \
2871   ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2872
2873 #define ppc64_tlsld_got(bfd) \
2874   (&ppc64_elf_tdata (bfd)->tlsld_got)
2875
2876 #define is_ppc64_elf(bfd) \
2877   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2878    && elf_object_id (bfd) == PPC64_ELF_DATA)
2879
2880 /* Override the generic function because we store some extras.  */
2881
2882 static bfd_boolean
2883 ppc64_elf_mkobject (bfd *abfd)
2884 {
2885   return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2886                                   PPC64_ELF_DATA);
2887 }
2888
2889 /* Fix bad default arch selected for a 64 bit input bfd when the
2890    default is 32 bit.  */
2891
2892 static bfd_boolean
2893 ppc64_elf_object_p (bfd *abfd)
2894 {
2895   if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32)
2896     {
2897       Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2898
2899       if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2900         {
2901           /* Relies on arch after 32 bit default being 64 bit default.  */
2902           abfd->arch_info = abfd->arch_info->next;
2903           BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2904         }
2905     }
2906   return TRUE;
2907 }
2908
2909 /* Support for core dump NOTE sections.  */
2910
2911 static bfd_boolean
2912 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2913 {
2914   size_t offset, size;
2915
2916   if (note->descsz != 504)
2917     return FALSE;
2918
2919   /* pr_cursig */
2920   elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2921
2922   /* pr_pid */
2923   elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2924
2925   /* pr_reg */
2926   offset = 112;
2927   size = 384;
2928
2929   /* Make a ".reg/999" section.  */
2930   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2931                                           size, note->descpos + offset);
2932 }
2933
2934 static bfd_boolean
2935 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2936 {
2937   if (note->descsz != 136)
2938     return FALSE;
2939
2940   elf_tdata (abfd)->core->pid
2941     = bfd_get_32 (abfd, note->descdata + 24);
2942   elf_tdata (abfd)->core->program
2943     = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2944   elf_tdata (abfd)->core->command
2945     = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2946
2947   return TRUE;
2948 }
2949
2950 static char *
2951 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2952                            ...)
2953 {
2954   switch (note_type)
2955     {
2956     default:
2957       return NULL;
2958
2959     case NT_PRPSINFO:
2960       {
2961         char data[136];
2962         va_list ap;
2963
2964         va_start (ap, note_type);
2965         memset (data, 0, sizeof (data));
2966         strncpy (data + 40, va_arg (ap, const char *), 16);
2967         strncpy (data + 56, va_arg (ap, const char *), 80);
2968         va_end (ap);
2969         return elfcore_write_note (abfd, buf, bufsiz,
2970                                    "CORE", note_type, data, sizeof (data));
2971       }
2972
2973     case NT_PRSTATUS:
2974       {
2975         char data[504];
2976         va_list ap;
2977         long pid;
2978         int cursig;
2979         const void *greg;
2980
2981         va_start (ap, note_type);
2982         memset (data, 0, 112);
2983         pid = va_arg (ap, long);
2984         bfd_put_32 (abfd, pid, data + 32);
2985         cursig = va_arg (ap, int);
2986         bfd_put_16 (abfd, cursig, data + 12);
2987         greg = va_arg (ap, const void *);
2988         memcpy (data + 112, greg, 384);
2989         memset (data + 496, 0, 8);
2990         va_end (ap);
2991         return elfcore_write_note (abfd, buf, bufsiz,
2992                                    "CORE", note_type, data, sizeof (data));
2993       }
2994     }
2995 }
2996
2997 /* Add extra PPC sections.  */
2998
2999 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
3000 {
3001   { STRING_COMMA_LEN (".plt"),    0, SHT_NOBITS,   0 },
3002   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
3003   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3004   { STRING_COMMA_LEN (".toc"),    0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3005   { STRING_COMMA_LEN (".toc1"),   0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3006   { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
3007   { NULL,                     0,  0, 0,            0 }
3008 };
3009
3010 enum _ppc64_sec_type {
3011   sec_normal = 0,
3012   sec_opd = 1,
3013   sec_toc = 2
3014 };
3015
3016 struct _ppc64_elf_section_data
3017 {
3018   struct bfd_elf_section_data elf;
3019
3020   union
3021   {
3022     /* An array with one entry for each opd function descriptor,
3023        and some spares since opd entries may be either 16 or 24 bytes.  */
3024 #define OPD_NDX(OFF) ((OFF) >> 4)
3025     struct _opd_sec_data
3026     {
3027       /* Points to the function code section for local opd entries.  */
3028       asection **func_sec;
3029
3030       /* After editing .opd, adjust references to opd local syms.  */
3031       long *adjust;
3032     } opd;
3033
3034     /* An array for toc sections, indexed by offset/8.  */
3035     struct _toc_sec_data
3036     {
3037       /* Specifies the relocation symbol index used at a given toc offset.  */
3038       unsigned *symndx;
3039
3040       /* And the relocation addend.  */
3041       bfd_vma *add;
3042     } toc;
3043   } u;
3044
3045   enum _ppc64_sec_type sec_type:2;
3046
3047   /* Flag set when small branches are detected.  Used to
3048      select suitable defaults for the stub group size.  */
3049   unsigned int has_14bit_branch:1;
3050 };
3051
3052 #define ppc64_elf_section_data(sec) \
3053   ((struct _ppc64_elf_section_data *) elf_section_data (sec))
3054
3055 static bfd_boolean
3056 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
3057 {
3058   if (!sec->used_by_bfd)
3059     {
3060       struct _ppc64_elf_section_data *sdata;
3061       bfd_size_type amt = sizeof (*sdata);
3062
3063       sdata = bfd_zalloc (abfd, amt);
3064       if (sdata == NULL)
3065         return FALSE;
3066       sec->used_by_bfd = sdata;
3067     }
3068
3069   return _bfd_elf_new_section_hook (abfd, sec);
3070 }
3071
3072 static struct _opd_sec_data *
3073 get_opd_info (asection * sec)
3074 {
3075   if (sec != NULL
3076       && ppc64_elf_section_data (sec) != NULL
3077       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
3078     return &ppc64_elf_section_data (sec)->u.opd;
3079   return NULL;
3080 }
3081 \f
3082 /* Parameters for the qsort hook.  */
3083 static bfd_boolean synthetic_relocatable;
3084
3085 /* qsort comparison function for ppc64_elf_get_synthetic_symtab.  */
3086
3087 static int
3088 compare_symbols (const void *ap, const void *bp)
3089 {
3090   const asymbol *a = * (const asymbol **) ap;
3091   const asymbol *b = * (const asymbol **) bp;
3092
3093   /* Section symbols first.  */
3094   if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
3095     return -1;
3096   if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
3097     return 1;
3098
3099   /* then .opd symbols.  */
3100   if (strcmp (a->section->name, ".opd") == 0
3101       && strcmp (b->section->name, ".opd") != 0)
3102     return -1;
3103   if (strcmp (a->section->name, ".opd") != 0
3104       && strcmp (b->section->name, ".opd") == 0)
3105     return 1;
3106
3107   /* then other code symbols.  */
3108   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3109       == (SEC_CODE | SEC_ALLOC)
3110       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3111          != (SEC_CODE | SEC_ALLOC))
3112     return -1;
3113
3114   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3115       != (SEC_CODE | SEC_ALLOC)
3116       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3117          == (SEC_CODE | SEC_ALLOC))
3118     return 1;
3119
3120   if (synthetic_relocatable)
3121     {
3122       if (a->section->id < b->section->id)
3123         return -1;
3124
3125       if (a->section->id > b->section->id)
3126         return 1;
3127     }
3128
3129   if (a->value + a->section->vma < b->value + b->section->vma)
3130     return -1;
3131
3132   if (a->value + a->section->vma > b->value + b->section->vma)
3133     return 1;
3134
3135   /* For syms with the same value, prefer strong dynamic global function
3136      syms over other syms.  */
3137   if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3138     return -1;
3139
3140   if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3141     return 1;
3142
3143   if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3144     return -1;
3145
3146   if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3147     return 1;
3148
3149   if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3150     return -1;
3151
3152   if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3153     return 1;
3154
3155   if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3156     return -1;
3157
3158   if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3159     return 1;
3160
3161   return 0;
3162 }
3163
3164 /* Search SYMS for a symbol of the given VALUE.  */
3165
3166 static asymbol *
3167 sym_exists_at (asymbol **syms, long lo, long hi, unsigned int id, bfd_vma value)
3168 {
3169   long mid;
3170
3171   if (id == (unsigned) -1)
3172     {
3173       while (lo < hi)
3174         {
3175           mid = (lo + hi) >> 1;
3176           if (syms[mid]->value + syms[mid]->section->vma < value)
3177             lo = mid + 1;
3178           else if (syms[mid]->value + syms[mid]->section->vma > value)
3179             hi = mid;
3180           else
3181             return syms[mid];
3182         }
3183     }
3184   else
3185     {
3186       while (lo < hi)
3187         {
3188           mid = (lo + hi) >> 1;
3189           if (syms[mid]->section->id < id)
3190             lo = mid + 1;
3191           else if (syms[mid]->section->id > id)
3192             hi = mid;
3193           else if (syms[mid]->value < value)
3194             lo = mid + 1;
3195           else if (syms[mid]->value > value)
3196             hi = mid;
3197           else
3198             return syms[mid];
3199         }
3200     }
3201   return NULL;
3202 }
3203
3204 static bfd_boolean
3205 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3206 {
3207   bfd_vma vma = *(bfd_vma *) ptr;
3208   return ((section->flags & SEC_ALLOC) != 0
3209           && section->vma <= vma
3210           && vma < section->vma + section->size);
3211 }
3212
3213 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3214    entry syms.  Also generate @plt symbols for the glink branch table.
3215    Returns count of synthetic symbols in RET or -1 on error.  */
3216
3217 static long
3218 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3219                                 long static_count, asymbol **static_syms,
3220                                 long dyn_count, asymbol **dyn_syms,
3221                                 asymbol **ret)
3222 {
3223   asymbol *s;
3224   long i;
3225   long count;
3226   char *names;
3227   long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3228   asection *opd = NULL;
3229   bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3230   asymbol **syms;
3231   int abi = abiversion (abfd);
3232
3233   *ret = NULL;
3234
3235   if (abi < 2)
3236     {
3237       opd = bfd_get_section_by_name (abfd, ".opd");
3238       if (opd == NULL && abi == 1)
3239         return 0;
3240     }
3241
3242   symcount = static_count;
3243   if (!relocatable)
3244     symcount += dyn_count;
3245   if (symcount == 0)
3246     return 0;
3247
3248   syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3249   if (syms == NULL)
3250     return -1;
3251
3252   if (!relocatable && static_count != 0 && dyn_count != 0)
3253     {
3254       /* Use both symbol tables.  */
3255       memcpy (syms, static_syms, static_count * sizeof (*syms));
3256       memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3257     }
3258   else if (!relocatable && static_count == 0)
3259     memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3260   else
3261     memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3262
3263   synthetic_relocatable = relocatable;
3264   qsort (syms, symcount, sizeof (*syms), compare_symbols);
3265
3266   if (!relocatable && symcount > 1)
3267     {
3268       long j;
3269       /* Trim duplicate syms, since we may have merged the normal and
3270          dynamic symbols.  Actually, we only care about syms that have
3271          different values, so trim any with the same value.  */
3272       for (i = 1, j = 1; i < symcount; ++i)
3273         if (syms[i - 1]->value + syms[i - 1]->section->vma
3274             != syms[i]->value + syms[i]->section->vma)
3275           syms[j++] = syms[i];
3276       symcount = j;
3277     }
3278
3279   i = 0;
3280   if (strcmp (syms[i]->section->name, ".opd") == 0)
3281     ++i;
3282   codesecsym = i;
3283
3284   for (; i < symcount; ++i)
3285     if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3286          != (SEC_CODE | SEC_ALLOC))
3287         || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3288       break;
3289   codesecsymend = i;
3290
3291   for (; i < symcount; ++i)
3292     if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3293       break;
3294   secsymend = i;
3295
3296   for (; i < symcount; ++i)
3297     if (strcmp (syms[i]->section->name, ".opd") != 0)
3298       break;
3299   opdsymend = i;
3300
3301   for (; i < symcount; ++i)
3302     if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3303         != (SEC_CODE | SEC_ALLOC))
3304       break;
3305   symcount = i;
3306
3307   count = 0;
3308
3309   if (relocatable)
3310     {
3311       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3312       arelent *r;
3313       size_t size;
3314       long relcount;
3315
3316       if (opdsymend == secsymend)
3317         goto done;
3318
3319       slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3320       relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3321       if (relcount == 0)
3322         goto done;
3323
3324       if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3325         {
3326           count = -1;
3327           goto done;
3328         }
3329
3330       size = 0;
3331       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3332         {
3333           asymbol *sym;
3334
3335           while (r < opd->relocation + relcount
3336                  && r->address < syms[i]->value + opd->vma)
3337             ++r;
3338
3339           if (r == opd->relocation + relcount)
3340             break;
3341
3342           if (r->address != syms[i]->value + opd->vma)
3343             continue;
3344
3345           if (r->howto->type != R_PPC64_ADDR64)
3346             continue;
3347
3348           sym = *r->sym_ptr_ptr;
3349           if (!sym_exists_at (syms, opdsymend, symcount,
3350                               sym->section->id, sym->value + r->addend))
3351             {
3352               ++count;
3353               size += sizeof (asymbol);
3354               size += strlen (syms[i]->name) + 2;
3355             }
3356         }
3357
3358       if (size == 0)
3359         goto done;
3360       s = *ret = bfd_malloc (size);
3361       if (s == NULL)
3362         {
3363           count = -1;
3364           goto done;
3365         }
3366
3367       names = (char *) (s + count);
3368
3369       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3370         {
3371           asymbol *sym;
3372
3373           while (r < opd->relocation + relcount
3374                  && r->address < syms[i]->value + opd->vma)
3375             ++r;
3376
3377           if (r == opd->relocation + relcount)
3378             break;
3379
3380           if (r->address != syms[i]->value + opd->vma)
3381             continue;
3382
3383           if (r->howto->type != R_PPC64_ADDR64)
3384             continue;
3385
3386           sym = *r->sym_ptr_ptr;
3387           if (!sym_exists_at (syms, opdsymend, symcount,
3388                               sym->section->id, sym->value + r->addend))
3389             {
3390               size_t len;
3391
3392               *s = *syms[i];
3393               s->flags |= BSF_SYNTHETIC;
3394               s->section = sym->section;
3395               s->value = sym->value + r->addend;
3396               s->name = names;
3397               *names++ = '.';
3398               len = strlen (syms[i]->name);
3399               memcpy (names, syms[i]->name, len + 1);
3400               names += len + 1;
3401               /* Have udata.p point back to the original symbol this
3402                  synthetic symbol was derived from.  */
3403               s->udata.p = syms[i];
3404               s++;
3405             }
3406         }
3407     }
3408   else
3409     {
3410       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3411       bfd_byte *contents = NULL;
3412       size_t size;
3413       long plt_count = 0;
3414       bfd_vma glink_vma = 0, resolv_vma = 0;
3415       asection *dynamic, *glink = NULL, *relplt = NULL;
3416       arelent *p;
3417
3418       if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3419         {
3420         free_contents_and_exit_err:
3421           count = -1;
3422         free_contents_and_exit:
3423           if (contents)
3424             free (contents);
3425           goto done;
3426         }
3427
3428       size = 0;
3429       for (i = secsymend; i < opdsymend; ++i)
3430         {
3431           bfd_vma ent;
3432
3433           /* Ignore bogus symbols.  */
3434           if (syms[i]->value > opd->size - 8)
3435             continue;
3436
3437           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3438           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3439             {
3440               ++count;
3441               size += sizeof (asymbol);
3442               size += strlen (syms[i]->name) + 2;
3443             }
3444         }
3445
3446       /* Get start of .glink stubs from DT_PPC64_GLINK.  */
3447       if (dyn_count != 0
3448           && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3449         {
3450           bfd_byte *dynbuf, *extdyn, *extdynend;
3451           size_t extdynsize;
3452           void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3453
3454           if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3455             goto free_contents_and_exit_err;
3456
3457           extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3458           swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3459
3460           extdyn = dynbuf;
3461           extdynend = extdyn + dynamic->size;
3462           for (; extdyn < extdynend; extdyn += extdynsize)
3463             {
3464               Elf_Internal_Dyn dyn;
3465               (*swap_dyn_in) (abfd, extdyn, &dyn);
3466
3467               if (dyn.d_tag == DT_NULL)
3468                 break;
3469
3470               if (dyn.d_tag == DT_PPC64_GLINK)
3471                 {
3472                   /* The first glink stub starts at offset 32; see
3473                      comment in ppc64_elf_finish_dynamic_sections. */
3474                   glink_vma = dyn.d_un.d_val + GLINK_CALL_STUB_SIZE - 8 * 4;
3475                   /* The .glink section usually does not survive the final
3476                      link; search for the section (usually .text) where the
3477                      glink stubs now reside.  */
3478                   glink = bfd_sections_find_if (abfd, section_covers_vma,
3479                                                 &glink_vma);
3480                   break;
3481                 }
3482             }
3483
3484           free (dynbuf);
3485         }
3486
3487       if (glink != NULL)
3488         {
3489           /* Determine __glink trampoline by reading the relative branch
3490              from the first glink stub.  */
3491           bfd_byte buf[4];
3492           unsigned int off = 0;
3493
3494           while (bfd_get_section_contents (abfd, glink, buf,
3495                                            glink_vma + off - glink->vma, 4))
3496             {
3497               unsigned int insn = bfd_get_32 (abfd, buf);
3498               insn ^= B_DOT;
3499               if ((insn & ~0x3fffffc) == 0)
3500                 {
3501                   resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3502                   break;
3503                 }
3504               off += 4;
3505               if (off > 4)
3506                 break;
3507             }
3508
3509           if (resolv_vma)
3510             size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3511
3512           relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3513           if (relplt != NULL)
3514             {
3515               slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3516               if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3517                 goto free_contents_and_exit_err;
3518
3519               plt_count = relplt->size / sizeof (Elf64_External_Rela);
3520               size += plt_count * sizeof (asymbol);
3521
3522               p = relplt->relocation;
3523               for (i = 0; i < plt_count; i++, p++)
3524                 {
3525                   size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3526                   if (p->addend != 0)
3527                     size += sizeof ("+0x") - 1 + 16;
3528                 }
3529             }
3530         }
3531
3532       if (size == 0)
3533         goto free_contents_and_exit;
3534       s = *ret = bfd_malloc (size);
3535       if (s == NULL)
3536         goto free_contents_and_exit_err;
3537
3538       names = (char *) (s + count + plt_count + (resolv_vma != 0));
3539
3540       for (i = secsymend; i < opdsymend; ++i)
3541         {
3542           bfd_vma ent;
3543
3544           if (syms[i]->value > opd->size - 8)
3545             continue;
3546
3547           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3548           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3549             {
3550               long lo, hi;
3551               size_t len;
3552               asection *sec = abfd->sections;
3553
3554               *s = *syms[i];
3555               lo = codesecsym;
3556               hi = codesecsymend;
3557               while (lo < hi)
3558                 {
3559                   long mid = (lo + hi) >> 1;
3560                   if (syms[mid]->section->vma < ent)
3561                     lo = mid + 1;
3562                   else if (syms[mid]->section->vma > ent)
3563                     hi = mid;
3564                   else
3565                     {
3566                       sec = syms[mid]->section;
3567                       break;
3568                     }
3569                 }
3570
3571               if (lo >= hi && lo > codesecsym)
3572                 sec = syms[lo - 1]->section;
3573
3574               for (; sec != NULL; sec = sec->next)
3575                 {
3576                   if (sec->vma > ent)
3577                     break;
3578                   /* SEC_LOAD may not be set if SEC is from a separate debug
3579                      info file.  */
3580                   if ((sec->flags & SEC_ALLOC) == 0)
3581                     break;
3582                   if ((sec->flags & SEC_CODE) != 0)
3583                     s->section = sec;
3584                 }
3585               s->flags |= BSF_SYNTHETIC;
3586               s->value = ent - s->section->vma;
3587               s->name = names;
3588               *names++ = '.';
3589               len = strlen (syms[i]->name);
3590               memcpy (names, syms[i]->name, len + 1);
3591               names += len + 1;
3592               /* Have udata.p point back to the original symbol this
3593                  synthetic symbol was derived from.  */
3594               s->udata.p = syms[i];
3595               s++;
3596             }
3597         }
3598       free (contents);
3599
3600       if (glink != NULL && relplt != NULL)
3601         {
3602           if (resolv_vma)
3603             {
3604               /* Add a symbol for the main glink trampoline.  */
3605               memset (s, 0, sizeof *s);
3606               s->the_bfd = abfd;
3607               s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3608               s->section = glink;
3609               s->value = resolv_vma - glink->vma;
3610               s->name = names;
3611               memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3612               names += sizeof ("__glink_PLTresolve");
3613               s++;
3614               count++;
3615             }
3616
3617           /* FIXME: It would be very much nicer to put sym@plt on the
3618              stub rather than on the glink branch table entry.  The
3619              objdump disassembler would then use a sensible symbol
3620              name on plt calls.  The difficulty in doing so is
3621              a) finding the stubs, and,
3622              b) matching stubs against plt entries, and,
3623              c) there can be multiple stubs for a given plt entry.
3624
3625              Solving (a) could be done by code scanning, but older
3626              ppc64 binaries used different stubs to current code.
3627              (b) is the tricky one since you need to known the toc
3628              pointer for at least one function that uses a pic stub to
3629              be able to calculate the plt address referenced.
3630              (c) means gdb would need to set multiple breakpoints (or
3631              find the glink branch itself) when setting breakpoints
3632              for pending shared library loads.  */
3633           p = relplt->relocation;
3634           for (i = 0; i < plt_count; i++, p++)
3635             {
3636               size_t len;
3637
3638               *s = **p->sym_ptr_ptr;
3639               /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
3640                  we are defining a symbol, ensure one of them is set.  */
3641               if ((s->flags & BSF_LOCAL) == 0)
3642                 s->flags |= BSF_GLOBAL;
3643               s->flags |= BSF_SYNTHETIC;
3644               s->section = glink;
3645               s->value = glink_vma - glink->vma;
3646               s->name = names;
3647               s->udata.p = NULL;
3648               len = strlen ((*p->sym_ptr_ptr)->name);
3649               memcpy (names, (*p->sym_ptr_ptr)->name, len);
3650               names += len;
3651               if (p->addend != 0)
3652                 {
3653                   memcpy (names, "+0x", sizeof ("+0x") - 1);
3654                   names += sizeof ("+0x") - 1;
3655                   bfd_sprintf_vma (abfd, names, p->addend);
3656                   names += strlen (names);
3657                 }
3658               memcpy (names, "@plt", sizeof ("@plt"));
3659               names += sizeof ("@plt");
3660               s++;
3661               if (abi < 2)
3662                 {
3663                   glink_vma += 8;
3664                   if (i >= 0x8000)
3665                     glink_vma += 4;
3666                 }
3667               else
3668                 glink_vma += 4;
3669             }
3670           count += plt_count;
3671         }
3672     }
3673
3674  done:
3675   free (syms);
3676   return count;
3677 }
3678 \f
3679 /* The following functions are specific to the ELF linker, while
3680    functions above are used generally.  Those named ppc64_elf_* are
3681    called by the main ELF linker code.  They appear in this file more
3682    or less in the order in which they are called.  eg.
3683    ppc64_elf_check_relocs is called early in the link process,
3684    ppc64_elf_finish_dynamic_sections is one of the last functions
3685    called.
3686
3687    PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3688    functions have both a function code symbol and a function descriptor
3689    symbol.  A call to foo in a relocatable object file looks like:
3690
3691    .            .text
3692    .    x:
3693    .            bl      .foo
3694    .            nop
3695
3696    The function definition in another object file might be:
3697
3698    .            .section .opd
3699    .    foo:    .quad   .foo
3700    .            .quad   .TOC.@tocbase
3701    .            .quad   0
3702    .
3703    .            .text
3704    .    .foo:   blr
3705
3706    When the linker resolves the call during a static link, the branch
3707    unsurprisingly just goes to .foo and the .opd information is unused.
3708    If the function definition is in a shared library, things are a little
3709    different:  The call goes via a plt call stub, the opd information gets
3710    copied to the plt, and the linker patches the nop.
3711
3712    .    x:
3713    .            bl      .foo_stub
3714    .            ld      2,40(1)
3715    .
3716    .
3717    .    .foo_stub:
3718    .            std     2,40(1)                 # in practice, the call stub
3719    .            addis   11,2,Lfoo@toc@ha        # is slightly optimized, but
3720    .            addi    11,11,Lfoo@toc@l        # this is the general idea
3721    .            ld      12,0(11)
3722    .            ld      2,8(11)
3723    .            mtctr   12
3724    .            ld      11,16(11)
3725    .            bctr
3726    .
3727    .            .section .plt
3728    .    Lfoo:   reloc (R_PPC64_JMP_SLOT, foo)
3729
3730    The "reloc ()" notation is supposed to indicate that the linker emits
3731    an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
3732    copying.
3733
3734    What are the difficulties here?  Well, firstly, the relocations
3735    examined by the linker in check_relocs are against the function code
3736    sym .foo, while the dynamic relocation in the plt is emitted against
3737    the function descriptor symbol, foo.  Somewhere along the line, we need
3738    to carefully copy dynamic link information from one symbol to the other.
3739    Secondly, the generic part of the elf linker will make .foo a dynamic
3740    symbol as is normal for most other backends.  We need foo dynamic
3741    instead, at least for an application final link.  However, when
3742    creating a shared library containing foo, we need to have both symbols
3743    dynamic so that references to .foo are satisfied during the early
3744    stages of linking.  Otherwise the linker might decide to pull in a
3745    definition from some other object, eg. a static library.
3746
3747    Update: As of August 2004, we support a new convention.  Function
3748    calls may use the function descriptor symbol, ie. "bl foo".  This
3749    behaves exactly as "bl .foo".  */
3750
3751 /* Of those relocs that might be copied as dynamic relocs, this function
3752    selects those that must be copied when linking a shared library,
3753    even when the symbol is local.  */
3754
3755 static int
3756 must_be_dyn_reloc (struct bfd_link_info *info,
3757                    enum elf_ppc64_reloc_type r_type)
3758 {
3759   switch (r_type)
3760     {
3761     default:
3762       return 1;
3763
3764     case R_PPC64_REL32:
3765     case R_PPC64_REL64:
3766     case R_PPC64_REL30:
3767       return 0;
3768
3769     case R_PPC64_TPREL16:
3770     case R_PPC64_TPREL16_LO:
3771     case R_PPC64_TPREL16_HI:
3772     case R_PPC64_TPREL16_HA:
3773     case R_PPC64_TPREL16_DS:
3774     case R_PPC64_TPREL16_LO_DS:
3775     case R_PPC64_TPREL16_HIGH:
3776     case R_PPC64_TPREL16_HIGHA:
3777     case R_PPC64_TPREL16_HIGHER:
3778     case R_PPC64_TPREL16_HIGHERA:
3779     case R_PPC64_TPREL16_HIGHEST:
3780     case R_PPC64_TPREL16_HIGHESTA:
3781     case R_PPC64_TPREL64:
3782       return !bfd_link_executable (info);
3783     }
3784 }
3785
3786 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3787    copying dynamic variables from a shared lib into an app's dynbss
3788    section, and instead use a dynamic relocation to point into the
3789    shared lib.  With code that gcc generates, it's vital that this be
3790    enabled;  In the PowerPC64 ABI, the address of a function is actually
3791    the address of a function descriptor, which resides in the .opd
3792    section.  gcc uses the descriptor directly rather than going via the
3793    GOT as some other ABI's do, which means that initialized function
3794    pointers must reference the descriptor.  Thus, a function pointer
3795    initialized to the address of a function in a shared library will
3796    either require a copy reloc, or a dynamic reloc.  Using a copy reloc
3797    redefines the function descriptor symbol to point to the copy.  This
3798    presents a problem as a plt entry for that function is also
3799    initialized from the function descriptor symbol and the copy reloc
3800    may not be initialized first.  */
3801 #define ELIMINATE_COPY_RELOCS 1
3802
3803 /* Section name for stubs is the associated section name plus this
3804    string.  */
3805 #define STUB_SUFFIX ".stub"
3806
3807 /* Linker stubs.
3808    ppc_stub_long_branch:
3809    Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3810    destination, but a 24 bit branch in a stub section will reach.
3811    .    b       dest
3812
3813    ppc_stub_plt_branch:
3814    Similar to the above, but a 24 bit branch in the stub section won't
3815    reach its destination.
3816    .    addis   %r11,%r2,xxx@toc@ha
3817    .    ld      %r12,xxx@toc@l(%r11)
3818    .    mtctr   %r12
3819    .    bctr
3820
3821    ppc_stub_plt_call:
3822    Used to call a function in a shared library.  If it so happens that
3823    the plt entry referenced crosses a 64k boundary, then an extra
3824    "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3825    .    std     %r2,40(%r1)
3826    .    addis   %r11,%r2,xxx@toc@ha
3827    .    ld      %r12,xxx+0@toc@l(%r11)
3828    .    mtctr   %r12
3829    .    ld      %r2,xxx+8@toc@l(%r11)
3830    .    ld      %r11,xxx+16@toc@l(%r11)
3831    .    bctr
3832
3833    ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3834    code to adjust the value and save r2 to support multiple toc sections.
3835    A ppc_stub_long_branch with an r2 offset looks like:
3836    .    std     %r2,40(%r1)
3837    .    addis   %r2,%r2,off@ha
3838    .    addi    %r2,%r2,off@l
3839    .    b       dest
3840
3841    A ppc_stub_plt_branch with an r2 offset looks like:
3842    .    std     %r2,40(%r1)
3843    .    addis   %r11,%r2,xxx@toc@ha
3844    .    ld      %r12,xxx@toc@l(%r11)
3845    .    addis   %r2,%r2,off@ha
3846    .    addi    %r2,%r2,off@l
3847    .    mtctr   %r12
3848    .    bctr
3849
3850    In cases where the "addis" instruction would add zero, the "addis" is
3851    omitted and following instructions modified slightly in some cases.
3852 */
3853
3854 enum ppc_stub_type {
3855   ppc_stub_none,
3856   ppc_stub_long_branch,
3857   ppc_stub_long_branch_r2off,
3858   ppc_stub_plt_branch,
3859   ppc_stub_plt_branch_r2off,
3860   ppc_stub_plt_call,
3861   ppc_stub_plt_call_r2save,
3862   ppc_stub_global_entry,
3863   ppc_stub_save_res
3864 };
3865
3866 /* Information on stub grouping.  */
3867 struct map_stub
3868 {
3869   /* The stub section.  */
3870   asection *stub_sec;
3871   /* This is the section to which stubs in the group will be attached.  */
3872   asection *link_sec;
3873   /* Next group.  */
3874   struct map_stub *next;
3875   /* Whether to emit a copy of register save/restore functions in this
3876      group.  */
3877   int needs_save_res;
3878 };
3879
3880 struct ppc_stub_hash_entry {
3881
3882   /* Base hash table entry structure.  */
3883   struct bfd_hash_entry root;
3884
3885   enum ppc_stub_type stub_type;
3886
3887   /* Group information.  */
3888   struct map_stub *group;
3889
3890   /* Offset within stub_sec of the beginning of this stub.  */
3891   bfd_vma stub_offset;
3892
3893   /* Given the symbol's value and its section we can determine its final
3894      value when building the stubs (so the stub knows where to jump.  */
3895   bfd_vma target_value;
3896   asection *target_section;
3897
3898   /* The symbol table entry, if any, that this was derived from.  */
3899   struct ppc_link_hash_entry *h;
3900   struct plt_entry *plt_ent;
3901
3902   /* Symbol st_other.  */
3903   unsigned char other;
3904 };
3905
3906 struct ppc_branch_hash_entry {
3907
3908   /* Base hash table entry structure.  */
3909   struct bfd_hash_entry root;
3910
3911   /* Offset within branch lookup table.  */
3912   unsigned int offset;
3913
3914   /* Generation marker.  */
3915   unsigned int iter;
3916 };
3917
3918 /* Used to track dynamic relocations for local symbols.  */
3919 struct ppc_dyn_relocs
3920 {
3921   struct ppc_dyn_relocs *next;
3922
3923   /* The input section of the reloc.  */
3924   asection *sec;
3925
3926   /* Total number of relocs copied for the input section.  */
3927   unsigned int count : 31;
3928
3929   /* Whether this entry is for STT_GNU_IFUNC symbols.  */
3930   unsigned int ifunc : 1;
3931 };
3932
3933 struct ppc_link_hash_entry
3934 {
3935   struct elf_link_hash_entry elf;
3936
3937   union {
3938     /* A pointer to the most recently used stub hash entry against this
3939        symbol.  */
3940     struct ppc_stub_hash_entry *stub_cache;
3941
3942     /* A pointer to the next symbol starting with a '.'  */
3943     struct ppc_link_hash_entry *next_dot_sym;
3944   } u;
3945
3946   /* Track dynamic relocs copied for this symbol.  */
3947   struct elf_dyn_relocs *dyn_relocs;
3948
3949   /* Link between function code and descriptor symbols.  */
3950   struct ppc_link_hash_entry *oh;
3951
3952   /* Flag function code and descriptor symbols.  */
3953   unsigned int is_func:1;
3954   unsigned int is_func_descriptor:1;
3955   unsigned int fake:1;
3956
3957   /* Whether global opd/toc sym has been adjusted or not.
3958      After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3959      should be set for all globals defined in any opd/toc section.  */
3960   unsigned int adjust_done:1;
3961
3962   /* Set if we twiddled this symbol to weak at some stage.  */
3963   unsigned int was_undefined:1;
3964
3965   /* Set if this is an out-of-line register save/restore function,
3966      with non-standard calling convention.  */
3967   unsigned int save_res:1;
3968
3969   /* Contexts in which symbol is used in the GOT (or TOC).
3970      TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3971      corresponding relocs are encountered during check_relocs.
3972      tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3973      indicate the corresponding GOT entry type is not needed.
3974      tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3975      a TPREL one.  We use a separate flag rather than setting TPREL
3976      just for convenience in distinguishing the two cases.  */
3977 #define TLS_GD           1      /* GD reloc. */
3978 #define TLS_LD           2      /* LD reloc. */
3979 #define TLS_TPREL        4      /* TPREL reloc, => IE. */
3980 #define TLS_DTPREL       8      /* DTPREL reloc, => LD. */
3981 #define TLS_TLS         16      /* Any TLS reloc.  */
3982 #define TLS_EXPLICIT    32      /* Marks TOC section TLS relocs. */
3983 #define TLS_TPRELGD     64      /* TPREL reloc resulting from GD->IE. */
3984 #define PLT_IFUNC      128      /* STT_GNU_IFUNC.  */
3985   unsigned char tls_mask;
3986 };
3987
3988 /* ppc64 ELF linker hash table.  */
3989
3990 struct ppc_link_hash_table
3991 {
3992   struct elf_link_hash_table elf;
3993
3994   /* The stub hash table.  */
3995   struct bfd_hash_table stub_hash_table;
3996
3997   /* Another hash table for plt_branch stubs.  */
3998   struct bfd_hash_table branch_hash_table;
3999
4000   /* Hash table for function prologue tocsave.  */
4001   htab_t tocsave_htab;
4002
4003   /* Various options and other info passed from the linker.  */
4004   struct ppc64_elf_params *params;
4005
4006   /* The size of sec_info below.  */
4007   unsigned int sec_info_arr_size;
4008
4009   /* Per-section array of extra section info.  Done this way rather
4010      than as part of ppc64_elf_section_data so we have the info for
4011      non-ppc64 sections.  */
4012   struct
4013   {
4014     /* Along with elf_gp, specifies the TOC pointer used by this section.  */
4015     bfd_vma toc_off;
4016
4017     union
4018     {
4019       /* The section group that this section belongs to.  */
4020       struct map_stub *group;
4021       /* A temp section list pointer.  */
4022       asection *list;
4023     } u;
4024   } *sec_info;
4025
4026   /* Linked list of groups.  */
4027   struct map_stub *group;
4028
4029   /* Temp used when calculating TOC pointers.  */
4030   bfd_vma toc_curr;
4031   bfd *toc_bfd;
4032   asection *toc_first_sec;
4033
4034   /* Used when adding symbols.  */
4035   struct ppc_link_hash_entry *dot_syms;
4036
4037   /* Shortcuts to get to dynamic linker sections.  */
4038   asection *dynbss;
4039   asection *relbss;
4040   asection *glink;
4041   asection *sfpr;
4042   asection *brlt;
4043   asection *relbrlt;
4044   asection *glink_eh_frame;
4045
4046   /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
4047   struct ppc_link_hash_entry *tls_get_addr;
4048   struct ppc_link_hash_entry *tls_get_addr_fd;
4049
4050   /* The size of reliplt used by got entry relocs.  */
4051   bfd_size_type got_reli_size;
4052
4053   /* Statistics.  */
4054   unsigned long stub_count[ppc_stub_global_entry];
4055
4056   /* Number of stubs against global syms.  */
4057   unsigned long stub_globals;
4058
4059   /* Set if we're linking code with function descriptors.  */
4060   unsigned int opd_abi:1;
4061
4062   /* Support for multiple toc sections.  */
4063   unsigned int do_multi_toc:1;
4064   unsigned int multi_toc_needed:1;
4065   unsigned int second_toc_pass:1;
4066   unsigned int do_toc_opt:1;
4067
4068   /* Set on error.  */
4069   unsigned int stub_error:1;
4070
4071   /* Temp used by ppc64_elf_before_check_relocs.  */
4072   unsigned int twiddled_syms:1;
4073
4074   /* Incremented every time we size stubs.  */
4075   unsigned int stub_iteration;
4076
4077   /* Small local sym cache.  */
4078   struct sym_cache sym_cache;
4079 };
4080
4081 /* Rename some of the generic section flags to better document how they
4082    are used here.  */
4083
4084 /* Nonzero if this section has TLS related relocations.  */
4085 #define has_tls_reloc sec_flg0
4086
4087 /* Nonzero if this section has a call to __tls_get_addr.  */
4088 #define has_tls_get_addr_call sec_flg1
4089
4090 /* Nonzero if this section has any toc or got relocs.  */
4091 #define has_toc_reloc sec_flg2
4092
4093 /* Nonzero if this section has a call to another section that uses
4094    the toc or got.  */
4095 #define makes_toc_func_call sec_flg3
4096
4097 /* Recursion protection when determining above flag.  */
4098 #define call_check_in_progress sec_flg4
4099 #define call_check_done sec_flg5
4100
4101 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
4102
4103 #define ppc_hash_table(p) \
4104   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
4105   == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
4106
4107 #define ppc_stub_hash_lookup(table, string, create, copy) \
4108   ((struct ppc_stub_hash_entry *) \
4109    bfd_hash_lookup ((table), (string), (create), (copy)))
4110
4111 #define ppc_branch_hash_lookup(table, string, create, copy) \
4112   ((struct ppc_branch_hash_entry *) \
4113    bfd_hash_lookup ((table), (string), (create), (copy)))
4114
4115 /* Create an entry in the stub hash table.  */
4116
4117 static struct bfd_hash_entry *
4118 stub_hash_newfunc (struct bfd_hash_entry *entry,
4119                    struct bfd_hash_table *table,
4120                    const char *string)
4121 {
4122   /* Allocate the structure if it has not already been allocated by a
4123      subclass.  */
4124   if (entry == NULL)
4125     {
4126       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4127       if (entry == NULL)
4128         return entry;
4129     }
4130
4131   /* Call the allocation method of the superclass.  */
4132   entry = bfd_hash_newfunc (entry, table, string);
4133   if (entry != NULL)
4134     {
4135       struct ppc_stub_hash_entry *eh;
4136
4137       /* Initialize the local fields.  */
4138       eh = (struct ppc_stub_hash_entry *) entry;
4139       eh->stub_type = ppc_stub_none;
4140       eh->group = NULL;
4141       eh->stub_offset = 0;
4142       eh->target_value = 0;
4143       eh->target_section = NULL;
4144       eh->h = NULL;
4145       eh->plt_ent = NULL;
4146       eh->other = 0;
4147     }
4148
4149   return entry;
4150 }
4151
4152 /* Create an entry in the branch hash table.  */
4153
4154 static struct bfd_hash_entry *
4155 branch_hash_newfunc (struct bfd_hash_entry *entry,
4156                      struct bfd_hash_table *table,
4157                      const char *string)
4158 {
4159   /* Allocate the structure if it has not already been allocated by a
4160      subclass.  */
4161   if (entry == NULL)
4162     {
4163       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4164       if (entry == NULL)
4165         return entry;
4166     }
4167
4168   /* Call the allocation method of the superclass.  */
4169   entry = bfd_hash_newfunc (entry, table, string);
4170   if (entry != NULL)
4171     {
4172       struct ppc_branch_hash_entry *eh;
4173
4174       /* Initialize the local fields.  */
4175       eh = (struct ppc_branch_hash_entry *) entry;
4176       eh->offset = 0;
4177       eh->iter = 0;
4178     }
4179
4180   return entry;
4181 }
4182
4183 /* Create an entry in a ppc64 ELF linker hash table.  */
4184
4185 static struct bfd_hash_entry *
4186 link_hash_newfunc (struct bfd_hash_entry *entry,
4187                    struct bfd_hash_table *table,
4188                    const char *string)
4189 {
4190   /* Allocate the structure if it has not already been allocated by a
4191      subclass.  */
4192   if (entry == NULL)
4193     {
4194       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4195       if (entry == NULL)
4196         return entry;
4197     }
4198
4199   /* Call the allocation method of the superclass.  */
4200   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4201   if (entry != NULL)
4202     {
4203       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4204
4205       memset (&eh->u.stub_cache, 0,
4206               (sizeof (struct ppc_link_hash_entry)
4207                - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4208
4209       /* When making function calls, old ABI code references function entry
4210          points (dot symbols), while new ABI code references the function
4211          descriptor symbol.  We need to make any combination of reference and
4212          definition work together, without breaking archive linking.
4213
4214          For a defined function "foo" and an undefined call to "bar":
4215          An old object defines "foo" and ".foo", references ".bar" (possibly
4216          "bar" too).
4217          A new object defines "foo" and references "bar".
4218
4219          A new object thus has no problem with its undefined symbols being
4220          satisfied by definitions in an old object.  On the other hand, the
4221          old object won't have ".bar" satisfied by a new object.
4222
4223          Keep a list of newly added dot-symbols.  */
4224
4225       if (string[0] == '.')
4226         {
4227           struct ppc_link_hash_table *htab;
4228
4229           htab = (struct ppc_link_hash_table *) table;
4230           eh->u.next_dot_sym = htab->dot_syms;
4231           htab->dot_syms = eh;
4232         }
4233     }
4234
4235   return entry;
4236 }
4237
4238 struct tocsave_entry {
4239   asection *sec;
4240   bfd_vma offset;
4241 };
4242
4243 static hashval_t
4244 tocsave_htab_hash (const void *p)
4245 {
4246   const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4247   return ((bfd_vma)(intptr_t) e->sec ^ e->offset) >> 3;
4248 }
4249
4250 static int
4251 tocsave_htab_eq (const void *p1, const void *p2)
4252 {
4253   const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4254   const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4255   return e1->sec == e2->sec && e1->offset == e2->offset;
4256 }
4257
4258 /* Destroy a ppc64 ELF linker hash table.  */
4259
4260 static void
4261 ppc64_elf_link_hash_table_free (bfd *obfd)
4262 {
4263   struct ppc_link_hash_table *htab;
4264
4265   htab = (struct ppc_link_hash_table *) obfd->link.hash;
4266   if (htab->tocsave_htab)
4267     htab_delete (htab->tocsave_htab);
4268   bfd_hash_table_free (&htab->branch_hash_table);
4269   bfd_hash_table_free (&htab->stub_hash_table);
4270   _bfd_elf_link_hash_table_free (obfd);
4271 }
4272
4273 /* Create a ppc64 ELF linker hash table.  */
4274
4275 static struct bfd_link_hash_table *
4276 ppc64_elf_link_hash_table_create (bfd *abfd)
4277 {
4278   struct ppc_link_hash_table *htab;
4279   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4280
4281   htab = bfd_zmalloc (amt);
4282   if (htab == NULL)
4283     return NULL;
4284
4285   if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4286                                       sizeof (struct ppc_link_hash_entry),
4287                                       PPC64_ELF_DATA))
4288     {
4289       free (htab);
4290       return NULL;
4291     }
4292
4293   /* Init the stub hash table too.  */
4294   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4295                             sizeof (struct ppc_stub_hash_entry)))
4296     {
4297       _bfd_elf_link_hash_table_free (abfd);
4298       return NULL;
4299     }
4300
4301   /* And the branch hash table.  */
4302   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4303                             sizeof (struct ppc_branch_hash_entry)))
4304     {
4305       bfd_hash_table_free (&htab->stub_hash_table);
4306       _bfd_elf_link_hash_table_free (abfd);
4307       return NULL;
4308     }
4309
4310   htab->tocsave_htab = htab_try_create (1024,
4311                                         tocsave_htab_hash,
4312                                         tocsave_htab_eq,
4313                                         NULL);
4314   if (htab->tocsave_htab == NULL)
4315     {
4316       ppc64_elf_link_hash_table_free (abfd);
4317       return NULL;
4318     }
4319   htab->elf.root.hash_table_free = ppc64_elf_link_hash_table_free;
4320
4321   /* Initializing two fields of the union is just cosmetic.  We really
4322      only care about glist, but when compiled on a 32-bit host the
4323      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
4324      debugger inspection of these fields look nicer.  */
4325   htab->elf.init_got_refcount.refcount = 0;
4326   htab->elf.init_got_refcount.glist = NULL;
4327   htab->elf.init_plt_refcount.refcount = 0;
4328   htab->elf.init_plt_refcount.glist = NULL;
4329   htab->elf.init_got_offset.offset = 0;
4330   htab->elf.init_got_offset.glist = NULL;
4331   htab->elf.init_plt_offset.offset = 0;
4332   htab->elf.init_plt_offset.glist = NULL;
4333
4334   return &htab->elf.root;
4335 }
4336
4337 /* Create sections for linker generated code.  */
4338
4339 static bfd_boolean
4340 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4341 {
4342   struct ppc_link_hash_table *htab;
4343   flagword flags;
4344
4345   htab = ppc_hash_table (info);
4346
4347   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4348            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4349   if (htab->params->save_restore_funcs)
4350     {
4351       /* Create .sfpr for code to save and restore fp regs.  */
4352       htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4353                                                        flags);
4354       if (htab->sfpr == NULL
4355           || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4356         return FALSE;
4357     }
4358
4359   if (bfd_link_relocatable (info))
4360     return TRUE;
4361
4362   /* Create .glink for lazy dynamic linking support.  */
4363   htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4364                                                     flags);
4365   if (htab->glink == NULL
4366       || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4367     return FALSE;
4368
4369   if (!info->no_ld_generated_unwind_info)
4370     {
4371       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4372                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4373       htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4374                                                                  ".eh_frame",
4375                                                                  flags);
4376       if (htab->glink_eh_frame == NULL
4377           || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4378         return FALSE;
4379     }
4380
4381   flags = SEC_ALLOC | SEC_LINKER_CREATED;
4382   htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4383   if (htab->elf.iplt == NULL
4384       || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4385     return FALSE;
4386
4387   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4388            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4389   htab->elf.irelplt
4390     = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4391   if (htab->elf.irelplt == NULL
4392       || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4393     return FALSE;
4394
4395   /* Create branch lookup table for plt_branch stubs.  */
4396   flags = (SEC_ALLOC | SEC_LOAD
4397            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4398   htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4399                                                    flags);
4400   if (htab->brlt == NULL
4401       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4402     return FALSE;
4403
4404   if (!bfd_link_pic (info))
4405     return TRUE;
4406
4407   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4408            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4409   htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4410                                                       ".rela.branch_lt",
4411                                                       flags);
4412   if (htab->relbrlt == NULL
4413       || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4414     return FALSE;
4415
4416   return TRUE;
4417 }
4418
4419 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
4420
4421 bfd_boolean
4422 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4423                          struct ppc64_elf_params *params)
4424 {
4425   struct ppc_link_hash_table *htab;
4426
4427   elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4428
4429 /* Always hook our dynamic sections into the first bfd, which is the
4430    linker created stub bfd.  This ensures that the GOT header is at
4431    the start of the output TOC section.  */
4432   htab = ppc_hash_table (info);
4433   htab->elf.dynobj = params->stub_bfd;
4434   htab->params = params;
4435
4436   return create_linkage_sections (htab->elf.dynobj, info);
4437 }
4438
4439 /* Build a name for an entry in the stub hash table.  */
4440
4441 static char *
4442 ppc_stub_name (const asection *input_section,
4443                const asection *sym_sec,
4444                const struct ppc_link_hash_entry *h,
4445                const Elf_Internal_Rela *rel)
4446 {
4447   char *stub_name;
4448   ssize_t len;
4449
4450   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4451      offsets from a sym as a branch target?  In fact, we could
4452      probably assume the addend is always zero.  */
4453   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4454
4455   if (h)
4456     {
4457       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4458       stub_name = bfd_malloc (len);
4459       if (stub_name == NULL)
4460         return stub_name;
4461
4462       len = sprintf (stub_name, "%08x.%s+%x",
4463                      input_section->id & 0xffffffff,
4464                      h->elf.root.root.string,
4465                      (int) rel->r_addend & 0xffffffff);
4466     }
4467   else
4468     {
4469       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4470       stub_name = bfd_malloc (len);
4471       if (stub_name == NULL)
4472         return stub_name;
4473
4474       len = sprintf (stub_name, "%08x.%x:%x+%x",
4475                      input_section->id & 0xffffffff,
4476                      sym_sec->id & 0xffffffff,
4477                      (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4478                      (int) rel->r_addend & 0xffffffff);
4479     }
4480   if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4481     stub_name[len - 2] = 0;
4482   return stub_name;
4483 }
4484
4485 /* Look up an entry in the stub hash.  Stub entries are cached because
4486    creating the stub name takes a bit of time.  */
4487
4488 static struct ppc_stub_hash_entry *
4489 ppc_get_stub_entry (const asection *input_section,
4490                     const asection *sym_sec,
4491                     struct ppc_link_hash_entry *h,
4492                     const Elf_Internal_Rela *rel,
4493                     struct ppc_link_hash_table *htab)
4494 {
4495   struct ppc_stub_hash_entry *stub_entry;
4496   struct map_stub *group;
4497
4498   /* If this input section is part of a group of sections sharing one
4499      stub section, then use the id of the first section in the group.
4500      Stub names need to include a section id, as there may well be
4501      more than one stub used to reach say, printf, and we need to
4502      distinguish between them.  */
4503   group = htab->sec_info[input_section->id].u.group;
4504
4505   if (h != NULL && h->u.stub_cache != NULL
4506       && h->u.stub_cache->h == h
4507       && h->u.stub_cache->group == group)
4508     {
4509       stub_entry = h->u.stub_cache;
4510     }
4511   else
4512     {
4513       char *stub_name;
4514
4515       stub_name = ppc_stub_name (group->link_sec, sym_sec, h, rel);
4516       if (stub_name == NULL)
4517         return NULL;
4518
4519       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4520                                          stub_name, FALSE, FALSE);
4521       if (h != NULL)
4522         h->u.stub_cache = stub_entry;
4523
4524       free (stub_name);
4525     }
4526
4527   return stub_entry;
4528 }
4529
4530 /* Add a new stub entry to the stub hash.  Not all fields of the new
4531    stub entry are initialised.  */
4532
4533 static struct ppc_stub_hash_entry *
4534 ppc_add_stub (const char *stub_name,
4535               asection *section,
4536               struct bfd_link_info *info)
4537 {
4538   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4539   struct map_stub *group;
4540   asection *link_sec;
4541   asection *stub_sec;
4542   struct ppc_stub_hash_entry *stub_entry;
4543
4544   group = htab->sec_info[section->id].u.group;
4545   link_sec = group->link_sec;
4546   stub_sec = group->stub_sec;
4547   if (stub_sec == NULL)
4548     {
4549       size_t namelen;
4550       bfd_size_type len;
4551       char *s_name;
4552
4553       namelen = strlen (link_sec->name);
4554       len = namelen + sizeof (STUB_SUFFIX);
4555       s_name = bfd_alloc (htab->params->stub_bfd, len);
4556       if (s_name == NULL)
4557         return NULL;
4558
4559       memcpy (s_name, link_sec->name, namelen);
4560       memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4561       stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4562       if (stub_sec == NULL)
4563         return NULL;
4564       group->stub_sec = stub_sec;
4565     }
4566
4567   /* Enter this entry into the linker stub hash table.  */
4568   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4569                                      TRUE, FALSE);
4570   if (stub_entry == NULL)
4571     {
4572       info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4573                               section->owner, stub_name);
4574       return NULL;
4575     }
4576
4577   stub_entry->group = group;
4578   stub_entry->stub_offset = 0;
4579   return stub_entry;
4580 }
4581
4582 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4583    not already done.  */
4584
4585 static bfd_boolean
4586 create_got_section (bfd *abfd, struct bfd_link_info *info)
4587 {
4588   asection *got, *relgot;
4589   flagword flags;
4590   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4591
4592   if (!is_ppc64_elf (abfd))
4593     return FALSE;
4594   if (htab == NULL)
4595     return FALSE;
4596
4597   if (!htab->elf.sgot
4598       && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4599     return FALSE;
4600
4601   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4602            | SEC_LINKER_CREATED);
4603
4604   got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4605   if (!got
4606       || !bfd_set_section_alignment (abfd, got, 3))
4607     return FALSE;
4608
4609   relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4610                                                flags | SEC_READONLY);
4611   if (!relgot
4612       || ! bfd_set_section_alignment (abfd, relgot, 3))
4613     return FALSE;
4614
4615   ppc64_elf_tdata (abfd)->got = got;
4616   ppc64_elf_tdata (abfd)->relgot = relgot;
4617   return TRUE;
4618 }
4619
4620 /* Create the dynamic sections, and set up shortcuts.  */
4621
4622 static bfd_boolean
4623 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4624 {
4625   struct ppc_link_hash_table *htab;
4626
4627   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4628     return FALSE;
4629
4630   htab = ppc_hash_table (info);
4631   if (htab == NULL)
4632     return FALSE;
4633
4634   htab->dynbss = bfd_get_linker_section (dynobj, ".dynbss");
4635   if (!bfd_link_pic (info))
4636     htab->relbss = bfd_get_linker_section (dynobj, ".rela.bss");
4637
4638   if (!htab->elf.sgot || !htab->elf.splt || !htab->elf.srelplt || !htab->dynbss
4639       || (!bfd_link_pic (info) && !htab->relbss))
4640     abort ();
4641
4642   return TRUE;
4643 }
4644
4645 /* Follow indirect and warning symbol links.  */
4646
4647 static inline struct bfd_link_hash_entry *
4648 follow_link (struct bfd_link_hash_entry *h)
4649 {
4650   while (h->type == bfd_link_hash_indirect
4651          || h->type == bfd_link_hash_warning)
4652     h = h->u.i.link;
4653   return h;
4654 }
4655
4656 static inline struct elf_link_hash_entry *
4657 elf_follow_link (struct elf_link_hash_entry *h)
4658 {
4659   return (struct elf_link_hash_entry *) follow_link (&h->root);
4660 }
4661
4662 static inline struct ppc_link_hash_entry *
4663 ppc_follow_link (struct ppc_link_hash_entry *h)
4664 {
4665   return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4666 }
4667
4668 /* Merge PLT info on FROM with that on TO.  */
4669
4670 static void
4671 move_plt_plist (struct ppc_link_hash_entry *from,
4672                 struct ppc_link_hash_entry *to)
4673 {
4674   if (from->elf.plt.plist != NULL)
4675     {
4676       if (to->elf.plt.plist != NULL)
4677         {
4678           struct plt_entry **entp;
4679           struct plt_entry *ent;
4680
4681           for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4682             {
4683               struct plt_entry *dent;
4684
4685               for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4686                 if (dent->addend == ent->addend)
4687                   {
4688                     dent->plt.refcount += ent->plt.refcount;
4689                     *entp = ent->next;
4690                     break;
4691                   }
4692               if (dent == NULL)
4693                 entp = &ent->next;
4694             }
4695           *entp = to->elf.plt.plist;
4696         }
4697
4698       to->elf.plt.plist = from->elf.plt.plist;
4699       from->elf.plt.plist = NULL;
4700     }
4701 }
4702
4703 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
4704
4705 static void
4706 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4707                                 struct elf_link_hash_entry *dir,
4708                                 struct elf_link_hash_entry *ind)
4709 {
4710   struct ppc_link_hash_entry *edir, *eind;
4711
4712   edir = (struct ppc_link_hash_entry *) dir;
4713   eind = (struct ppc_link_hash_entry *) ind;
4714
4715   edir->is_func |= eind->is_func;
4716   edir->is_func_descriptor |= eind->is_func_descriptor;
4717   edir->tls_mask |= eind->tls_mask;
4718   if (eind->oh != NULL)
4719     edir->oh = ppc_follow_link (eind->oh);
4720
4721   /* If called to transfer flags for a weakdef during processing
4722      of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4723      We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
4724   if (!(ELIMINATE_COPY_RELOCS
4725         && eind->elf.root.type != bfd_link_hash_indirect
4726         && edir->elf.dynamic_adjusted))
4727     edir->elf.non_got_ref |= eind->elf.non_got_ref;
4728
4729   edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4730   edir->elf.ref_regular |= eind->elf.ref_regular;
4731   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4732   edir->elf.needs_plt |= eind->elf.needs_plt;
4733   edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4734
4735   /* Copy over any dynamic relocs we may have on the indirect sym.  */
4736   if (eind->dyn_relocs != NULL)
4737     {
4738       if (edir->dyn_relocs != NULL)
4739         {
4740           struct elf_dyn_relocs **pp;
4741           struct elf_dyn_relocs *p;
4742
4743           /* Add reloc counts against the indirect sym to the direct sym
4744              list.  Merge any entries against the same section.  */
4745           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4746             {
4747               struct elf_dyn_relocs *q;
4748
4749               for (q = edir->dyn_relocs; q != NULL; q = q->next)
4750                 if (q->sec == p->sec)
4751                   {
4752                     q->pc_count += p->pc_count;
4753                     q->count += p->count;
4754                     *pp = p->next;
4755                     break;
4756                   }
4757               if (q == NULL)
4758                 pp = &p->next;
4759             }
4760           *pp = edir->dyn_relocs;
4761         }
4762
4763       edir->dyn_relocs = eind->dyn_relocs;
4764       eind->dyn_relocs = NULL;
4765     }
4766
4767   /* If we were called to copy over info for a weak sym, that's all.
4768      You might think dyn_relocs need not be copied over;  After all,
4769      both syms will be dynamic or both non-dynamic so we're just
4770      moving reloc accounting around.  However, ELIMINATE_COPY_RELOCS
4771      code in ppc64_elf_adjust_dynamic_symbol needs to check for
4772      dyn_relocs in read-only sections, and it does so on what is the
4773      DIR sym here.  */
4774   if (eind->elf.root.type != bfd_link_hash_indirect)
4775     return;
4776
4777   /* Copy over got entries that we may have already seen to the
4778      symbol which just became indirect.  */
4779   if (eind->elf.got.glist != NULL)
4780     {
4781       if (edir->elf.got.glist != NULL)
4782         {
4783           struct got_entry **entp;
4784           struct got_entry *ent;
4785
4786           for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4787             {
4788               struct got_entry *dent;
4789
4790               for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4791                 if (dent->addend == ent->addend
4792                     && dent->owner == ent->owner
4793                     && dent->tls_type == ent->tls_type)
4794                   {
4795                     dent->got.refcount += ent->got.refcount;
4796                     *entp = ent->next;
4797                     break;
4798                   }
4799               if (dent == NULL)
4800                 entp = &ent->next;
4801             }
4802           *entp = edir->elf.got.glist;
4803         }
4804
4805       edir->elf.got.glist = eind->elf.got.glist;
4806       eind->elf.got.glist = NULL;
4807     }
4808
4809   /* And plt entries.  */
4810   move_plt_plist (eind, edir);
4811
4812   if (eind->elf.dynindx != -1)
4813     {
4814       if (edir->elf.dynindx != -1)
4815         _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4816                                 edir->elf.dynstr_index);
4817       edir->elf.dynindx = eind->elf.dynindx;
4818       edir->elf.dynstr_index = eind->elf.dynstr_index;
4819       eind->elf.dynindx = -1;
4820       eind->elf.dynstr_index = 0;
4821     }
4822 }
4823
4824 /* Find the function descriptor hash entry from the given function code
4825    hash entry FH.  Link the entries via their OH fields.  */
4826
4827 static struct ppc_link_hash_entry *
4828 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4829 {
4830   struct ppc_link_hash_entry *fdh = fh->oh;
4831
4832   if (fdh == NULL)
4833     {
4834       const char *fd_name = fh->elf.root.root.string + 1;
4835
4836       fdh = (struct ppc_link_hash_entry *)
4837         elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4838       if (fdh == NULL)
4839         return fdh;
4840
4841       fdh->is_func_descriptor = 1;
4842       fdh->oh = fh;
4843       fh->is_func = 1;
4844       fh->oh = fdh;
4845     }
4846
4847   return ppc_follow_link (fdh);
4848 }
4849
4850 /* Make a fake function descriptor sym for the code sym FH.  */
4851
4852 static struct ppc_link_hash_entry *
4853 make_fdh (struct bfd_link_info *info,
4854           struct ppc_link_hash_entry *fh)
4855 {
4856   bfd *abfd;
4857   asymbol *newsym;
4858   struct bfd_link_hash_entry *bh;
4859   struct ppc_link_hash_entry *fdh;
4860
4861   abfd = fh->elf.root.u.undef.abfd;
4862   newsym = bfd_make_empty_symbol (abfd);
4863   newsym->name = fh->elf.root.root.string + 1;
4864   newsym->section = bfd_und_section_ptr;
4865   newsym->value = 0;
4866   newsym->flags = BSF_WEAK;
4867
4868   bh = NULL;
4869   if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4870                                          newsym->flags, newsym->section,
4871                                          newsym->value, NULL, FALSE, FALSE,
4872                                          &bh))
4873     return NULL;
4874
4875   fdh = (struct ppc_link_hash_entry *) bh;
4876   fdh->elf.non_elf = 0;
4877   fdh->fake = 1;
4878   fdh->is_func_descriptor = 1;
4879   fdh->oh = fh;
4880   fh->is_func = 1;
4881   fh->oh = fdh;
4882   return fdh;
4883 }
4884
4885 /* Fix function descriptor symbols defined in .opd sections to be
4886    function type.  */
4887
4888 static bfd_boolean
4889 ppc64_elf_add_symbol_hook (bfd *ibfd,
4890                            struct bfd_link_info *info,
4891                            Elf_Internal_Sym *isym,
4892                            const char **name,
4893                            flagword *flags ATTRIBUTE_UNUSED,
4894                            asection **sec,
4895                            bfd_vma *value)
4896 {
4897   if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4898       && (ibfd->flags & DYNAMIC) == 0
4899       && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
4900     elf_tdata (info->output_bfd)->has_gnu_symbols |= elf_gnu_symbol_ifunc;
4901
4902   if (*sec != NULL
4903       && strcmp ((*sec)->name, ".opd") == 0)
4904     {
4905       asection *code_sec;
4906
4907       if (!(ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4908             || ELF_ST_TYPE (isym->st_info) == STT_FUNC))
4909         isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4910
4911       /* If the symbol is a function defined in .opd, and the function
4912          code is in a discarded group, let it appear to be undefined.  */
4913       if (!bfd_link_relocatable (info)
4914           && (*sec)->reloc_count != 0
4915           && opd_entry_value (*sec, *value, &code_sec, NULL,
4916                               FALSE) != (bfd_vma) -1
4917           && discarded_section (code_sec))
4918         {
4919           *sec = bfd_und_section_ptr;
4920           isym->st_shndx = SHN_UNDEF;
4921         }
4922     }
4923   else if (*sec != NULL
4924            && strcmp ((*sec)->name, ".toc") == 0
4925            && ELF_ST_TYPE (isym->st_info) == STT_OBJECT)
4926     {
4927       struct ppc_link_hash_table *htab = ppc_hash_table (info);
4928       if (htab != NULL)
4929         htab->params->object_in_toc = 1;
4930     }
4931
4932   if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4933     {
4934       if (abiversion (ibfd) == 0)
4935         set_abiversion (ibfd, 2);
4936       else if (abiversion (ibfd) == 1)
4937         {
4938           info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other"
4939                                     " for ABI version 1\n"), name);
4940           bfd_set_error (bfd_error_bad_value);
4941           return FALSE;
4942         }
4943     }
4944
4945   return TRUE;
4946 }
4947
4948 /* Merge non-visibility st_other attributes: local entry point.  */
4949
4950 static void
4951 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
4952                                   const Elf_Internal_Sym *isym,
4953                                   bfd_boolean definition,
4954                                   bfd_boolean dynamic)
4955 {
4956   if (definition && !dynamic)
4957     h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
4958                 | ELF_ST_VISIBILITY (h->other));
4959 }
4960
4961 /* This function makes an old ABI object reference to ".bar" cause the
4962    inclusion of a new ABI object archive that defines "bar".
4963    NAME is a symbol defined in an archive.  Return a symbol in the hash
4964    table that might be satisfied by the archive symbols.  */
4965
4966 static struct elf_link_hash_entry *
4967 ppc64_elf_archive_symbol_lookup (bfd *abfd,
4968                                  struct bfd_link_info *info,
4969                                  const char *name)
4970 {
4971   struct elf_link_hash_entry *h;
4972   char *dot_name;
4973   size_t len;
4974
4975   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4976   if (h != NULL
4977       /* Don't return this sym if it is a fake function descriptor
4978          created by add_symbol_adjust.  */
4979       && !(h->root.type == bfd_link_hash_undefweak
4980            && ((struct ppc_link_hash_entry *) h)->fake))
4981     return h;
4982
4983   if (name[0] == '.')
4984     return h;
4985
4986   len = strlen (name);
4987   dot_name = bfd_alloc (abfd, len + 2);
4988   if (dot_name == NULL)
4989     return (struct elf_link_hash_entry *) 0 - 1;
4990   dot_name[0] = '.';
4991   memcpy (dot_name + 1, name, len + 1);
4992   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4993   bfd_release (abfd, dot_name);
4994   return h;
4995 }
4996
4997 /* This function satisfies all old ABI object references to ".bar" if a
4998    new ABI object defines "bar".  Well, at least, undefined dot symbols
4999    are made weak.  This stops later archive searches from including an
5000    object if we already have a function descriptor definition.  It also
5001    prevents the linker complaining about undefined symbols.
5002    We also check and correct mismatched symbol visibility here.  The
5003    most restrictive visibility of the function descriptor and the
5004    function entry symbol is used.  */
5005
5006 static bfd_boolean
5007 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
5008 {
5009   struct ppc_link_hash_table *htab;
5010   struct ppc_link_hash_entry *fdh;
5011
5012   if (eh->elf.root.type == bfd_link_hash_indirect)
5013     return TRUE;
5014
5015   if (eh->elf.root.type == bfd_link_hash_warning)
5016     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
5017
5018   if (eh->elf.root.root.string[0] != '.')
5019     abort ();
5020
5021   htab = ppc_hash_table (info);
5022   if (htab == NULL)
5023     return FALSE;
5024
5025   fdh = lookup_fdh (eh, htab);
5026   if (fdh == NULL)
5027     {
5028       if (!bfd_link_relocatable (info)
5029           && (eh->elf.root.type == bfd_link_hash_undefined
5030               || eh->elf.root.type == bfd_link_hash_undefweak)
5031           && eh->elf.ref_regular)
5032         {
5033           /* Make an undefweak function descriptor sym, which is enough to
5034              pull in an --as-needed shared lib, but won't cause link
5035              errors.  Archives are handled elsewhere.  */
5036           fdh = make_fdh (info, eh);
5037           if (fdh == NULL)
5038             return FALSE;
5039           fdh->elf.ref_regular = 1;
5040         }
5041     }
5042   else
5043     {
5044       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
5045       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
5046       if (entry_vis < descr_vis)
5047         fdh->elf.other += entry_vis - descr_vis;
5048       else if (entry_vis > descr_vis)
5049         eh->elf.other += descr_vis - entry_vis;
5050
5051       if ((fdh->elf.root.type == bfd_link_hash_defined
5052            || fdh->elf.root.type == bfd_link_hash_defweak)
5053           && eh->elf.root.type == bfd_link_hash_undefined)
5054         {
5055           eh->elf.root.type = bfd_link_hash_undefweak;
5056           eh->was_undefined = 1;
5057           htab->twiddled_syms = 1;
5058         }
5059     }
5060
5061   return TRUE;
5062 }
5063
5064 /* Set up opd section info and abiversion for IBFD, and process list
5065    of dot-symbols we made in link_hash_newfunc.  */
5066
5067 static bfd_boolean
5068 ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
5069 {
5070   struct ppc_link_hash_table *htab;
5071   struct ppc_link_hash_entry **p, *eh;
5072   asection *opd = bfd_get_section_by_name (ibfd, ".opd");
5073
5074   if (opd != NULL && opd->size != 0)
5075     {
5076       if (abiversion (ibfd) == 0)
5077         set_abiversion (ibfd, 1);
5078       else if (abiversion (ibfd) == 2)
5079         {
5080           info->callbacks->einfo (_("%P: %B .opd not allowed in ABI"
5081                                     " version %d\n"),
5082                                   ibfd, abiversion (ibfd));
5083           bfd_set_error (bfd_error_bad_value);
5084           return FALSE;
5085         }
5086
5087       if ((ibfd->flags & DYNAMIC) == 0
5088           && (opd->flags & SEC_RELOC) != 0
5089           && opd->reloc_count != 0
5090           && !bfd_is_abs_section (opd->output_section))
5091         {
5092           /* Garbage collection needs some extra help with .opd sections.
5093              We don't want to necessarily keep everything referenced by
5094              relocs in .opd, as that would keep all functions.  Instead,
5095              if we reference an .opd symbol (a function descriptor), we
5096              want to keep the function code symbol's section.  This is
5097              easy for global symbols, but for local syms we need to keep
5098              information about the associated function section.  */
5099           bfd_size_type amt;
5100           asection **opd_sym_map;
5101
5102           amt = OPD_NDX (opd->size) * sizeof (*opd_sym_map);
5103           opd_sym_map = bfd_zalloc (ibfd, amt);
5104           if (opd_sym_map == NULL)
5105             return FALSE;
5106           ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
5107           BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
5108           ppc64_elf_section_data (opd)->sec_type = sec_opd;
5109         }
5110     }
5111
5112   if (!is_ppc64_elf (info->output_bfd))
5113     return TRUE;
5114   htab = ppc_hash_table (info);
5115   if (htab == NULL)
5116     return FALSE;
5117
5118   /* For input files without an explicit abiversion in e_flags
5119      we should have flagged any with symbol st_other bits set
5120      as ELFv1 and above flagged those with .opd as ELFv2.
5121      Set the output abiversion if not yet set, and for any input
5122      still ambiguous, take its abiversion from the output.
5123      Differences in ABI are reported later.  */
5124   if (abiversion (info->output_bfd) == 0)
5125     set_abiversion (info->output_bfd, abiversion (ibfd));
5126   else if (abiversion (ibfd) == 0)
5127     set_abiversion (ibfd, abiversion (info->output_bfd));
5128
5129   p = &htab->dot_syms;
5130   while ((eh = *p) != NULL)
5131     {
5132       *p = NULL;
5133       if (&eh->elf == htab->elf.hgot)
5134         ;
5135       else if (htab->elf.hgot == NULL
5136                && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
5137         htab->elf.hgot = &eh->elf;
5138       else if (!add_symbol_adjust (eh, info))
5139         return FALSE;
5140       p = &eh->u.next_dot_sym;
5141     }
5142
5143   /* Clear the list for non-ppc64 input files.  */
5144   p = &htab->dot_syms;
5145   while ((eh = *p) != NULL)
5146     {
5147       *p = NULL;
5148       p = &eh->u.next_dot_sym;
5149     }
5150
5151   /* We need to fix the undefs list for any syms we have twiddled to
5152      undef_weak.  */
5153   if (htab->twiddled_syms)
5154     {
5155       bfd_link_repair_undef_list (&htab->elf.root);
5156       htab->twiddled_syms = 0;
5157     }
5158   return TRUE;
5159 }
5160
5161 /* Undo hash table changes when an --as-needed input file is determined
5162    not to be needed.  */
5163
5164 static bfd_boolean
5165 ppc64_elf_notice_as_needed (bfd *ibfd,
5166                             struct bfd_link_info *info,
5167                             enum notice_asneeded_action act)
5168 {
5169   if (act == notice_not_needed)
5170     {
5171       struct ppc_link_hash_table *htab = ppc_hash_table (info);
5172
5173       if (htab == NULL)
5174         return FALSE;
5175
5176       htab->dot_syms = NULL;
5177     }
5178   return _bfd_elf_notice_as_needed (ibfd, info, act);
5179 }
5180
5181 /* If --just-symbols against a final linked binary, then assume we need
5182    toc adjusting stubs when calling functions defined there.  */
5183
5184 static void
5185 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5186 {
5187   if ((sec->flags & SEC_CODE) != 0
5188       && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5189       && is_ppc64_elf (sec->owner))
5190     {
5191       if (abiversion (sec->owner) >= 2
5192           || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5193         sec->has_toc_reloc = 1;
5194     }
5195   _bfd_elf_link_just_syms (sec, info);
5196 }
5197
5198 static struct plt_entry **
5199 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5200                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5201 {
5202   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5203   struct plt_entry **local_plt;
5204   unsigned char *local_got_tls_masks;
5205
5206   if (local_got_ents == NULL)
5207     {
5208       bfd_size_type size = symtab_hdr->sh_info;
5209
5210       size *= (sizeof (*local_got_ents)
5211                + sizeof (*local_plt)
5212                + sizeof (*local_got_tls_masks));
5213       local_got_ents = bfd_zalloc (abfd, size);
5214       if (local_got_ents == NULL)
5215         return NULL;
5216       elf_local_got_ents (abfd) = local_got_ents;
5217     }
5218
5219   if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
5220     {
5221       struct got_entry *ent;
5222
5223       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5224         if (ent->addend == r_addend
5225             && ent->owner == abfd
5226             && ent->tls_type == tls_type)
5227           break;
5228       if (ent == NULL)
5229         {
5230           bfd_size_type amt = sizeof (*ent);
5231           ent = bfd_alloc (abfd, amt);
5232           if (ent == NULL)
5233             return FALSE;
5234           ent->next = local_got_ents[r_symndx];
5235           ent->addend = r_addend;
5236           ent->owner = abfd;
5237           ent->tls_type = tls_type;
5238           ent->is_indirect = FALSE;
5239           ent->got.refcount = 0;
5240           local_got_ents[r_symndx] = ent;
5241         }
5242       ent->got.refcount += 1;
5243     }
5244
5245   local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5246   local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5247   local_got_tls_masks[r_symndx] |= tls_type;
5248
5249   return local_plt + r_symndx;
5250 }
5251
5252 static bfd_boolean
5253 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5254 {
5255   struct plt_entry *ent;
5256
5257   for (ent = *plist; ent != NULL; ent = ent->next)
5258     if (ent->addend == addend)
5259       break;
5260   if (ent == NULL)
5261     {
5262       bfd_size_type amt = sizeof (*ent);
5263       ent = bfd_alloc (abfd, amt);
5264       if (ent == NULL)
5265         return FALSE;
5266       ent->next = *plist;
5267       ent->addend = addend;
5268       ent->plt.refcount = 0;
5269       *plist = ent;
5270     }
5271   ent->plt.refcount += 1;
5272   return TRUE;
5273 }
5274
5275 static bfd_boolean
5276 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5277 {
5278   return (r_type == R_PPC64_REL24
5279           || r_type == R_PPC64_REL14
5280           || r_type == R_PPC64_REL14_BRTAKEN
5281           || r_type == R_PPC64_REL14_BRNTAKEN
5282           || r_type == R_PPC64_ADDR24
5283           || r_type == R_PPC64_ADDR14
5284           || r_type == R_PPC64_ADDR14_BRTAKEN
5285           || r_type == R_PPC64_ADDR14_BRNTAKEN);
5286 }
5287
5288 /* Look through the relocs for a section during the first phase, and
5289    calculate needed space in the global offset table, procedure
5290    linkage table, and dynamic reloc sections.  */
5291
5292 static bfd_boolean
5293 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5294                         asection *sec, const Elf_Internal_Rela *relocs)
5295 {
5296   struct ppc_link_hash_table *htab;
5297   Elf_Internal_Shdr *symtab_hdr;
5298   struct elf_link_hash_entry **sym_hashes;
5299   const Elf_Internal_Rela *rel;
5300   const Elf_Internal_Rela *rel_end;
5301   asection *sreloc;
5302   asection **opd_sym_map;
5303   struct elf_link_hash_entry *tga, *dottga;
5304
5305   if (bfd_link_relocatable (info))
5306     return TRUE;
5307
5308   /* Don't do anything special with non-loaded, non-alloced sections.
5309      In particular, any relocs in such sections should not affect GOT
5310      and PLT reference counting (ie. we don't allow them to create GOT
5311      or PLT entries), there's no possibility or desire to optimize TLS
5312      relocs, and there's not much point in propagating relocs to shared
5313      libs that the dynamic linker won't relocate.  */
5314   if ((sec->flags & SEC_ALLOC) == 0)
5315     return TRUE;
5316
5317   BFD_ASSERT (is_ppc64_elf (abfd));
5318
5319   htab = ppc_hash_table (info);
5320   if (htab == NULL)
5321     return FALSE;
5322
5323   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5324                               FALSE, FALSE, TRUE);
5325   dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5326                                  FALSE, FALSE, TRUE);
5327   symtab_hdr = &elf_symtab_hdr (abfd);
5328   sym_hashes = elf_sym_hashes (abfd);
5329   sreloc = NULL;
5330   opd_sym_map = NULL;
5331   if (ppc64_elf_section_data (sec) != NULL
5332       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
5333     opd_sym_map = ppc64_elf_section_data (sec)->u.opd.func_sec;
5334
5335   rel_end = relocs + sec->reloc_count;
5336   for (rel = relocs; rel < rel_end; rel++)
5337     {
5338       unsigned long r_symndx;
5339       struct elf_link_hash_entry *h;
5340       enum elf_ppc64_reloc_type r_type;
5341       int tls_type;
5342       struct _ppc64_elf_section_data *ppc64_sec;
5343       struct plt_entry **ifunc, **plt_list;
5344
5345       r_symndx = ELF64_R_SYM (rel->r_info);
5346       if (r_symndx < symtab_hdr->sh_info)
5347         h = NULL;
5348       else
5349         {
5350           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5351           h = elf_follow_link (h);
5352
5353           /* PR15323, ref flags aren't set for references in the same
5354              object.  */
5355           h->root.non_ir_ref = 1;
5356
5357           if (h == htab->elf.hgot)
5358             sec->has_toc_reloc = 1;
5359         }
5360
5361       tls_type = 0;
5362       ifunc = NULL;
5363       if (h != NULL)
5364         {
5365           if (h->type == STT_GNU_IFUNC)
5366             {
5367               h->needs_plt = 1;
5368               ifunc = &h->plt.plist;
5369             }
5370         }
5371       else
5372         {
5373           Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5374                                                           abfd, r_symndx);
5375           if (isym == NULL)
5376             return FALSE;
5377
5378           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5379             {
5380               ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5381                                              rel->r_addend, PLT_IFUNC);
5382               if (ifunc == NULL)
5383                 return FALSE;
5384             }
5385         }
5386
5387       r_type = ELF64_R_TYPE (rel->r_info);
5388       switch (r_type)
5389         {
5390         case R_PPC64_TLSGD:
5391         case R_PPC64_TLSLD:
5392           /* These special tls relocs tie a call to __tls_get_addr with
5393              its parameter symbol.  */
5394           break;
5395
5396         case R_PPC64_GOT_TLSLD16:
5397         case R_PPC64_GOT_TLSLD16_LO:
5398         case R_PPC64_GOT_TLSLD16_HI:
5399         case R_PPC64_GOT_TLSLD16_HA:
5400           tls_type = TLS_TLS | TLS_LD;
5401           goto dogottls;
5402
5403         case R_PPC64_GOT_TLSGD16:
5404         case R_PPC64_GOT_TLSGD16_LO:
5405         case R_PPC64_GOT_TLSGD16_HI:
5406         case R_PPC64_GOT_TLSGD16_HA:
5407           tls_type = TLS_TLS | TLS_GD;
5408           goto dogottls;
5409
5410         case R_PPC64_GOT_TPREL16_DS:
5411         case R_PPC64_GOT_TPREL16_LO_DS:
5412         case R_PPC64_GOT_TPREL16_HI:
5413         case R_PPC64_GOT_TPREL16_HA:
5414           if (bfd_link_pic (info))
5415             info->flags |= DF_STATIC_TLS;
5416           tls_type = TLS_TLS | TLS_TPREL;
5417           goto dogottls;
5418
5419         case R_PPC64_GOT_DTPREL16_DS:
5420         case R_PPC64_GOT_DTPREL16_LO_DS:
5421         case R_PPC64_GOT_DTPREL16_HI:
5422         case R_PPC64_GOT_DTPREL16_HA:
5423           tls_type = TLS_TLS | TLS_DTPREL;
5424         dogottls:
5425           sec->has_tls_reloc = 1;
5426           /* Fall thru */
5427
5428         case R_PPC64_GOT16:
5429         case R_PPC64_GOT16_DS:
5430         case R_PPC64_GOT16_HA:
5431         case R_PPC64_GOT16_HI:
5432         case R_PPC64_GOT16_LO:
5433         case R_PPC64_GOT16_LO_DS:
5434           /* This symbol requires a global offset table entry.  */
5435           sec->has_toc_reloc = 1;
5436           if (r_type == R_PPC64_GOT_TLSLD16
5437               || r_type == R_PPC64_GOT_TLSGD16
5438               || r_type == R_PPC64_GOT_TPREL16_DS
5439               || r_type == R_PPC64_GOT_DTPREL16_DS
5440               || r_type == R_PPC64_GOT16
5441               || r_type == R_PPC64_GOT16_DS)
5442             {
5443               htab->do_multi_toc = 1;
5444               ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5445             }
5446
5447           if (ppc64_elf_tdata (abfd)->got == NULL
5448               && !create_got_section (abfd, info))
5449             return FALSE;
5450
5451           if (h != NULL)
5452             {
5453               struct ppc_link_hash_entry *eh;
5454               struct got_entry *ent;
5455
5456               eh = (struct ppc_link_hash_entry *) h;
5457               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5458                 if (ent->addend == rel->r_addend
5459                     && ent->owner == abfd
5460                     && ent->tls_type == tls_type)
5461                   break;
5462               if (ent == NULL)
5463                 {
5464                   bfd_size_type amt = sizeof (*ent);
5465                   ent = bfd_alloc (abfd, amt);
5466                   if (ent == NULL)
5467                     return FALSE;
5468                   ent->next = eh->elf.got.glist;
5469                   ent->addend = rel->r_addend;
5470                   ent->owner = abfd;
5471                   ent->tls_type = tls_type;
5472                   ent->is_indirect = FALSE;
5473                   ent->got.refcount = 0;
5474                   eh->elf.got.glist = ent;
5475                 }
5476               ent->got.refcount += 1;
5477               eh->tls_mask |= tls_type;
5478             }
5479           else
5480             /* This is a global offset table entry for a local symbol.  */
5481             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5482                                         rel->r_addend, tls_type))
5483               return FALSE;
5484
5485           /* We may also need a plt entry if the symbol turns out to be
5486              an ifunc.  */
5487           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1)
5488             {
5489               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5490                 return FALSE;
5491             }
5492           break;
5493
5494         case R_PPC64_PLT16_HA:
5495         case R_PPC64_PLT16_HI:
5496         case R_PPC64_PLT16_LO:
5497         case R_PPC64_PLT32:
5498         case R_PPC64_PLT64:
5499           /* This symbol requires a procedure linkage table entry.  */
5500           plt_list = ifunc;
5501           if (h != NULL)
5502             {
5503               h->needs_plt = 1;
5504               if (h->root.root.string[0] == '.'
5505                   && h->root.root.string[1] != '\0')
5506                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5507               plt_list = &h->plt.plist;
5508             }
5509           if (plt_list == NULL)
5510             {
5511               /* It does not make sense to have a procedure linkage
5512                  table entry for a non-ifunc local symbol.  */
5513               info->callbacks->einfo
5514                 (_("%P: %H: %s reloc against local symbol\n"),
5515                  abfd, sec, rel->r_offset,
5516                  ppc64_elf_howto_table[r_type]->name);
5517               bfd_set_error (bfd_error_bad_value);
5518               return FALSE;
5519             }
5520           if (!update_plt_info (abfd, plt_list, rel->r_addend))
5521             return FALSE;
5522           break;
5523
5524           /* The following relocations don't need to propagate the
5525              relocation if linking a shared object since they are
5526              section relative.  */
5527         case R_PPC64_SECTOFF:
5528         case R_PPC64_SECTOFF_LO:
5529         case R_PPC64_SECTOFF_HI:
5530         case R_PPC64_SECTOFF_HA:
5531         case R_PPC64_SECTOFF_DS:
5532         case R_PPC64_SECTOFF_LO_DS:
5533         case R_PPC64_DTPREL16:
5534         case R_PPC64_DTPREL16_LO:
5535         case R_PPC64_DTPREL16_HI:
5536         case R_PPC64_DTPREL16_HA:
5537         case R_PPC64_DTPREL16_DS:
5538         case R_PPC64_DTPREL16_LO_DS:
5539         case R_PPC64_DTPREL16_HIGH:
5540         case R_PPC64_DTPREL16_HIGHA:
5541         case R_PPC64_DTPREL16_HIGHER:
5542         case R_PPC64_DTPREL16_HIGHERA:
5543         case R_PPC64_DTPREL16_HIGHEST:
5544         case R_PPC64_DTPREL16_HIGHESTA:
5545           break;
5546
5547           /* Nor do these.  */
5548         case R_PPC64_REL16:
5549         case R_PPC64_REL16_LO:
5550         case R_PPC64_REL16_HI:
5551         case R_PPC64_REL16_HA:
5552         case R_PPC64_REL16DX_HA:
5553           break;
5554
5555           /* Not supported as a dynamic relocation.  */
5556         case R_PPC64_ADDR64_LOCAL:
5557           if (bfd_link_pic (info))
5558             {
5559               if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5560                 ppc_howto_init ();
5561               info->callbacks->einfo (_("%P: %H: %s reloc unsupported "
5562                                         "in shared libraries and PIEs.\n"),
5563                                       abfd, sec, rel->r_offset,
5564                                       ppc64_elf_howto_table[r_type]->name);
5565               bfd_set_error (bfd_error_bad_value);
5566               return FALSE;
5567             }
5568           break;
5569
5570         case R_PPC64_TOC16:
5571         case R_PPC64_TOC16_DS:
5572           htab->do_multi_toc = 1;
5573           ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5574         case R_PPC64_TOC16_LO:
5575         case R_PPC64_TOC16_HI:
5576         case R_PPC64_TOC16_HA:
5577         case R_PPC64_TOC16_LO_DS:
5578           sec->has_toc_reloc = 1;
5579           break;
5580
5581           /* Marker reloc.  */
5582         case R_PPC64_ENTRY:
5583           break;
5584
5585           /* This relocation describes the C++ object vtable hierarchy.
5586              Reconstruct it for later use during GC.  */
5587         case R_PPC64_GNU_VTINHERIT:
5588           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5589             return FALSE;
5590           break;
5591
5592           /* This relocation describes which C++ vtable entries are actually
5593              used.  Record for later use during GC.  */
5594         case R_PPC64_GNU_VTENTRY:
5595           BFD_ASSERT (h != NULL);
5596           if (h != NULL
5597               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5598             return FALSE;
5599           break;
5600
5601         case R_PPC64_REL14:
5602         case R_PPC64_REL14_BRTAKEN:
5603         case R_PPC64_REL14_BRNTAKEN:
5604           {
5605             asection *dest = NULL;
5606
5607             /* Heuristic: If jumping outside our section, chances are
5608                we are going to need a stub.  */
5609             if (h != NULL)
5610               {
5611                 /* If the sym is weak it may be overridden later, so
5612                    don't assume we know where a weak sym lives.  */
5613                 if (h->root.type == bfd_link_hash_defined)
5614                   dest = h->root.u.def.section;
5615               }
5616             else
5617               {
5618                 Elf_Internal_Sym *isym;
5619
5620                 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5621                                               abfd, r_symndx);
5622                 if (isym == NULL)
5623                   return FALSE;
5624
5625                 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5626               }
5627
5628             if (dest != sec)
5629               ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5630           }
5631           /* Fall through.  */
5632
5633         case R_PPC64_REL24:
5634           plt_list = ifunc;
5635           if (h != NULL)
5636             {
5637               h->needs_plt = 1;
5638               if (h->root.root.string[0] == '.'
5639                   && h->root.root.string[1] != '\0')
5640                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5641
5642               if (h == tga || h == dottga)
5643                 {
5644                   sec->has_tls_reloc = 1;
5645                   if (rel != relocs
5646                       && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5647                           || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5648                     /* We have a new-style __tls_get_addr call with
5649                        a marker reloc.  */
5650                     ;
5651                   else
5652                     /* Mark this section as having an old-style call.  */
5653                     sec->has_tls_get_addr_call = 1;
5654                 }
5655               plt_list = &h->plt.plist;
5656             }
5657
5658           /* We may need a .plt entry if the function this reloc
5659              refers to is in a shared lib.  */
5660           if (plt_list
5661               && !update_plt_info (abfd, plt_list, rel->r_addend))
5662             return FALSE;
5663           break;
5664
5665         case R_PPC64_ADDR14:
5666         case R_PPC64_ADDR14_BRNTAKEN:
5667         case R_PPC64_ADDR14_BRTAKEN:
5668         case R_PPC64_ADDR24:
5669           goto dodyn;
5670
5671         case R_PPC64_TPREL64:
5672           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5673           if (bfd_link_pic (info))
5674             info->flags |= DF_STATIC_TLS;
5675           goto dotlstoc;
5676
5677         case R_PPC64_DTPMOD64:
5678           if (rel + 1 < rel_end
5679               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5680               && rel[1].r_offset == rel->r_offset + 8)
5681             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5682           else
5683             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5684           goto dotlstoc;
5685
5686         case R_PPC64_DTPREL64:
5687           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5688           if (rel != relocs
5689               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5690               && rel[-1].r_offset == rel->r_offset - 8)
5691             /* This is the second reloc of a dtpmod, dtprel pair.
5692                Don't mark with TLS_DTPREL.  */
5693             goto dodyn;
5694
5695         dotlstoc:
5696           sec->has_tls_reloc = 1;
5697           if (h != NULL)
5698             {
5699               struct ppc_link_hash_entry *eh;
5700               eh = (struct ppc_link_hash_entry *) h;
5701               eh->tls_mask |= tls_type;
5702             }
5703           else
5704             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5705                                         rel->r_addend, tls_type))
5706               return FALSE;
5707
5708           ppc64_sec = ppc64_elf_section_data (sec);
5709           if (ppc64_sec->sec_type != sec_toc)
5710             {
5711               bfd_size_type amt;
5712
5713               /* One extra to simplify get_tls_mask.  */
5714               amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5715               ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5716               if (ppc64_sec->u.toc.symndx == NULL)
5717                 return FALSE;
5718               amt = sec->size * sizeof (bfd_vma) / 8;
5719               ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5720               if (ppc64_sec->u.toc.add == NULL)
5721                 return FALSE;
5722               BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5723               ppc64_sec->sec_type = sec_toc;
5724             }
5725           BFD_ASSERT (rel->r_offset % 8 == 0);
5726           ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5727           ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5728
5729           /* Mark the second slot of a GD or LD entry.
5730              -1 to indicate GD and -2 to indicate LD.  */
5731           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5732             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5733           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5734             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5735           goto dodyn;
5736
5737         case R_PPC64_TPREL16:
5738         case R_PPC64_TPREL16_LO:
5739         case R_PPC64_TPREL16_HI:
5740         case R_PPC64_TPREL16_HA:
5741         case R_PPC64_TPREL16_DS:
5742         case R_PPC64_TPREL16_LO_DS:
5743         case R_PPC64_TPREL16_HIGH:
5744         case R_PPC64_TPREL16_HIGHA:
5745         case R_PPC64_TPREL16_HIGHER:
5746         case R_PPC64_TPREL16_HIGHERA:
5747         case R_PPC64_TPREL16_HIGHEST:
5748         case R_PPC64_TPREL16_HIGHESTA:
5749           if (bfd_link_pic (info))
5750             {
5751               info->flags |= DF_STATIC_TLS;
5752               goto dodyn;
5753             }
5754           break;
5755
5756         case R_PPC64_ADDR64:
5757           if (opd_sym_map != NULL
5758               && rel + 1 < rel_end
5759               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5760             {
5761               if (h != NULL)
5762                 {
5763                   if (h->root.root.string[0] == '.'
5764                       && h->root.root.string[1] != 0
5765                       && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
5766                     ;
5767                   else
5768                     ((struct ppc_link_hash_entry *) h)->is_func = 1;
5769                 }
5770               else
5771                 {
5772                   asection *s;
5773                   Elf_Internal_Sym *isym;
5774
5775                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5776                                                 abfd, r_symndx);
5777                   if (isym == NULL)
5778                     return FALSE;
5779
5780                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5781                   if (s != NULL && s != sec)
5782                     opd_sym_map[OPD_NDX (rel->r_offset)] = s;
5783                 }
5784             }
5785           /* Fall through.  */
5786
5787         case R_PPC64_ADDR16:
5788         case R_PPC64_ADDR16_DS:
5789         case R_PPC64_ADDR16_HA:
5790         case R_PPC64_ADDR16_HI:
5791         case R_PPC64_ADDR16_HIGH:
5792         case R_PPC64_ADDR16_HIGHA:
5793         case R_PPC64_ADDR16_HIGHER:
5794         case R_PPC64_ADDR16_HIGHERA:
5795         case R_PPC64_ADDR16_HIGHEST:
5796         case R_PPC64_ADDR16_HIGHESTA:
5797         case R_PPC64_ADDR16_LO:
5798         case R_PPC64_ADDR16_LO_DS:
5799           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1
5800               && rel->r_addend == 0)
5801             {
5802               /* We may need a .plt entry if this reloc refers to a
5803                  function in a shared lib.  */
5804               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5805                 return FALSE;
5806               h->pointer_equality_needed = 1;
5807             }
5808           /* Fall through.  */
5809
5810         case R_PPC64_REL30:
5811         case R_PPC64_REL32:
5812         case R_PPC64_REL64:
5813         case R_PPC64_ADDR32:
5814         case R_PPC64_UADDR16:
5815         case R_PPC64_UADDR32:
5816         case R_PPC64_UADDR64:
5817         case R_PPC64_TOC:
5818           if (h != NULL && !bfd_link_pic (info))
5819             /* We may need a copy reloc.  */
5820             h->non_got_ref = 1;
5821
5822           /* Don't propagate .opd relocs.  */
5823           if (NO_OPD_RELOCS && opd_sym_map != NULL)
5824             break;
5825
5826           /* If we are creating a shared library, and this is a reloc
5827              against a global symbol, or a non PC relative reloc
5828              against a local symbol, then we need to copy the reloc
5829              into the shared library.  However, if we are linking with
5830              -Bsymbolic, we do not need to copy a reloc against a
5831              global symbol which is defined in an object we are
5832              including in the link (i.e., DEF_REGULAR is set).  At
5833              this point we have not seen all the input files, so it is
5834              possible that DEF_REGULAR is not set now but will be set
5835              later (it is never cleared).  In case of a weak definition,
5836              DEF_REGULAR may be cleared later by a strong definition in
5837              a shared library.  We account for that possibility below by
5838              storing information in the dyn_relocs field of the hash
5839              table entry.  A similar situation occurs when creating
5840              shared libraries and symbol visibility changes render the
5841              symbol local.
5842
5843              If on the other hand, we are creating an executable, we
5844              may need to keep relocations for symbols satisfied by a
5845              dynamic library if we manage to avoid copy relocs for the
5846              symbol.  */
5847         dodyn:
5848           if ((bfd_link_pic (info)
5849                && (must_be_dyn_reloc (info, r_type)
5850                    || (h != NULL
5851                        && (!SYMBOLIC_BIND (info, h)
5852                            || h->root.type == bfd_link_hash_defweak
5853                            || !h->def_regular))))
5854               || (ELIMINATE_COPY_RELOCS
5855                   && !bfd_link_pic (info)
5856                   && h != NULL
5857                   && (h->root.type == bfd_link_hash_defweak
5858                       || !h->def_regular))
5859               || (!bfd_link_pic (info)
5860                   && ifunc != NULL))
5861             {
5862               /* We must copy these reloc types into the output file.
5863                  Create a reloc section in dynobj and make room for
5864                  this reloc.  */
5865               if (sreloc == NULL)
5866                 {
5867                   sreloc = _bfd_elf_make_dynamic_reloc_section
5868                     (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5869
5870                   if (sreloc == NULL)
5871                     return FALSE;
5872                 }
5873
5874               /* If this is a global symbol, we count the number of
5875                  relocations we need for this symbol.  */
5876               if (h != NULL)
5877                 {
5878                   struct elf_dyn_relocs *p;
5879                   struct elf_dyn_relocs **head;
5880
5881                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5882                   p = *head;
5883                   if (p == NULL || p->sec != sec)
5884                     {
5885                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5886                       if (p == NULL)
5887                         return FALSE;
5888                       p->next = *head;
5889                       *head = p;
5890                       p->sec = sec;
5891                       p->count = 0;
5892                       p->pc_count = 0;
5893                     }
5894                   p->count += 1;
5895                   if (!must_be_dyn_reloc (info, r_type))
5896                     p->pc_count += 1;
5897                 }
5898               else
5899                 {
5900                   /* Track dynamic relocs needed for local syms too.
5901                      We really need local syms available to do this
5902                      easily.  Oh well.  */
5903                   struct ppc_dyn_relocs *p;
5904                   struct ppc_dyn_relocs **head;
5905                   bfd_boolean is_ifunc;
5906                   asection *s;
5907                   void *vpp;
5908                   Elf_Internal_Sym *isym;
5909
5910                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5911                                                 abfd, r_symndx);
5912                   if (isym == NULL)
5913                     return FALSE;
5914
5915                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5916                   if (s == NULL)
5917                     s = sec;
5918
5919                   vpp = &elf_section_data (s)->local_dynrel;
5920                   head = (struct ppc_dyn_relocs **) vpp;
5921                   is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5922                   p = *head;
5923                   if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5924                     p = p->next;
5925                   if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5926                     {
5927                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5928                       if (p == NULL)
5929                         return FALSE;
5930                       p->next = *head;
5931                       *head = p;
5932                       p->sec = sec;
5933                       p->ifunc = is_ifunc;
5934                       p->count = 0;
5935                     }
5936                   p->count += 1;
5937                 }
5938             }
5939           break;
5940
5941         default:
5942           break;
5943         }
5944     }
5945
5946   return TRUE;
5947 }
5948
5949 /* Merge backend specific data from an object file to the output
5950    object file when linking.  */
5951
5952 static bfd_boolean
5953 ppc64_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
5954 {
5955   unsigned long iflags, oflags;
5956
5957   if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
5958     return TRUE;
5959
5960   if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
5961     return TRUE;
5962
5963   if (!_bfd_generic_verify_endian_match (ibfd, obfd))
5964     return FALSE;
5965
5966   iflags = elf_elfheader (ibfd)->e_flags;
5967   oflags = elf_elfheader (obfd)->e_flags;
5968
5969   if (iflags & ~EF_PPC64_ABI)
5970     {
5971       (*_bfd_error_handler)
5972         (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
5973       bfd_set_error (bfd_error_bad_value);
5974       return FALSE;
5975     }
5976   else if (iflags != oflags && iflags != 0)
5977     {
5978       (*_bfd_error_handler)
5979         (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
5980          ibfd, iflags, oflags);
5981       bfd_set_error (bfd_error_bad_value);
5982       return FALSE;
5983     }
5984
5985   /* Merge Tag_compatibility attributes and any common GNU ones.  */
5986   _bfd_elf_merge_object_attributes (ibfd, obfd);
5987
5988   return TRUE;
5989 }
5990
5991 static bfd_boolean
5992 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
5993 {
5994   /* Print normal ELF private data.  */
5995   _bfd_elf_print_private_bfd_data (abfd, ptr);
5996
5997   if (elf_elfheader (abfd)->e_flags != 0)
5998     {
5999       FILE *file = ptr;
6000
6001       /* xgettext:c-format */
6002       fprintf (file, _("private flags = 0x%lx:"),
6003                elf_elfheader (abfd)->e_flags);
6004
6005       if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
6006         fprintf (file, _(" [abiv%ld]"),
6007                  elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
6008       fputc ('\n', file);
6009     }
6010
6011   return TRUE;
6012 }
6013
6014 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
6015    of the code entry point, and its section, which must be in the same
6016    object as OPD_SEC.  Returns (bfd_vma) -1 on error.  */
6017
6018 static bfd_vma
6019 opd_entry_value (asection *opd_sec,
6020                  bfd_vma offset,
6021                  asection **code_sec,
6022                  bfd_vma *code_off,
6023                  bfd_boolean in_code_sec)
6024 {
6025   bfd *opd_bfd = opd_sec->owner;
6026   Elf_Internal_Rela *relocs;
6027   Elf_Internal_Rela *lo, *hi, *look;
6028   bfd_vma val;
6029
6030   /* No relocs implies we are linking a --just-symbols object, or looking
6031      at a final linked executable with addr2line or somesuch.  */
6032   if (opd_sec->reloc_count == 0)
6033     {
6034       bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
6035
6036       if (contents == NULL)
6037         {
6038           if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
6039             return (bfd_vma) -1;
6040           ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
6041         }
6042
6043       /* PR 17512: file: 64b9dfbb.  */
6044       if (offset + 7 >= opd_sec->size || offset + 7 < offset)
6045         return (bfd_vma) -1;
6046
6047       val = bfd_get_64 (opd_bfd, contents + offset);
6048       if (code_sec != NULL)
6049         {
6050           asection *sec, *likely = NULL;
6051
6052           if (in_code_sec)
6053             {
6054               sec = *code_sec;
6055               if (sec->vma <= val
6056                   && val < sec->vma + sec->size)
6057                 likely = sec;
6058               else
6059                 val = -1;
6060             }
6061           else
6062             for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
6063               if (sec->vma <= val
6064                   && (sec->flags & SEC_LOAD) != 0
6065                   && (sec->flags & SEC_ALLOC) != 0)
6066                 likely = sec;
6067           if (likely != NULL)
6068             {
6069               *code_sec = likely;
6070               if (code_off != NULL)
6071                 *code_off = val - likely->vma;
6072             }
6073         }
6074       return val;
6075     }
6076
6077   BFD_ASSERT (is_ppc64_elf (opd_bfd));
6078
6079   relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
6080   if (relocs == NULL)
6081     relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
6082   /* PR 17512: file: df8e1fd6.  */
6083   if (relocs == NULL)
6084     return (bfd_vma) -1;
6085
6086   /* Go find the opd reloc at the sym address.  */
6087   lo = relocs;
6088   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
6089   val = (bfd_vma) -1;
6090   while (lo < hi)
6091     {
6092       look = lo + (hi - lo) / 2;
6093       if (look->r_offset < offset)
6094         lo = look + 1;
6095       else if (look->r_offset > offset)
6096         hi = look;
6097       else
6098         {
6099           Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
6100
6101           if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
6102               && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
6103             {
6104               unsigned long symndx = ELF64_R_SYM (look->r_info);
6105               asection *sec = NULL;
6106
6107               if (symndx >= symtab_hdr->sh_info
6108                   && elf_sym_hashes (opd_bfd) != NULL)
6109                 {
6110                   struct elf_link_hash_entry **sym_hashes;
6111                   struct elf_link_hash_entry *rh;
6112
6113                   sym_hashes = elf_sym_hashes (opd_bfd);
6114                   rh = sym_hashes[symndx - symtab_hdr->sh_info];
6115                   if (rh != NULL)
6116                     {
6117                       rh = elf_follow_link (rh);
6118                       if (rh->root.type != bfd_link_hash_defined
6119                           && rh->root.type != bfd_link_hash_defweak)
6120                         break;
6121                       if (rh->root.u.def.section->owner == opd_bfd)
6122                         {
6123                           val = rh->root.u.def.value;
6124                           sec = rh->root.u.def.section;
6125                         }
6126                     }
6127                 }
6128
6129               if (sec == NULL)
6130                 {
6131                   Elf_Internal_Sym *sym;
6132
6133                   if (symndx < symtab_hdr->sh_info)
6134                     {
6135                       sym = (Elf_Internal_Sym *) symtab_hdr->contents;
6136                       if (sym == NULL)
6137                         {
6138                           size_t symcnt = symtab_hdr->sh_info;
6139                           sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6140                                                       symcnt, 0,
6141                                                       NULL, NULL, NULL);
6142                           if (sym == NULL)
6143                             break;
6144                           symtab_hdr->contents = (bfd_byte *) sym;
6145                         }
6146                       sym += symndx;
6147                     }
6148                   else
6149                     {
6150                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6151                                                   1, symndx,
6152                                                   NULL, NULL, NULL);
6153                       if (sym == NULL)
6154                         break;
6155                     }
6156                   sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6157                   if (sec == NULL)
6158                     break;
6159                   BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
6160                   val = sym->st_value;
6161                 }
6162
6163               val += look->r_addend;
6164               if (code_off != NULL)
6165                 *code_off = val;
6166               if (code_sec != NULL)
6167                 {
6168                   if (in_code_sec && *code_sec != sec)
6169                     return -1;
6170                   else
6171                     *code_sec = sec;
6172                 }
6173               if (sec->output_section != NULL)
6174                 val += sec->output_section->vma + sec->output_offset;
6175             }
6176           break;
6177         }
6178     }
6179
6180   return val;
6181 }
6182
6183 /* If the ELF symbol SYM might be a function in SEC, return the
6184    function size and set *CODE_OFF to the function's entry point,
6185    otherwise return zero.  */
6186
6187 static bfd_size_type
6188 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6189                               bfd_vma *code_off)
6190 {
6191   bfd_size_type size;
6192
6193   if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6194                      | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6195     return 0;
6196
6197   size = 0;
6198   if (!(sym->flags & BSF_SYNTHETIC))
6199     size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6200
6201   if (strcmp (sym->section->name, ".opd") == 0)
6202     {
6203       struct _opd_sec_data *opd = get_opd_info (sym->section);
6204       bfd_vma symval = sym->value;
6205
6206       if (opd != NULL
6207           && opd->adjust != NULL
6208           && elf_section_data (sym->section)->relocs != NULL)
6209         {
6210           /* opd_entry_value will use cached relocs that have been
6211              adjusted, but with raw symbols.  That means both local
6212              and global symbols need adjusting.  */
6213           long adjust = opd->adjust[OPD_NDX (symval)];
6214           if (adjust == -1)
6215             return 0;
6216           symval += adjust;
6217         }
6218
6219       if (opd_entry_value (sym->section, symval,
6220                            &sec, code_off, TRUE) == (bfd_vma) -1)
6221         return 0;
6222       /* An old ABI binary with dot-syms has a size of 24 on the .opd
6223          symbol.  This size has nothing to do with the code size of the
6224          function, which is what we're supposed to return, but the
6225          code size isn't available without looking up the dot-sym.
6226          However, doing that would be a waste of time particularly
6227          since elf_find_function will look at the dot-sym anyway.
6228          Now, elf_find_function will keep the largest size of any
6229          function sym found at the code address of interest, so return
6230          1 here to avoid it incorrectly caching a larger function size
6231          for a small function.  This does mean we return the wrong
6232          size for a new-ABI function of size 24, but all that does is
6233          disable caching for such functions.  */
6234       if (size == 24)
6235         size = 1;
6236     }
6237   else
6238     {
6239       if (sym->section != sec)
6240         return 0;
6241       *code_off = sym->value;
6242     }
6243   if (size == 0)
6244     size = 1;
6245   return size;
6246 }
6247
6248 /* Return true if symbol is defined in a regular object file.  */
6249
6250 static bfd_boolean
6251 is_static_defined (struct elf_link_hash_entry *h)
6252 {
6253   return ((h->root.type == bfd_link_hash_defined
6254            || h->root.type == bfd_link_hash_defweak)
6255           && h->root.u.def.section != NULL
6256           && h->root.u.def.section->output_section != NULL);
6257 }
6258
6259 /* If FDH is a function descriptor symbol, return the associated code
6260    entry symbol if it is defined.  Return NULL otherwise.  */
6261
6262 static struct ppc_link_hash_entry *
6263 defined_code_entry (struct ppc_link_hash_entry *fdh)
6264 {
6265   if (fdh->is_func_descriptor)
6266     {
6267       struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6268       if (fh->elf.root.type == bfd_link_hash_defined
6269           || fh->elf.root.type == bfd_link_hash_defweak)
6270         return fh;
6271     }
6272   return NULL;
6273 }
6274
6275 /* If FH is a function code entry symbol, return the associated
6276    function descriptor symbol if it is defined.  Return NULL otherwise.  */
6277
6278 static struct ppc_link_hash_entry *
6279 defined_func_desc (struct ppc_link_hash_entry *fh)
6280 {
6281   if (fh->oh != NULL
6282       && fh->oh->is_func_descriptor)
6283     {
6284       struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6285       if (fdh->elf.root.type == bfd_link_hash_defined
6286           || fdh->elf.root.type == bfd_link_hash_defweak)
6287         return fdh;
6288     }
6289   return NULL;
6290 }
6291
6292 /* Mark all our entry sym sections, both opd and code section.  */
6293
6294 static void
6295 ppc64_elf_gc_keep (struct bfd_link_info *info)
6296 {
6297   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6298   struct bfd_sym_chain *sym;
6299
6300   if (htab == NULL)
6301     return;
6302
6303   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6304     {
6305       struct ppc_link_hash_entry *eh, *fh;
6306       asection *sec;
6307
6308       eh = (struct ppc_link_hash_entry *)
6309         elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6310       if (eh == NULL)
6311         continue;
6312       if (eh->elf.root.type != bfd_link_hash_defined
6313           && eh->elf.root.type != bfd_link_hash_defweak)
6314         continue;
6315
6316       fh = defined_code_entry (eh);
6317       if (fh != NULL)
6318         {
6319           sec = fh->elf.root.u.def.section;
6320           sec->flags |= SEC_KEEP;
6321         }
6322       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6323                && opd_entry_value (eh->elf.root.u.def.section,
6324                                    eh->elf.root.u.def.value,
6325                                    &sec, NULL, FALSE) != (bfd_vma) -1)
6326         sec->flags |= SEC_KEEP;
6327
6328       sec = eh->elf.root.u.def.section;
6329       sec->flags |= SEC_KEEP;
6330     }
6331 }
6332
6333 /* Mark sections containing dynamically referenced symbols.  When
6334    building shared libraries, we must assume that any visible symbol is
6335    referenced.  */
6336
6337 static bfd_boolean
6338 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6339 {
6340   struct bfd_link_info *info = (struct bfd_link_info *) inf;
6341   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6342   struct ppc_link_hash_entry *fdh;
6343   struct bfd_elf_dynamic_list *d = info->dynamic_list;
6344
6345   /* Dynamic linking info is on the func descriptor sym.  */
6346   fdh = defined_func_desc (eh);
6347   if (fdh != NULL)
6348     eh = fdh;
6349
6350   if ((eh->elf.root.type == bfd_link_hash_defined
6351        || eh->elf.root.type == bfd_link_hash_defweak)
6352       && (eh->elf.ref_dynamic
6353           || ((eh->elf.def_regular || ELF_COMMON_DEF_P (&eh->elf))
6354               && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6355               && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6356               && (!bfd_link_executable (info)
6357                   || info->export_dynamic
6358                   || (eh->elf.dynamic
6359                       && d != NULL
6360                       && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
6361               && (strchr (eh->elf.root.root.string, ELF_VER_CHR) != NULL
6362                   || !bfd_hide_sym_by_version (info->version_info,
6363                                                eh->elf.root.root.string)))))
6364     {
6365       asection *code_sec;
6366       struct ppc_link_hash_entry *fh;
6367
6368       eh->elf.root.u.def.section->flags |= SEC_KEEP;
6369
6370       /* Function descriptor syms cause the associated
6371          function code sym section to be marked.  */
6372       fh = defined_code_entry (eh);
6373       if (fh != NULL)
6374         {
6375           code_sec = fh->elf.root.u.def.section;
6376           code_sec->flags |= SEC_KEEP;
6377         }
6378       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6379                && opd_entry_value (eh->elf.root.u.def.section,
6380                                    eh->elf.root.u.def.value,
6381                                    &code_sec, NULL, FALSE) != (bfd_vma) -1)
6382         code_sec->flags |= SEC_KEEP;
6383     }
6384
6385   return TRUE;
6386 }
6387
6388 /* Return the section that should be marked against GC for a given
6389    relocation.  */
6390
6391 static asection *
6392 ppc64_elf_gc_mark_hook (asection *sec,
6393                         struct bfd_link_info *info,
6394                         Elf_Internal_Rela *rel,
6395                         struct elf_link_hash_entry *h,
6396                         Elf_Internal_Sym *sym)
6397 {
6398   asection *rsec;
6399
6400   /* Syms return NULL if we're marking .opd, so we avoid marking all
6401      function sections, as all functions are referenced in .opd.  */
6402   rsec = NULL;
6403   if (get_opd_info (sec) != NULL)
6404     return rsec;
6405
6406   if (h != NULL)
6407     {
6408       enum elf_ppc64_reloc_type r_type;
6409       struct ppc_link_hash_entry *eh, *fh, *fdh;
6410
6411       r_type = ELF64_R_TYPE (rel->r_info);
6412       switch (r_type)
6413         {
6414         case R_PPC64_GNU_VTINHERIT:
6415         case R_PPC64_GNU_VTENTRY:
6416           break;
6417
6418         default:
6419           switch (h->root.type)
6420             {
6421             case bfd_link_hash_defined:
6422             case bfd_link_hash_defweak:
6423               eh = (struct ppc_link_hash_entry *) h;
6424               fdh = defined_func_desc (eh);
6425               if (fdh != NULL)
6426                 eh = fdh;
6427
6428               /* Function descriptor syms cause the associated
6429                  function code sym section to be marked.  */
6430               fh = defined_code_entry (eh);
6431               if (fh != NULL)
6432                 {
6433                   /* They also mark their opd section.  */
6434                   eh->elf.root.u.def.section->gc_mark = 1;
6435
6436                   rsec = fh->elf.root.u.def.section;
6437                 }
6438               else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6439                        && opd_entry_value (eh->elf.root.u.def.section,
6440                                            eh->elf.root.u.def.value,
6441                                            &rsec, NULL, FALSE) != (bfd_vma) -1)
6442                 eh->elf.root.u.def.section->gc_mark = 1;
6443               else
6444                 rsec = h->root.u.def.section;
6445               break;
6446
6447             case bfd_link_hash_common:
6448               rsec = h->root.u.c.p->section;
6449               break;
6450
6451             default:
6452               return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6453             }
6454         }
6455     }
6456   else
6457     {
6458       struct _opd_sec_data *opd;
6459
6460       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6461       opd = get_opd_info (rsec);
6462       if (opd != NULL && opd->func_sec != NULL)
6463         {
6464           rsec->gc_mark = 1;
6465
6466           rsec = opd->func_sec[OPD_NDX (sym->st_value + rel->r_addend)];
6467         }
6468     }
6469
6470   return rsec;
6471 }
6472
6473 /* Update the .got, .plt. and dynamic reloc reference counts for the
6474    section being removed.  */
6475
6476 static bfd_boolean
6477 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
6478                          asection *sec, const Elf_Internal_Rela *relocs)
6479 {
6480   struct ppc_link_hash_table *htab;
6481   Elf_Internal_Shdr *symtab_hdr;
6482   struct elf_link_hash_entry **sym_hashes;
6483   struct got_entry **local_got_ents;
6484   const Elf_Internal_Rela *rel, *relend;
6485
6486   if (bfd_link_relocatable (info))
6487     return TRUE;
6488
6489   if ((sec->flags & SEC_ALLOC) == 0)
6490     return TRUE;
6491
6492   elf_section_data (sec)->local_dynrel = NULL;
6493
6494   htab = ppc_hash_table (info);
6495   if (htab == NULL)
6496     return FALSE;
6497
6498   symtab_hdr = &elf_symtab_hdr (abfd);
6499   sym_hashes = elf_sym_hashes (abfd);
6500   local_got_ents = elf_local_got_ents (abfd);
6501
6502   relend = relocs + sec->reloc_count;
6503   for (rel = relocs; rel < relend; rel++)
6504     {
6505       unsigned long r_symndx;
6506       enum elf_ppc64_reloc_type r_type;
6507       struct elf_link_hash_entry *h = NULL;
6508       struct plt_entry **plt_list;
6509       unsigned char tls_type = 0;
6510
6511       r_symndx = ELF64_R_SYM (rel->r_info);
6512       r_type = ELF64_R_TYPE (rel->r_info);
6513       if (r_symndx >= symtab_hdr->sh_info)
6514         {
6515           struct ppc_link_hash_entry *eh;
6516           struct elf_dyn_relocs **pp;
6517           struct elf_dyn_relocs *p;
6518
6519           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6520           h = elf_follow_link (h);
6521           eh = (struct ppc_link_hash_entry *) h;
6522
6523           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6524             if (p->sec == sec)
6525               {
6526                 /* Everything must go for SEC.  */
6527                 *pp = p->next;
6528                 break;
6529               }
6530         }
6531
6532       switch (r_type)
6533         {
6534         case R_PPC64_GOT_TLSLD16:
6535         case R_PPC64_GOT_TLSLD16_LO:
6536         case R_PPC64_GOT_TLSLD16_HI:
6537         case R_PPC64_GOT_TLSLD16_HA:
6538           tls_type = TLS_TLS | TLS_LD;
6539           goto dogot;
6540
6541         case R_PPC64_GOT_TLSGD16:
6542         case R_PPC64_GOT_TLSGD16_LO:
6543         case R_PPC64_GOT_TLSGD16_HI:
6544         case R_PPC64_GOT_TLSGD16_HA:
6545           tls_type = TLS_TLS | TLS_GD;
6546           goto dogot;
6547
6548         case R_PPC64_GOT_TPREL16_DS:
6549         case R_PPC64_GOT_TPREL16_LO_DS:
6550         case R_PPC64_GOT_TPREL16_HI:
6551         case R_PPC64_GOT_TPREL16_HA:
6552           tls_type = TLS_TLS | TLS_TPREL;
6553           goto dogot;
6554
6555         case R_PPC64_GOT_DTPREL16_DS:
6556         case R_PPC64_GOT_DTPREL16_LO_DS:
6557         case R_PPC64_GOT_DTPREL16_HI:
6558         case R_PPC64_GOT_DTPREL16_HA:
6559           tls_type = TLS_TLS | TLS_DTPREL;
6560           goto dogot;
6561
6562         case R_PPC64_GOT16:
6563         case R_PPC64_GOT16_DS:
6564         case R_PPC64_GOT16_HA:
6565         case R_PPC64_GOT16_HI:
6566         case R_PPC64_GOT16_LO:
6567         case R_PPC64_GOT16_LO_DS:
6568         dogot:
6569           {
6570             struct got_entry *ent;
6571
6572             if (h != NULL)
6573               ent = h->got.glist;
6574             else
6575               ent = local_got_ents[r_symndx];
6576
6577             for (; ent != NULL; ent = ent->next)
6578               if (ent->addend == rel->r_addend
6579                   && ent->owner == abfd
6580                   && ent->tls_type == tls_type)
6581                 break;
6582             if (ent == NULL)
6583               abort ();
6584             if (ent->got.refcount > 0)
6585               ent->got.refcount -= 1;
6586           }
6587           break;
6588
6589         case R_PPC64_PLT16_HA:
6590         case R_PPC64_PLT16_HI:
6591         case R_PPC64_PLT16_LO:
6592         case R_PPC64_PLT32:
6593         case R_PPC64_PLT64:
6594         case R_PPC64_REL14:
6595         case R_PPC64_REL14_BRNTAKEN:
6596         case R_PPC64_REL14_BRTAKEN:
6597         case R_PPC64_REL24:
6598           plt_list = NULL;
6599           if (h != NULL)
6600             plt_list = &h->plt.plist;
6601           else if (local_got_ents != NULL)
6602             {
6603               struct plt_entry **local_plt = (struct plt_entry **)
6604                 (local_got_ents + symtab_hdr->sh_info);
6605               unsigned char *local_got_tls_masks = (unsigned char *)
6606                 (local_plt + symtab_hdr->sh_info);
6607               if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6608                 plt_list = local_plt + r_symndx;
6609             }
6610           if (plt_list)
6611             {
6612               struct plt_entry *ent;
6613
6614               for (ent = *plt_list; ent != NULL; ent = ent->next)
6615                 if (ent->addend == rel->r_addend)
6616                   break;
6617               if (ent != NULL && ent->plt.refcount > 0)
6618                 ent->plt.refcount -= 1;
6619             }
6620           break;
6621
6622         default:
6623           break;
6624         }
6625     }
6626   return TRUE;
6627 }
6628
6629 /* The maximum size of .sfpr.  */
6630 #define SFPR_MAX (218*4)
6631
6632 struct sfpr_def_parms
6633 {
6634   const char name[12];
6635   unsigned char lo, hi;
6636   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6637   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6638 };
6639
6640 /* Auto-generate _save*, _rest* functions in .sfpr.
6641    If STUB_SEC is non-null, define alias symbols in STUB_SEC
6642    instead.  */
6643
6644 static bfd_boolean
6645 sfpr_define (struct bfd_link_info *info,
6646              const struct sfpr_def_parms *parm,
6647              asection *stub_sec)
6648 {
6649   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6650   unsigned int i;
6651   size_t len = strlen (parm->name);
6652   bfd_boolean writing = FALSE;
6653   char sym[16];
6654
6655   if (htab == NULL)
6656     return FALSE;
6657
6658   memcpy (sym, parm->name, len);
6659   sym[len + 2] = 0;
6660
6661   for (i = parm->lo; i <= parm->hi; i++)
6662     {
6663       struct ppc_link_hash_entry *h;
6664
6665       sym[len + 0] = i / 10 + '0';
6666       sym[len + 1] = i % 10 + '0';
6667       h = (struct ppc_link_hash_entry *)
6668         elf_link_hash_lookup (&htab->elf, sym, writing, TRUE, TRUE);
6669       if (stub_sec != NULL)
6670         {
6671           if (h != NULL
6672               && h->elf.root.type == bfd_link_hash_defined
6673               && h->elf.root.u.def.section == htab->sfpr)
6674             {
6675               struct elf_link_hash_entry *s;
6676               char buf[32];
6677               sprintf (buf, "%08x.%s", stub_sec->id & 0xffffffff, sym);
6678               s = elf_link_hash_lookup (&htab->elf, buf, TRUE, TRUE, FALSE);
6679               if (s == NULL)
6680                 return FALSE;
6681               if (s->root.type == bfd_link_hash_new
6682                   || (s->root.type = bfd_link_hash_defined
6683                       && s->root.u.def.section == stub_sec))
6684                 {
6685                   s->root.type = bfd_link_hash_defined;
6686                   s->root.u.def.section = stub_sec;
6687                   s->root.u.def.value = (stub_sec->size
6688                                          + h->elf.root.u.def.value);
6689                   s->ref_regular = 1;
6690                   s->def_regular = 1;
6691                   s->ref_regular_nonweak = 1;
6692                   s->forced_local = 1;
6693                   s->non_elf = 0;
6694                   s->root.linker_def = 1;
6695                 }
6696             }
6697           continue;
6698         }
6699       if (h != NULL)
6700         {
6701           h->save_res = 1;
6702           if (!h->elf.def_regular)
6703             {
6704               h->elf.root.type = bfd_link_hash_defined;
6705               h->elf.root.u.def.section = htab->sfpr;
6706               h->elf.root.u.def.value = htab->sfpr->size;
6707               h->elf.type = STT_FUNC;
6708               h->elf.def_regular = 1;
6709               h->elf.non_elf = 0;
6710               _bfd_elf_link_hash_hide_symbol (info, &h->elf, TRUE);
6711               writing = TRUE;
6712               if (htab->sfpr->contents == NULL)
6713                 {
6714                   htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6715                   if (htab->sfpr->contents == NULL)
6716                     return FALSE;
6717                 }
6718             }
6719         }
6720       if (writing)
6721         {
6722           bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6723           if (i != parm->hi)
6724             p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6725           else
6726             p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6727           htab->sfpr->size = p - htab->sfpr->contents;
6728         }
6729     }
6730
6731   return TRUE;
6732 }
6733
6734 static bfd_byte *
6735 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6736 {
6737   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6738   return p + 4;
6739 }
6740
6741 static bfd_byte *
6742 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6743 {
6744   p = savegpr0 (abfd, p, r);
6745   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6746   p = p + 4;
6747   bfd_put_32 (abfd, BLR, p);
6748   return p + 4;
6749 }
6750
6751 static bfd_byte *
6752 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6753 {
6754   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6755   return p + 4;
6756 }
6757
6758 static bfd_byte *
6759 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6760 {
6761   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6762   p = p + 4;
6763   p = restgpr0 (abfd, p, r);
6764   bfd_put_32 (abfd, MTLR_R0, p);
6765   p = p + 4;
6766   if (r == 29)
6767     {
6768       p = restgpr0 (abfd, p, 30);
6769       p = restgpr0 (abfd, p, 31);
6770     }
6771   bfd_put_32 (abfd, BLR, p);
6772   return p + 4;
6773 }
6774
6775 static bfd_byte *
6776 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6777 {
6778   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6779   return p + 4;
6780 }
6781
6782 static bfd_byte *
6783 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6784 {
6785   p = savegpr1 (abfd, p, r);
6786   bfd_put_32 (abfd, BLR, p);
6787   return p + 4;
6788 }
6789
6790 static bfd_byte *
6791 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6792 {
6793   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6794   return p + 4;
6795 }
6796
6797 static bfd_byte *
6798 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6799 {
6800   p = restgpr1 (abfd, p, r);
6801   bfd_put_32 (abfd, BLR, p);
6802   return p + 4;
6803 }
6804
6805 static bfd_byte *
6806 savefpr (bfd *abfd, bfd_byte *p, int r)
6807 {
6808   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6809   return p + 4;
6810 }
6811
6812 static bfd_byte *
6813 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6814 {
6815   p = savefpr (abfd, p, r);
6816   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6817   p = p + 4;
6818   bfd_put_32 (abfd, BLR, p);
6819   return p + 4;
6820 }
6821
6822 static bfd_byte *
6823 restfpr (bfd *abfd, bfd_byte *p, int r)
6824 {
6825   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6826   return p + 4;
6827 }
6828
6829 static bfd_byte *
6830 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6831 {
6832   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6833   p = p + 4;
6834   p = restfpr (abfd, p, r);
6835   bfd_put_32 (abfd, MTLR_R0, p);
6836   p = p + 4;
6837   if (r == 29)
6838     {
6839       p = restfpr (abfd, p, 30);
6840       p = restfpr (abfd, p, 31);
6841     }
6842   bfd_put_32 (abfd, BLR, p);
6843   return p + 4;
6844 }
6845
6846 static bfd_byte *
6847 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6848 {
6849   p = savefpr (abfd, p, r);
6850   bfd_put_32 (abfd, BLR, p);
6851   return p + 4;
6852 }
6853
6854 static bfd_byte *
6855 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6856 {
6857   p = restfpr (abfd, p, r);
6858   bfd_put_32 (abfd, BLR, p);
6859   return p + 4;
6860 }
6861
6862 static bfd_byte *
6863 savevr (bfd *abfd, bfd_byte *p, int r)
6864 {
6865   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6866   p = p + 4;
6867   bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6868   return p + 4;
6869 }
6870
6871 static bfd_byte *
6872 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6873 {
6874   p = savevr (abfd, p, r);
6875   bfd_put_32 (abfd, BLR, p);
6876   return p + 4;
6877 }
6878
6879 static bfd_byte *
6880 restvr (bfd *abfd, bfd_byte *p, int r)
6881 {
6882   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6883   p = p + 4;
6884   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6885   return p + 4;
6886 }
6887
6888 static bfd_byte *
6889 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6890 {
6891   p = restvr (abfd, p, r);
6892   bfd_put_32 (abfd, BLR, p);
6893   return p + 4;
6894 }
6895
6896 /* Called via elf_link_hash_traverse to transfer dynamic linking
6897    information on function code symbol entries to their corresponding
6898    function descriptor symbol entries.  */
6899
6900 static bfd_boolean
6901 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6902 {
6903   struct bfd_link_info *info;
6904   struct ppc_link_hash_table *htab;
6905   struct plt_entry *ent;
6906   struct ppc_link_hash_entry *fh;
6907   struct ppc_link_hash_entry *fdh;
6908   bfd_boolean force_local;
6909
6910   fh = (struct ppc_link_hash_entry *) h;
6911   if (fh->elf.root.type == bfd_link_hash_indirect)
6912     return TRUE;
6913
6914   info = inf;
6915   htab = ppc_hash_table (info);
6916   if (htab == NULL)
6917     return FALSE;
6918
6919   /* Resolve undefined references to dot-symbols as the value
6920      in the function descriptor, if we have one in a regular object.
6921      This is to satisfy cases like ".quad .foo".  Calls to functions
6922      in dynamic objects are handled elsewhere.  */
6923   if (fh->elf.root.type == bfd_link_hash_undefweak
6924       && fh->was_undefined
6925       && (fdh = defined_func_desc (fh)) != NULL
6926       && get_opd_info (fdh->elf.root.u.def.section) != NULL
6927       && opd_entry_value (fdh->elf.root.u.def.section,
6928                           fdh->elf.root.u.def.value,
6929                           &fh->elf.root.u.def.section,
6930                           &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
6931     {
6932       fh->elf.root.type = fdh->elf.root.type;
6933       fh->elf.forced_local = 1;
6934       fh->elf.def_regular = fdh->elf.def_regular;
6935       fh->elf.def_dynamic = fdh->elf.def_dynamic;
6936     }
6937
6938   /* If this is a function code symbol, transfer dynamic linking
6939      information to the function descriptor symbol.  */
6940   if (!fh->is_func)
6941     return TRUE;
6942
6943   for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6944     if (ent->plt.refcount > 0)
6945       break;
6946   if (ent == NULL
6947       || fh->elf.root.root.string[0] != '.'
6948       || fh->elf.root.root.string[1] == '\0')
6949     return TRUE;
6950
6951   /* Find the corresponding function descriptor symbol.  Create it
6952      as undefined if necessary.  */
6953
6954   fdh = lookup_fdh (fh, htab);
6955   if (fdh == NULL
6956       && !bfd_link_executable (info)
6957       && (fh->elf.root.type == bfd_link_hash_undefined
6958           || fh->elf.root.type == bfd_link_hash_undefweak))
6959     {
6960       fdh = make_fdh (info, fh);
6961       if (fdh == NULL)
6962         return FALSE;
6963     }
6964
6965   /* Fake function descriptors are made undefweak.  If the function
6966      code symbol is strong undefined, make the fake sym the same.
6967      If the function code symbol is defined, then force the fake
6968      descriptor local;  We can't support overriding of symbols in a
6969      shared library on a fake descriptor.  */
6970
6971   if (fdh != NULL
6972       && fdh->fake
6973       && fdh->elf.root.type == bfd_link_hash_undefweak)
6974     {
6975       if (fh->elf.root.type == bfd_link_hash_undefined)
6976         {
6977           fdh->elf.root.type = bfd_link_hash_undefined;
6978           bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
6979         }
6980       else if (fh->elf.root.type == bfd_link_hash_defined
6981                || fh->elf.root.type == bfd_link_hash_defweak)
6982         {
6983           _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6984         }
6985     }
6986
6987   if (fdh != NULL
6988       && !fdh->elf.forced_local
6989       && (!bfd_link_executable (info)
6990           || fdh->elf.def_dynamic
6991           || fdh->elf.ref_dynamic
6992           || (fdh->elf.root.type == bfd_link_hash_undefweak
6993               && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
6994     {
6995       if (fdh->elf.dynindx == -1)
6996         if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
6997           return FALSE;
6998       fdh->elf.ref_regular |= fh->elf.ref_regular;
6999       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
7000       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
7001       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
7002       if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
7003         {
7004           move_plt_plist (fh, fdh);
7005           fdh->elf.needs_plt = 1;
7006         }
7007       fdh->is_func_descriptor = 1;
7008       fdh->oh = fh;
7009       fh->oh = fdh;
7010     }
7011
7012   /* Now that the info is on the function descriptor, clear the
7013      function code sym info.  Any function code syms for which we
7014      don't have a definition in a regular file, we force local.
7015      This prevents a shared library from exporting syms that have
7016      been imported from another library.  Function code syms that
7017      are really in the library we must leave global to prevent the
7018      linker dragging in a definition from a static library.  */
7019   force_local = (!fh->elf.def_regular
7020                  || fdh == NULL
7021                  || !fdh->elf.def_regular
7022                  || fdh->elf.forced_local);
7023   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7024
7025   return TRUE;
7026 }
7027
7028 static const struct sfpr_def_parms save_res_funcs[] =
7029   {
7030     { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
7031     { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
7032     { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
7033     { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
7034     { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
7035     { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
7036     { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
7037     { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
7038     { "._savef", 14, 31, savefpr, savefpr1_tail },
7039     { "._restf", 14, 31, restfpr, restfpr1_tail },
7040     { "_savevr_", 20, 31, savevr, savevr_tail },
7041     { "_restvr_", 20, 31, restvr, restvr_tail }
7042   };
7043
7044 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
7045    this hook to a) provide some gcc support functions, and b) transfer
7046    dynamic linking information gathered so far on function code symbol
7047    entries, to their corresponding function descriptor symbol entries.  */
7048
7049 static bfd_boolean
7050 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
7051                             struct bfd_link_info *info)
7052 {
7053   struct ppc_link_hash_table *htab;
7054
7055   htab = ppc_hash_table (info);
7056   if (htab == NULL)
7057     return FALSE;
7058
7059   /* Provide any missing _save* and _rest* functions.  */
7060   if (htab->sfpr != NULL)
7061     {
7062       unsigned int i;
7063
7064       htab->sfpr->size = 0;
7065       for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
7066         if (!sfpr_define (info, &save_res_funcs[i], NULL))
7067           return FALSE;
7068       if (htab->sfpr->size == 0)
7069         htab->sfpr->flags |= SEC_EXCLUDE;
7070     }
7071
7072   if (bfd_link_relocatable (info))
7073     return TRUE;
7074
7075   if (htab->elf.hgot != NULL)
7076     {
7077       _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
7078       /* Make .TOC. defined so as to prevent it being made dynamic.
7079          The wrong value here is fixed later in ppc64_elf_set_toc.  */
7080       if (!htab->elf.hgot->def_regular
7081           || htab->elf.hgot->root.type != bfd_link_hash_defined)
7082         {
7083           htab->elf.hgot->root.type = bfd_link_hash_defined;
7084           htab->elf.hgot->root.u.def.value = 0;
7085           htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
7086           htab->elf.hgot->def_regular = 1;
7087           htab->elf.hgot->root.linker_def = 1;
7088         }
7089       htab->elf.hgot->type = STT_OBJECT;
7090       htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
7091                                | STV_HIDDEN);
7092     }
7093
7094   elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
7095
7096   return TRUE;
7097 }
7098
7099 /* Return true if we have dynamic relocs that apply to read-only sections.  */
7100
7101 static bfd_boolean
7102 readonly_dynrelocs (struct elf_link_hash_entry *h)
7103 {
7104   struct ppc_link_hash_entry *eh;
7105   struct elf_dyn_relocs *p;
7106
7107   eh = (struct ppc_link_hash_entry *) h;
7108   for (p = eh->dyn_relocs; p != NULL; p = p->next)
7109     {
7110       asection *s = p->sec->output_section;
7111
7112       if (s != NULL && (s->flags & SEC_READONLY) != 0)
7113         return TRUE;
7114     }
7115   return FALSE;
7116 }
7117
7118 /* Adjust a symbol defined by a dynamic object and referenced by a
7119    regular object.  The current definition is in some section of the
7120    dynamic object, but we're not including those sections.  We have to
7121    change the definition to something the rest of the link can
7122    understand.  */
7123
7124 static bfd_boolean
7125 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
7126                                  struct elf_link_hash_entry *h)
7127 {
7128   struct ppc_link_hash_table *htab;
7129   asection *s;
7130
7131   htab = ppc_hash_table (info);
7132   if (htab == NULL)
7133     return FALSE;
7134
7135   /* Deal with function syms.  */
7136   if (h->type == STT_FUNC
7137       || h->type == STT_GNU_IFUNC
7138       || h->needs_plt)
7139     {
7140       /* Clear procedure linkage table information for any symbol that
7141          won't need a .plt entry.  */
7142       struct plt_entry *ent;
7143       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
7144         if (ent->plt.refcount > 0)
7145           break;
7146       if (ent == NULL
7147           || (h->type != STT_GNU_IFUNC
7148               && (SYMBOL_CALLS_LOCAL (info, h)
7149                   || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
7150                       && h->root.type == bfd_link_hash_undefweak)))
7151           || ((struct ppc_link_hash_entry *) h)->save_res)
7152         {
7153           h->plt.plist = NULL;
7154           h->needs_plt = 0;
7155           h->pointer_equality_needed = 0;
7156         }
7157       else if (abiversion (info->output_bfd) == 2)
7158         {
7159           /* Taking a function's address in a read/write section
7160              doesn't require us to define the function symbol in the
7161              executable on a global entry stub.  A dynamic reloc can
7162              be used instead.  */
7163           if (h->pointer_equality_needed
7164               && h->type != STT_GNU_IFUNC
7165               && !readonly_dynrelocs (h))
7166             {
7167               h->pointer_equality_needed = 0;
7168               h->non_got_ref = 0;
7169             }
7170
7171           /* After adjust_dynamic_symbol, non_got_ref set in the
7172              non-shared case means that we have allocated space in
7173              .dynbss for the symbol and thus dyn_relocs for this
7174              symbol should be discarded.
7175              If we get here we know we are making a PLT entry for this
7176              symbol, and in an executable we'd normally resolve
7177              relocations against this symbol to the PLT entry.  Allow
7178              dynamic relocs if the reference is weak, and the dynamic
7179              relocs will not cause text relocation.  */
7180           else if (!h->ref_regular_nonweak
7181                    && h->non_got_ref
7182                    && h->type != STT_GNU_IFUNC
7183                    && !readonly_dynrelocs (h))
7184             h->non_got_ref = 0;
7185
7186           /* If making a plt entry, then we don't need copy relocs.  */
7187           return TRUE;
7188         }
7189     }
7190   else
7191     h->plt.plist = NULL;
7192
7193   /* If this is a weak symbol, and there is a real definition, the
7194      processor independent code will have arranged for us to see the
7195      real definition first, and we can just use the same value.  */
7196   if (h->u.weakdef != NULL)
7197     {
7198       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
7199                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
7200       h->root.u.def.section = h->u.weakdef->root.u.def.section;
7201       h->root.u.def.value = h->u.weakdef->root.u.def.value;
7202       if (ELIMINATE_COPY_RELOCS)
7203         h->non_got_ref = h->u.weakdef->non_got_ref;
7204       return TRUE;
7205     }
7206
7207   /* If we are creating a shared library, we must presume that the
7208      only references to the symbol are via the global offset table.
7209      For such cases we need not do anything here; the relocations will
7210      be handled correctly by relocate_section.  */
7211   if (bfd_link_pic (info))
7212     return TRUE;
7213
7214   /* If there are no references to this symbol that do not use the
7215      GOT, we don't need to generate a copy reloc.  */
7216   if (!h->non_got_ref)
7217     return TRUE;
7218
7219   /* Don't generate a copy reloc for symbols defined in the executable.  */
7220   if (!h->def_dynamic || !h->ref_regular || h->def_regular)
7221     return TRUE;
7222
7223   /* If -z nocopyreloc was given, don't generate them either.  */
7224   if (info->nocopyreloc)
7225     {
7226       h->non_got_ref = 0;
7227       return TRUE;
7228     }
7229
7230   /* If we didn't find any dynamic relocs in read-only sections, then
7231      we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
7232   if (ELIMINATE_COPY_RELOCS && !readonly_dynrelocs (h))
7233     {
7234       h->non_got_ref = 0;
7235       return TRUE;
7236     }
7237
7238   /* Protected variables do not work with .dynbss.  The copy in
7239      .dynbss won't be used by the shared library with the protected
7240      definition for the variable.  Text relocations are preferable
7241      to an incorrect program.  */
7242   if (h->protected_def)
7243     {
7244       h->non_got_ref = 0;
7245       return TRUE;
7246     }
7247
7248   if (h->plt.plist != NULL)
7249     {
7250       /* We should never get here, but unfortunately there are versions
7251          of gcc out there that improperly (for this ABI) put initialized
7252          function pointers, vtable refs and suchlike in read-only
7253          sections.  Allow them to proceed, but warn that this might
7254          break at runtime.  */
7255       info->callbacks->einfo
7256         (_("%P: copy reloc against `%T' requires lazy plt linking; "
7257            "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7258          h->root.root.string);
7259     }
7260
7261   /* This is a reference to a symbol defined by a dynamic object which
7262      is not a function.  */
7263
7264   /* We must allocate the symbol in our .dynbss section, which will
7265      become part of the .bss section of the executable.  There will be
7266      an entry for this symbol in the .dynsym section.  The dynamic
7267      object will contain position independent code, so all references
7268      from the dynamic object to this symbol will go through the global
7269      offset table.  The dynamic linker will use the .dynsym entry to
7270      determine the address it must put in the global offset table, so
7271      both the dynamic object and the regular object will refer to the
7272      same memory location for the variable.  */
7273
7274   /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
7275      to copy the initial value out of the dynamic object and into the
7276      runtime process image.  We need to remember the offset into the
7277      .rela.bss section we are going to use.  */
7278   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7279     {
7280       htab->relbss->size += sizeof (Elf64_External_Rela);
7281       h->needs_copy = 1;
7282     }
7283
7284   s = htab->dynbss;
7285
7286   return _bfd_elf_adjust_dynamic_copy (info, h, s);
7287 }
7288
7289 /* If given a function descriptor symbol, hide both the function code
7290    sym and the descriptor.  */
7291 static void
7292 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7293                        struct elf_link_hash_entry *h,
7294                        bfd_boolean force_local)
7295 {
7296   struct ppc_link_hash_entry *eh;
7297   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7298
7299   eh = (struct ppc_link_hash_entry *) h;
7300   if (eh->is_func_descriptor)
7301     {
7302       struct ppc_link_hash_entry *fh = eh->oh;
7303
7304       if (fh == NULL)
7305         {
7306           const char *p, *q;
7307           struct ppc_link_hash_table *htab;
7308           char save;
7309
7310           /* We aren't supposed to use alloca in BFD because on
7311              systems which do not have alloca the version in libiberty
7312              calls xmalloc, which might cause the program to crash
7313              when it runs out of memory.  This function doesn't have a
7314              return status, so there's no way to gracefully return an
7315              error.  So cheat.  We know that string[-1] can be safely
7316              accessed;  It's either a string in an ELF string table,
7317              or allocated in an objalloc structure.  */
7318
7319           p = eh->elf.root.root.string - 1;
7320           save = *p;
7321           *(char *) p = '.';
7322           htab = ppc_hash_table (info);
7323           if (htab == NULL)
7324             return;
7325
7326           fh = (struct ppc_link_hash_entry *)
7327             elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7328           *(char *) p = save;
7329
7330           /* Unfortunately, if it so happens that the string we were
7331              looking for was allocated immediately before this string,
7332              then we overwrote the string terminator.  That's the only
7333              reason the lookup should fail.  */
7334           if (fh == NULL)
7335             {
7336               q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7337               while (q >= eh->elf.root.root.string && *q == *p)
7338                 --q, --p;
7339               if (q < eh->elf.root.root.string && *p == '.')
7340                 fh = (struct ppc_link_hash_entry *)
7341                   elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7342             }
7343           if (fh != NULL)
7344             {
7345               eh->oh = fh;
7346               fh->oh = eh;
7347             }
7348         }
7349       if (fh != NULL)
7350         _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7351     }
7352 }
7353
7354 static bfd_boolean
7355 get_sym_h (struct elf_link_hash_entry **hp,
7356            Elf_Internal_Sym **symp,
7357            asection **symsecp,
7358            unsigned char **tls_maskp,
7359            Elf_Internal_Sym **locsymsp,
7360            unsigned long r_symndx,
7361            bfd *ibfd)
7362 {
7363   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7364
7365   if (r_symndx >= symtab_hdr->sh_info)
7366     {
7367       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7368       struct elf_link_hash_entry *h;
7369
7370       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7371       h = elf_follow_link (h);
7372
7373       if (hp != NULL)
7374         *hp = h;
7375
7376       if (symp != NULL)
7377         *symp = NULL;
7378
7379       if (symsecp != NULL)
7380         {
7381           asection *symsec = NULL;
7382           if (h->root.type == bfd_link_hash_defined
7383               || h->root.type == bfd_link_hash_defweak)
7384             symsec = h->root.u.def.section;
7385           *symsecp = symsec;
7386         }
7387
7388       if (tls_maskp != NULL)
7389         {
7390           struct ppc_link_hash_entry *eh;
7391
7392           eh = (struct ppc_link_hash_entry *) h;
7393           *tls_maskp = &eh->tls_mask;
7394         }
7395     }
7396   else
7397     {
7398       Elf_Internal_Sym *sym;
7399       Elf_Internal_Sym *locsyms = *locsymsp;
7400
7401       if (locsyms == NULL)
7402         {
7403           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7404           if (locsyms == NULL)
7405             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7406                                             symtab_hdr->sh_info,
7407                                             0, NULL, NULL, NULL);
7408           if (locsyms == NULL)
7409             return FALSE;
7410           *locsymsp = locsyms;
7411         }
7412       sym = locsyms + r_symndx;
7413
7414       if (hp != NULL)
7415         *hp = NULL;
7416
7417       if (symp != NULL)
7418         *symp = sym;
7419
7420       if (symsecp != NULL)
7421         *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7422
7423       if (tls_maskp != NULL)
7424         {
7425           struct got_entry **lgot_ents;
7426           unsigned char *tls_mask;
7427
7428           tls_mask = NULL;
7429           lgot_ents = elf_local_got_ents (ibfd);
7430           if (lgot_ents != NULL)
7431             {
7432               struct plt_entry **local_plt = (struct plt_entry **)
7433                 (lgot_ents + symtab_hdr->sh_info);
7434               unsigned char *lgot_masks = (unsigned char *)
7435                 (local_plt + symtab_hdr->sh_info);
7436               tls_mask = &lgot_masks[r_symndx];
7437             }
7438           *tls_maskp = tls_mask;
7439         }
7440     }
7441   return TRUE;
7442 }
7443
7444 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
7445    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7446    type suitable for optimization, and 1 otherwise.  */
7447
7448 static int
7449 get_tls_mask (unsigned char **tls_maskp,
7450               unsigned long *toc_symndx,
7451               bfd_vma *toc_addend,
7452               Elf_Internal_Sym **locsymsp,
7453               const Elf_Internal_Rela *rel,
7454               bfd *ibfd)
7455 {
7456   unsigned long r_symndx;
7457   int next_r;
7458   struct elf_link_hash_entry *h;
7459   Elf_Internal_Sym *sym;
7460   asection *sec;
7461   bfd_vma off;
7462
7463   r_symndx = ELF64_R_SYM (rel->r_info);
7464   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7465     return 0;
7466
7467   if ((*tls_maskp != NULL && **tls_maskp != 0)
7468       || sec == NULL
7469       || ppc64_elf_section_data (sec) == NULL
7470       || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7471     return 1;
7472
7473   /* Look inside a TOC section too.  */
7474   if (h != NULL)
7475     {
7476       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7477       off = h->root.u.def.value;
7478     }
7479   else
7480     off = sym->st_value;
7481   off += rel->r_addend;
7482   BFD_ASSERT (off % 8 == 0);
7483   r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7484   next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7485   if (toc_symndx != NULL)
7486     *toc_symndx = r_symndx;
7487   if (toc_addend != NULL)
7488     *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7489   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7490     return 0;
7491   if ((h == NULL || is_static_defined (h))
7492       && (next_r == -1 || next_r == -2))
7493     return 1 - next_r;
7494   return 1;
7495 }
7496
7497 /* Find (or create) an entry in the tocsave hash table.  */
7498
7499 static struct tocsave_entry *
7500 tocsave_find (struct ppc_link_hash_table *htab,
7501               enum insert_option insert,
7502               Elf_Internal_Sym **local_syms,
7503               const Elf_Internal_Rela *irela,
7504               bfd *ibfd)
7505 {
7506   unsigned long r_indx;
7507   struct elf_link_hash_entry *h;
7508   Elf_Internal_Sym *sym;
7509   struct tocsave_entry ent, *p;
7510   hashval_t hash;
7511   struct tocsave_entry **slot;
7512
7513   r_indx = ELF64_R_SYM (irela->r_info);
7514   if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7515     return NULL;
7516   if (ent.sec == NULL || ent.sec->output_section == NULL)
7517     {
7518       (*_bfd_error_handler)
7519         (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"));
7520       return NULL;
7521     }
7522
7523   if (h != NULL)
7524     ent.offset = h->root.u.def.value;
7525   else
7526     ent.offset = sym->st_value;
7527   ent.offset += irela->r_addend;
7528
7529   hash = tocsave_htab_hash (&ent);
7530   slot = ((struct tocsave_entry **)
7531           htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7532   if (slot == NULL)
7533     return NULL;
7534
7535   if (*slot == NULL)
7536     {
7537       p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7538       if (p == NULL)
7539         return NULL;
7540       *p = ent;
7541       *slot = p;
7542     }
7543   return *slot;
7544 }
7545
7546 /* Adjust all global syms defined in opd sections.  In gcc generated
7547    code for the old ABI, these will already have been done.  */
7548
7549 static bfd_boolean
7550 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7551 {
7552   struct ppc_link_hash_entry *eh;
7553   asection *sym_sec;
7554   struct _opd_sec_data *opd;
7555
7556   if (h->root.type == bfd_link_hash_indirect)
7557     return TRUE;
7558
7559   if (h->root.type != bfd_link_hash_defined
7560       && h->root.type != bfd_link_hash_defweak)
7561     return TRUE;
7562
7563   eh = (struct ppc_link_hash_entry *) h;
7564   if (eh->adjust_done)
7565     return TRUE;
7566
7567   sym_sec = eh->elf.root.u.def.section;
7568   opd = get_opd_info (sym_sec);
7569   if (opd != NULL && opd->adjust != NULL)
7570     {
7571       long adjust = opd->adjust[OPD_NDX (eh->elf.root.u.def.value)];
7572       if (adjust == -1)
7573         {
7574           /* This entry has been deleted.  */
7575           asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7576           if (dsec == NULL)
7577             {
7578               for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7579                 if (discarded_section (dsec))
7580                   {
7581                     ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7582                     break;
7583                   }
7584             }
7585           eh->elf.root.u.def.value = 0;
7586           eh->elf.root.u.def.section = dsec;
7587         }
7588       else
7589         eh->elf.root.u.def.value += adjust;
7590       eh->adjust_done = 1;
7591     }
7592   return TRUE;
7593 }
7594
7595 /* Handles decrementing dynamic reloc counts for the reloc specified by
7596    R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM
7597    have already been determined.  */
7598
7599 static bfd_boolean
7600 dec_dynrel_count (bfd_vma r_info,
7601                   asection *sec,
7602                   struct bfd_link_info *info,
7603                   Elf_Internal_Sym **local_syms,
7604                   struct elf_link_hash_entry *h,
7605                   Elf_Internal_Sym *sym)
7606 {
7607   enum elf_ppc64_reloc_type r_type;
7608   asection *sym_sec = NULL;
7609
7610   /* Can this reloc be dynamic?  This switch, and later tests here
7611      should be kept in sync with the code in check_relocs.  */
7612   r_type = ELF64_R_TYPE (r_info);
7613   switch (r_type)
7614     {
7615     default:
7616       return TRUE;
7617
7618     case R_PPC64_TPREL16:
7619     case R_PPC64_TPREL16_LO:
7620     case R_PPC64_TPREL16_HI:
7621     case R_PPC64_TPREL16_HA:
7622     case R_PPC64_TPREL16_DS:
7623     case R_PPC64_TPREL16_LO_DS:
7624     case R_PPC64_TPREL16_HIGH:
7625     case R_PPC64_TPREL16_HIGHA:
7626     case R_PPC64_TPREL16_HIGHER:
7627     case R_PPC64_TPREL16_HIGHERA:
7628     case R_PPC64_TPREL16_HIGHEST:
7629     case R_PPC64_TPREL16_HIGHESTA:
7630       if (!bfd_link_pic (info))
7631         return TRUE;
7632
7633     case R_PPC64_TPREL64:
7634     case R_PPC64_DTPMOD64:
7635     case R_PPC64_DTPREL64:
7636     case R_PPC64_ADDR64:
7637     case R_PPC64_REL30:
7638     case R_PPC64_REL32:
7639     case R_PPC64_REL64:
7640     case R_PPC64_ADDR14:
7641     case R_PPC64_ADDR14_BRNTAKEN:
7642     case R_PPC64_ADDR14_BRTAKEN:
7643     case R_PPC64_ADDR16:
7644     case R_PPC64_ADDR16_DS:
7645     case R_PPC64_ADDR16_HA:
7646     case R_PPC64_ADDR16_HI:
7647     case R_PPC64_ADDR16_HIGH:
7648     case R_PPC64_ADDR16_HIGHA:
7649     case R_PPC64_ADDR16_HIGHER:
7650     case R_PPC64_ADDR16_HIGHERA:
7651     case R_PPC64_ADDR16_HIGHEST:
7652     case R_PPC64_ADDR16_HIGHESTA:
7653     case R_PPC64_ADDR16_LO:
7654     case R_PPC64_ADDR16_LO_DS:
7655     case R_PPC64_ADDR24:
7656     case R_PPC64_ADDR32:
7657     case R_PPC64_UADDR16:
7658     case R_PPC64_UADDR32:
7659     case R_PPC64_UADDR64:
7660     case R_PPC64_TOC:
7661       break;
7662     }
7663
7664   if (local_syms != NULL)
7665     {
7666       unsigned long r_symndx;
7667       bfd *ibfd = sec->owner;
7668
7669       r_symndx = ELF64_R_SYM (r_info);
7670       if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7671         return FALSE;
7672     }
7673
7674   if ((bfd_link_pic (info)
7675        && (must_be_dyn_reloc (info, r_type)
7676            || (h != NULL
7677                && (!SYMBOLIC_BIND (info, h)
7678                    || h->root.type == bfd_link_hash_defweak
7679                    || !h->def_regular))))
7680       || (ELIMINATE_COPY_RELOCS
7681           && !bfd_link_pic (info)
7682           && h != NULL
7683           && (h->root.type == bfd_link_hash_defweak
7684               || !h->def_regular)))
7685     ;
7686   else
7687     return TRUE;
7688
7689   if (h != NULL)
7690     {
7691       struct elf_dyn_relocs *p;
7692       struct elf_dyn_relocs **pp;
7693       pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7694
7695       /* elf_gc_sweep may have already removed all dyn relocs associated
7696          with local syms for a given section.  Also, symbol flags are
7697          changed by elf_gc_sweep_symbol, confusing the test above.  Don't
7698          report a dynreloc miscount.  */
7699       if (*pp == NULL && info->gc_sections)
7700         return TRUE;
7701
7702       while ((p = *pp) != NULL)
7703         {
7704           if (p->sec == sec)
7705             {
7706               if (!must_be_dyn_reloc (info, r_type))
7707                 p->pc_count -= 1;
7708               p->count -= 1;
7709               if (p->count == 0)
7710                 *pp = p->next;
7711               return TRUE;
7712             }
7713           pp = &p->next;
7714         }
7715     }
7716   else
7717     {
7718       struct ppc_dyn_relocs *p;
7719       struct ppc_dyn_relocs **pp;
7720       void *vpp;
7721       bfd_boolean is_ifunc;
7722
7723       if (local_syms == NULL)
7724         sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7725       if (sym_sec == NULL)
7726         sym_sec = sec;
7727
7728       vpp = &elf_section_data (sym_sec)->local_dynrel;
7729       pp = (struct ppc_dyn_relocs **) vpp;
7730
7731       if (*pp == NULL && info->gc_sections)
7732         return TRUE;
7733
7734       is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7735       while ((p = *pp) != NULL)
7736         {
7737           if (p->sec == sec && p->ifunc == is_ifunc)
7738             {
7739               p->count -= 1;
7740               if (p->count == 0)
7741                 *pp = p->next;
7742               return TRUE;
7743             }
7744           pp = &p->next;
7745         }
7746     }
7747
7748   info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7749                           sec->owner, sec);
7750   bfd_set_error (bfd_error_bad_value);
7751   return FALSE;
7752 }
7753
7754 /* Remove unused Official Procedure Descriptor entries.  Currently we
7755    only remove those associated with functions in discarded link-once
7756    sections, or weakly defined functions that have been overridden.  It
7757    would be possible to remove many more entries for statically linked
7758    applications.  */
7759
7760 bfd_boolean
7761 ppc64_elf_edit_opd (struct bfd_link_info *info)
7762 {
7763   bfd *ibfd;
7764   bfd_boolean some_edited = FALSE;
7765   asection *need_pad = NULL;
7766   struct ppc_link_hash_table *htab;
7767
7768   htab = ppc_hash_table (info);
7769   if (htab == NULL)
7770     return FALSE;
7771
7772   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
7773     {
7774       asection *sec;
7775       Elf_Internal_Rela *relstart, *rel, *relend;
7776       Elf_Internal_Shdr *symtab_hdr;
7777       Elf_Internal_Sym *local_syms;
7778       struct _opd_sec_data *opd;
7779       bfd_boolean need_edit, add_aux_fields, broken;
7780       bfd_size_type cnt_16b = 0;
7781
7782       if (!is_ppc64_elf (ibfd))
7783         continue;
7784
7785       sec = bfd_get_section_by_name (ibfd, ".opd");
7786       if (sec == NULL || sec->size == 0)
7787         continue;
7788
7789       if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7790         continue;
7791
7792       if (sec->output_section == bfd_abs_section_ptr)
7793         continue;
7794
7795       /* Look through the section relocs.  */
7796       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7797         continue;
7798
7799       local_syms = NULL;
7800       symtab_hdr = &elf_symtab_hdr (ibfd);
7801
7802       /* Read the relocations.  */
7803       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7804                                             info->keep_memory);
7805       if (relstart == NULL)
7806         return FALSE;
7807
7808       /* First run through the relocs to check they are sane, and to
7809          determine whether we need to edit this opd section.  */
7810       need_edit = FALSE;
7811       broken = FALSE;
7812       need_pad = sec;
7813       relend = relstart + sec->reloc_count;
7814       for (rel = relstart; rel < relend; )
7815         {
7816           enum elf_ppc64_reloc_type r_type;
7817           unsigned long r_symndx;
7818           asection *sym_sec;
7819           struct elf_link_hash_entry *h;
7820           Elf_Internal_Sym *sym;
7821           bfd_vma offset;
7822
7823           /* .opd contains an array of 16 or 24 byte entries.  We're
7824              only interested in the reloc pointing to a function entry
7825              point.  */
7826           offset = rel->r_offset;
7827           if (rel + 1 == relend
7828               || rel[1].r_offset != offset + 8)
7829             {
7830               /* If someone messes with .opd alignment then after a
7831                  "ld -r" we might have padding in the middle of .opd.
7832                  Also, there's nothing to prevent someone putting
7833                  something silly in .opd with the assembler.  No .opd
7834                  optimization for them!  */
7835             broken_opd:
7836               (*_bfd_error_handler)
7837                 (_("%B: .opd is not a regular array of opd entries"), ibfd);
7838               broken = TRUE;
7839               break;
7840             }
7841
7842           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7843               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7844             {
7845               (*_bfd_error_handler)
7846                 (_("%B: unexpected reloc type %u in .opd section"),
7847                  ibfd, r_type);
7848               broken = TRUE;
7849               break;
7850             }
7851
7852           r_symndx = ELF64_R_SYM (rel->r_info);
7853           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7854                           r_symndx, ibfd))
7855             goto error_ret;
7856
7857           if (sym_sec == NULL || sym_sec->owner == NULL)
7858             {
7859               const char *sym_name;
7860               if (h != NULL)
7861                 sym_name = h->root.root.string;
7862               else
7863                 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7864                                              sym_sec);
7865
7866               (*_bfd_error_handler)
7867                 (_("%B: undefined sym `%s' in .opd section"),
7868                  ibfd, sym_name);
7869               broken = TRUE;
7870               break;
7871             }
7872
7873           /* opd entries are always for functions defined in the
7874              current input bfd.  If the symbol isn't defined in the
7875              input bfd, then we won't be using the function in this
7876              bfd;  It must be defined in a linkonce section in another
7877              bfd, or is weak.  It's also possible that we are
7878              discarding the function due to a linker script /DISCARD/,
7879              which we test for via the output_section.  */
7880           if (sym_sec->owner != ibfd
7881               || sym_sec->output_section == bfd_abs_section_ptr)
7882             need_edit = TRUE;
7883
7884           rel += 2;
7885           if (rel + 1 == relend
7886               || (rel + 2 < relend
7887                   && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC))
7888             ++rel;
7889
7890           if (rel == relend)
7891             {
7892               if (sec->size == offset + 24)
7893                 {
7894                   need_pad = NULL;
7895                   break;
7896                 }
7897               if (sec->size == offset + 16)
7898                 {
7899                   cnt_16b++;
7900                   break;
7901                 }
7902               goto broken_opd;
7903             }
7904           else if (rel + 1 < relend
7905                    && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7906                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7907             {
7908               if (rel[0].r_offset == offset + 16)
7909                 cnt_16b++;
7910               else if (rel[0].r_offset != offset + 24)
7911                 goto broken_opd;
7912             }
7913           else
7914             goto broken_opd;
7915         }
7916
7917       add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
7918
7919       if (!broken && (need_edit || add_aux_fields))
7920         {
7921           Elf_Internal_Rela *write_rel;
7922           Elf_Internal_Shdr *rel_hdr;
7923           bfd_byte *rptr, *wptr;
7924           bfd_byte *new_contents;
7925           bfd_size_type amt;
7926
7927           new_contents = NULL;
7928           amt = OPD_NDX (sec->size) * sizeof (long);
7929           opd = &ppc64_elf_section_data (sec)->u.opd;
7930           opd->adjust = bfd_zalloc (sec->owner, amt);
7931           if (opd->adjust == NULL)
7932             return FALSE;
7933           ppc64_elf_section_data (sec)->sec_type = sec_opd;
7934
7935           /* This seems a waste of time as input .opd sections are all
7936              zeros as generated by gcc, but I suppose there's no reason
7937              this will always be so.  We might start putting something in
7938              the third word of .opd entries.  */
7939           if ((sec->flags & SEC_IN_MEMORY) == 0)
7940             {
7941               bfd_byte *loc;
7942               if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7943                 {
7944                   if (loc != NULL)
7945                     free (loc);
7946                 error_ret:
7947                   if (local_syms != NULL
7948                       && symtab_hdr->contents != (unsigned char *) local_syms)
7949                     free (local_syms);
7950                   if (elf_section_data (sec)->relocs != relstart)
7951                     free (relstart);
7952                   return FALSE;
7953                 }
7954               sec->contents = loc;
7955               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7956             }
7957
7958           elf_section_data (sec)->relocs = relstart;
7959
7960           new_contents = sec->contents;
7961           if (add_aux_fields)
7962             {
7963               new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7964               if (new_contents == NULL)
7965                 return FALSE;
7966               need_pad = NULL;
7967             }
7968           wptr = new_contents;
7969           rptr = sec->contents;
7970           write_rel = relstart;
7971           for (rel = relstart; rel < relend; )
7972             {
7973               unsigned long r_symndx;
7974               asection *sym_sec;
7975               struct elf_link_hash_entry *h;
7976               struct ppc_link_hash_entry *fdh = NULL;
7977               Elf_Internal_Sym *sym;
7978               long opd_ent_size;
7979               Elf_Internal_Rela *next_rel;
7980               bfd_boolean skip;
7981
7982               r_symndx = ELF64_R_SYM (rel->r_info);
7983               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7984                               r_symndx, ibfd))
7985                 goto error_ret;
7986
7987               next_rel = rel + 2;
7988               if (next_rel + 1 == relend
7989                   || (next_rel + 2 < relend
7990                       && ELF64_R_TYPE (next_rel[2].r_info) == R_PPC64_TOC))
7991                 ++next_rel;
7992
7993               /* See if the .opd entry is full 24 byte or
7994                  16 byte (with fd_aux entry overlapped with next
7995                  fd_func).  */
7996               opd_ent_size = 24;
7997               if (next_rel == relend)
7998                 {
7999                   if (sec->size == rel->r_offset + 16)
8000                     opd_ent_size = 16;
8001                 }
8002               else if (next_rel->r_offset == rel->r_offset + 16)
8003                 opd_ent_size = 16;
8004
8005               if (h != NULL
8006                   && h->root.root.string[0] == '.')
8007                 {
8008                   fdh = lookup_fdh ((struct ppc_link_hash_entry *) h, htab);
8009                   if (fdh != NULL
8010                       && fdh->elf.root.type != bfd_link_hash_defined
8011                       && fdh->elf.root.type != bfd_link_hash_defweak)
8012                     fdh = NULL;
8013                 }
8014
8015               skip = (sym_sec->owner != ibfd
8016                       || sym_sec->output_section == bfd_abs_section_ptr);
8017               if (skip)
8018                 {
8019                   if (fdh != NULL && sym_sec->owner == ibfd)
8020                     {
8021                       /* Arrange for the function descriptor sym
8022                          to be dropped.  */
8023                       fdh->elf.root.u.def.value = 0;
8024                       fdh->elf.root.u.def.section = sym_sec;
8025                     }
8026                   opd->adjust[OPD_NDX (rel->r_offset)] = -1;
8027
8028                   if (NO_OPD_RELOCS || bfd_link_relocatable (info))
8029                     rel = next_rel;
8030                   else
8031                     while (1)
8032                       {
8033                         if (!dec_dynrel_count (rel->r_info, sec, info,
8034                                                NULL, h, sym))
8035                           goto error_ret;
8036
8037                         if (++rel == next_rel)
8038                           break;
8039
8040                         r_symndx = ELF64_R_SYM (rel->r_info);
8041                         if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8042                                         r_symndx, ibfd))
8043                           goto error_ret;
8044                       }
8045                 }
8046               else
8047                 {
8048                   /* We'll be keeping this opd entry.  */
8049                   long adjust;
8050
8051                   if (fdh != NULL)
8052                     {
8053                       /* Redefine the function descriptor symbol to
8054                          this location in the opd section.  It is
8055                          necessary to update the value here rather
8056                          than using an array of adjustments as we do
8057                          for local symbols, because various places
8058                          in the generic ELF code use the value
8059                          stored in u.def.value.  */
8060                       fdh->elf.root.u.def.value = wptr - new_contents;
8061                       fdh->adjust_done = 1;
8062                     }
8063
8064                   /* Local syms are a bit tricky.  We could
8065                      tweak them as they can be cached, but
8066                      we'd need to look through the local syms
8067                      for the function descriptor sym which we
8068                      don't have at the moment.  So keep an
8069                      array of adjustments.  */
8070                   adjust = (wptr - new_contents) - (rptr - sec->contents);
8071                   opd->adjust[OPD_NDX (rel->r_offset)] = adjust;
8072
8073                   if (wptr != rptr)
8074                     memcpy (wptr, rptr, opd_ent_size);
8075                   wptr += opd_ent_size;
8076                   if (add_aux_fields && opd_ent_size == 16)
8077                     {
8078                       memset (wptr, '\0', 8);
8079                       wptr += 8;
8080                     }
8081
8082                   /* We need to adjust any reloc offsets to point to the
8083                      new opd entries.  */
8084                   for ( ; rel != next_rel; ++rel)
8085                     {
8086                       rel->r_offset += adjust;
8087                       if (write_rel != rel)
8088                         memcpy (write_rel, rel, sizeof (*rel));
8089                       ++write_rel;
8090                     }
8091                 }
8092
8093               rptr += opd_ent_size;
8094             }
8095
8096           sec->size = wptr - new_contents;
8097           sec->reloc_count = write_rel - relstart;
8098           if (add_aux_fields)
8099             {
8100               free (sec->contents);
8101               sec->contents = new_contents;
8102             }
8103
8104           /* Fudge the header size too, as this is used later in
8105              elf_bfd_final_link if we are emitting relocs.  */
8106           rel_hdr = _bfd_elf_single_rel_hdr (sec);
8107           rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
8108           some_edited = TRUE;
8109         }
8110       else if (elf_section_data (sec)->relocs != relstart)
8111         free (relstart);
8112
8113       if (local_syms != NULL
8114           && symtab_hdr->contents != (unsigned char *) local_syms)
8115         {
8116           if (!info->keep_memory)
8117             free (local_syms);
8118           else
8119             symtab_hdr->contents = (unsigned char *) local_syms;
8120         }
8121     }
8122
8123   if (some_edited)
8124     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
8125
8126   /* If we are doing a final link and the last .opd entry is just 16 byte
8127      long, add a 8 byte padding after it.  */
8128   if (need_pad != NULL && !bfd_link_relocatable (info))
8129     {
8130       bfd_byte *p;
8131
8132       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
8133         {
8134           BFD_ASSERT (need_pad->size > 0);
8135
8136           p = bfd_malloc (need_pad->size + 8);
8137           if (p == NULL)
8138             return FALSE;
8139
8140           if (! bfd_get_section_contents (need_pad->owner, need_pad,
8141                                           p, 0, need_pad->size))
8142             return FALSE;
8143
8144           need_pad->contents = p;
8145           need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8146         }
8147       else
8148         {
8149           p = bfd_realloc (need_pad->contents, need_pad->size + 8);
8150           if (p == NULL)
8151             return FALSE;
8152
8153           need_pad->contents = p;
8154         }
8155
8156       memset (need_pad->contents + need_pad->size, 0, 8);
8157       need_pad->size += 8;
8158     }
8159
8160   return TRUE;
8161 }
8162
8163 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
8164
8165 asection *
8166 ppc64_elf_tls_setup (struct bfd_link_info *info)
8167 {
8168   struct ppc_link_hash_table *htab;
8169
8170   htab = ppc_hash_table (info);
8171   if (htab == NULL)
8172     return NULL;
8173
8174   if (abiversion (info->output_bfd) == 1)
8175     htab->opd_abi = 1;
8176
8177   if (htab->params->no_multi_toc)
8178     htab->do_multi_toc = 0;
8179   else if (!htab->do_multi_toc)
8180     htab->params->no_multi_toc = 1;
8181
8182   htab->tls_get_addr = ((struct ppc_link_hash_entry *)
8183                         elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
8184                                               FALSE, FALSE, TRUE));
8185   /* Move dynamic linking info to the function descriptor sym.  */
8186   if (htab->tls_get_addr != NULL)
8187     func_desc_adjust (&htab->tls_get_addr->elf, info);
8188   htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
8189                            elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
8190                                                  FALSE, FALSE, TRUE));
8191   if (htab->params->tls_get_addr_opt)
8192     {
8193       struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
8194
8195       opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
8196                                   FALSE, FALSE, TRUE);
8197       if (opt != NULL)
8198         func_desc_adjust (opt, info);
8199       opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
8200                                      FALSE, FALSE, TRUE);
8201       if (opt_fd != NULL
8202           && (opt_fd->root.type == bfd_link_hash_defined
8203               || opt_fd->root.type == bfd_link_hash_defweak))
8204         {
8205           /* If glibc supports an optimized __tls_get_addr call stub,
8206              signalled by the presence of __tls_get_addr_opt, and we'll
8207              be calling __tls_get_addr via a plt call stub, then
8208              make __tls_get_addr point to __tls_get_addr_opt.  */
8209           tga_fd = &htab->tls_get_addr_fd->elf;
8210           if (htab->elf.dynamic_sections_created
8211               && tga_fd != NULL
8212               && (tga_fd->type == STT_FUNC
8213                   || tga_fd->needs_plt)
8214               && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
8215                    || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
8216                        && tga_fd->root.type == bfd_link_hash_undefweak)))
8217             {
8218               struct plt_entry *ent;
8219
8220               for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
8221                 if (ent->plt.refcount > 0)
8222                   break;
8223               if (ent != NULL)
8224                 {
8225                   tga_fd->root.type = bfd_link_hash_indirect;
8226                   tga_fd->root.u.i.link = &opt_fd->root;
8227                   ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
8228                   opt_fd->forced_local = 0;
8229                   if (opt_fd->dynindx != -1)
8230                     {
8231                       /* Use __tls_get_addr_opt in dynamic relocations.  */
8232                       opt_fd->dynindx = -1;
8233                       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8234                                               opt_fd->dynstr_index);
8235                       if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8236                         return NULL;
8237                     }
8238                   htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8239                   tga = &htab->tls_get_addr->elf;
8240                   if (opt != NULL && tga != NULL)
8241                     {
8242                       tga->root.type = bfd_link_hash_indirect;
8243                       tga->root.u.i.link = &opt->root;
8244                       ppc64_elf_copy_indirect_symbol (info, opt, tga);
8245                       opt->forced_local = 0;
8246                       _bfd_elf_link_hash_hide_symbol (info, opt,
8247                                                       tga->forced_local);
8248                       htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8249                     }
8250                   htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8251                   htab->tls_get_addr_fd->is_func_descriptor = 1;
8252                   if (htab->tls_get_addr != NULL)
8253                     {
8254                       htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8255                       htab->tls_get_addr->is_func = 1;
8256                     }
8257                 }
8258             }
8259         }
8260       else if (htab->params->tls_get_addr_opt < 0)
8261         htab->params->tls_get_addr_opt = 0;
8262     }
8263   return _bfd_elf_tls_setup (info->output_bfd, info);
8264 }
8265
8266 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8267    HASH1 or HASH2.  */
8268
8269 static bfd_boolean
8270 branch_reloc_hash_match (const bfd *ibfd,
8271                          const Elf_Internal_Rela *rel,
8272                          const struct ppc_link_hash_entry *hash1,
8273                          const struct ppc_link_hash_entry *hash2)
8274 {
8275   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8276   enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8277   unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8278
8279   if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8280     {
8281       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8282       struct elf_link_hash_entry *h;
8283
8284       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8285       h = elf_follow_link (h);
8286       if (h == &hash1->elf || h == &hash2->elf)
8287         return TRUE;
8288     }
8289   return FALSE;
8290 }
8291
8292 /* Run through all the TLS relocs looking for optimization
8293    opportunities.  The linker has been hacked (see ppc64elf.em) to do
8294    a preliminary section layout so that we know the TLS segment
8295    offsets.  We can't optimize earlier because some optimizations need
8296    to know the tp offset, and we need to optimize before allocating
8297    dynamic relocations.  */
8298
8299 bfd_boolean
8300 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8301 {
8302   bfd *ibfd;
8303   asection *sec;
8304   struct ppc_link_hash_table *htab;
8305   unsigned char *toc_ref;
8306   int pass;
8307
8308   if (!bfd_link_executable (info))
8309     return TRUE;
8310
8311   htab = ppc_hash_table (info);
8312   if (htab == NULL)
8313     return FALSE;
8314
8315   /* Make two passes over the relocs.  On the first pass, mark toc
8316      entries involved with tls relocs, and check that tls relocs
8317      involved in setting up a tls_get_addr call are indeed followed by
8318      such a call.  If they are not, we can't do any tls optimization.
8319      On the second pass twiddle tls_mask flags to notify
8320      relocate_section that optimization can be done, and adjust got
8321      and plt refcounts.  */
8322   toc_ref = NULL;
8323   for (pass = 0; pass < 2; ++pass)
8324     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8325       {
8326         Elf_Internal_Sym *locsyms = NULL;
8327         asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8328
8329         for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8330           if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8331             {
8332               Elf_Internal_Rela *relstart, *rel, *relend;
8333               bfd_boolean found_tls_get_addr_arg = 0;
8334
8335               /* Read the relocations.  */
8336               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8337                                                     info->keep_memory);
8338               if (relstart == NULL)
8339                 {
8340                   free (toc_ref);
8341                   return FALSE;
8342                 }
8343
8344               relend = relstart + sec->reloc_count;
8345               for (rel = relstart; rel < relend; rel++)
8346                 {
8347                   enum elf_ppc64_reloc_type r_type;
8348                   unsigned long r_symndx;
8349                   struct elf_link_hash_entry *h;
8350                   Elf_Internal_Sym *sym;
8351                   asection *sym_sec;
8352                   unsigned char *tls_mask;
8353                   unsigned char tls_set, tls_clear, tls_type = 0;
8354                   bfd_vma value;
8355                   bfd_boolean ok_tprel, is_local;
8356                   long toc_ref_index = 0;
8357                   int expecting_tls_get_addr = 0;
8358                   bfd_boolean ret = FALSE;
8359
8360                   r_symndx = ELF64_R_SYM (rel->r_info);
8361                   if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8362                                   r_symndx, ibfd))
8363                     {
8364                     err_free_rel:
8365                       if (elf_section_data (sec)->relocs != relstart)
8366                         free (relstart);
8367                       if (toc_ref != NULL)
8368                         free (toc_ref);
8369                       if (locsyms != NULL
8370                           && (elf_symtab_hdr (ibfd).contents
8371                               != (unsigned char *) locsyms))
8372                         free (locsyms);
8373                       return ret;
8374                     }
8375
8376                   if (h != NULL)
8377                     {
8378                       if (h->root.type == bfd_link_hash_defined
8379                           || h->root.type == bfd_link_hash_defweak)
8380                         value = h->root.u.def.value;
8381                       else if (h->root.type == bfd_link_hash_undefweak)
8382                         value = 0;
8383                       else
8384                         {
8385                           found_tls_get_addr_arg = 0;
8386                           continue;
8387                         }
8388                     }
8389                   else
8390                     /* Symbols referenced by TLS relocs must be of type
8391                        STT_TLS.  So no need for .opd local sym adjust.  */
8392                     value = sym->st_value;
8393
8394                   ok_tprel = FALSE;
8395                   is_local = FALSE;
8396                   if (h == NULL
8397                       || !h->def_dynamic)
8398                     {
8399                       is_local = TRUE;
8400                       if (h != NULL
8401                           && h->root.type == bfd_link_hash_undefweak)
8402                         ok_tprel = TRUE;
8403                       else if (sym_sec != NULL
8404                                && sym_sec->output_section != NULL)
8405                         {
8406                           value += sym_sec->output_offset;
8407                           value += sym_sec->output_section->vma;
8408                           value -= htab->elf.tls_sec->vma;
8409                           ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8410                                       < (bfd_vma) 1 << 32);
8411                         }
8412                     }
8413
8414                   r_type = ELF64_R_TYPE (rel->r_info);
8415                   /* If this section has old-style __tls_get_addr calls
8416                      without marker relocs, then check that each
8417                      __tls_get_addr call reloc is preceded by a reloc
8418                      that conceivably belongs to the __tls_get_addr arg
8419                      setup insn.  If we don't find matching arg setup
8420                      relocs, don't do any tls optimization.  */
8421                   if (pass == 0
8422                       && sec->has_tls_get_addr_call
8423                       && h != NULL
8424                       && (h == &htab->tls_get_addr->elf
8425                           || h == &htab->tls_get_addr_fd->elf)
8426                       && !found_tls_get_addr_arg
8427                       && is_branch_reloc (r_type))
8428                     {
8429                       info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8430                                                 "TLS optimization disabled\n"),
8431                                               ibfd, sec, rel->r_offset);
8432                       ret = TRUE;
8433                       goto err_free_rel;
8434                     }
8435
8436                   found_tls_get_addr_arg = 0;
8437                   switch (r_type)
8438                     {
8439                     case R_PPC64_GOT_TLSLD16:
8440                     case R_PPC64_GOT_TLSLD16_LO:
8441                       expecting_tls_get_addr = 1;
8442                       found_tls_get_addr_arg = 1;
8443                       /* Fall thru */
8444
8445                     case R_PPC64_GOT_TLSLD16_HI:
8446                     case R_PPC64_GOT_TLSLD16_HA:
8447                       /* These relocs should never be against a symbol
8448                          defined in a shared lib.  Leave them alone if
8449                          that turns out to be the case.  */
8450                       if (!is_local)
8451                         continue;
8452
8453                       /* LD -> LE */
8454                       tls_set = 0;
8455                       tls_clear = TLS_LD;
8456                       tls_type = TLS_TLS | TLS_LD;
8457                       break;
8458
8459                     case R_PPC64_GOT_TLSGD16:
8460                     case R_PPC64_GOT_TLSGD16_LO:
8461                       expecting_tls_get_addr = 1;
8462                       found_tls_get_addr_arg = 1;
8463                       /* Fall thru */
8464
8465                     case R_PPC64_GOT_TLSGD16_HI:
8466                     case R_PPC64_GOT_TLSGD16_HA:
8467                       if (ok_tprel)
8468                         /* GD -> LE */
8469                         tls_set = 0;
8470                       else
8471                         /* GD -> IE */
8472                         tls_set = TLS_TLS | TLS_TPRELGD;
8473                       tls_clear = TLS_GD;
8474                       tls_type = TLS_TLS | TLS_GD;
8475                       break;
8476
8477                     case R_PPC64_GOT_TPREL16_DS:
8478                     case R_PPC64_GOT_TPREL16_LO_DS:
8479                     case R_PPC64_GOT_TPREL16_HI:
8480                     case R_PPC64_GOT_TPREL16_HA:
8481                       if (ok_tprel)
8482                         {
8483                           /* IE -> LE */
8484                           tls_set = 0;
8485                           tls_clear = TLS_TPREL;
8486                           tls_type = TLS_TLS | TLS_TPREL;
8487                           break;
8488                         }
8489                       continue;
8490
8491                     case R_PPC64_TLSGD:
8492                     case R_PPC64_TLSLD:
8493                       found_tls_get_addr_arg = 1;
8494                       /* Fall thru */
8495
8496                     case R_PPC64_TLS:
8497                     case R_PPC64_TOC16:
8498                     case R_PPC64_TOC16_LO:
8499                       if (sym_sec == NULL || sym_sec != toc)
8500                         continue;
8501
8502                       /* Mark this toc entry as referenced by a TLS
8503                          code sequence.  We can do that now in the
8504                          case of R_PPC64_TLS, and after checking for
8505                          tls_get_addr for the TOC16 relocs.  */
8506                       if (toc_ref == NULL)
8507                         toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8508                       if (toc_ref == NULL)
8509                         goto err_free_rel;
8510
8511                       if (h != NULL)
8512                         value = h->root.u.def.value;
8513                       else
8514                         value = sym->st_value;
8515                       value += rel->r_addend;
8516                       if (value % 8 != 0)
8517                         continue;
8518                       BFD_ASSERT (value < toc->size
8519                                   && toc->output_offset % 8 == 0);
8520                       toc_ref_index = (value + toc->output_offset) / 8;
8521                       if (r_type == R_PPC64_TLS
8522                           || r_type == R_PPC64_TLSGD
8523                           || r_type == R_PPC64_TLSLD)
8524                         {
8525                           toc_ref[toc_ref_index] = 1;
8526                           continue;
8527                         }
8528
8529                       if (pass != 0 && toc_ref[toc_ref_index] == 0)
8530                         continue;
8531
8532                       tls_set = 0;
8533                       tls_clear = 0;
8534                       expecting_tls_get_addr = 2;
8535                       break;
8536
8537                     case R_PPC64_TPREL64:
8538                       if (pass == 0
8539                           || sec != toc
8540                           || toc_ref == NULL
8541                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8542                         continue;
8543                       if (ok_tprel)
8544                         {
8545                           /* IE -> LE */
8546                           tls_set = TLS_EXPLICIT;
8547                           tls_clear = TLS_TPREL;
8548                           break;
8549                         }
8550                       continue;
8551
8552                     case R_PPC64_DTPMOD64:
8553                       if (pass == 0
8554                           || sec != toc
8555                           || toc_ref == NULL
8556                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8557                         continue;
8558                       if (rel + 1 < relend
8559                           && (rel[1].r_info
8560                               == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8561                           && rel[1].r_offset == rel->r_offset + 8)
8562                         {
8563                           if (ok_tprel)
8564                             /* GD -> LE */
8565                             tls_set = TLS_EXPLICIT | TLS_GD;
8566                           else
8567                             /* GD -> IE */
8568                             tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8569                           tls_clear = TLS_GD;
8570                         }
8571                       else
8572                         {
8573                           if (!is_local)
8574                             continue;
8575
8576                           /* LD -> LE */
8577                           tls_set = TLS_EXPLICIT;
8578                           tls_clear = TLS_LD;
8579                         }
8580                       break;
8581
8582                     default:
8583                       continue;
8584                     }
8585
8586                   if (pass == 0)
8587                     {
8588                       if (!expecting_tls_get_addr
8589                           || !sec->has_tls_get_addr_call)
8590                         continue;
8591
8592                       if (rel + 1 < relend
8593                           && branch_reloc_hash_match (ibfd, rel + 1,
8594                                                       htab->tls_get_addr,
8595                                                       htab->tls_get_addr_fd))
8596                         {
8597                           if (expecting_tls_get_addr == 2)
8598                             {
8599                               /* Check for toc tls entries.  */
8600                               unsigned char *toc_tls;
8601                               int retval;
8602
8603                               retval = get_tls_mask (&toc_tls, NULL, NULL,
8604                                                      &locsyms,
8605                                                      rel, ibfd);
8606                               if (retval == 0)
8607                                 goto err_free_rel;
8608                               if (toc_tls != NULL)
8609                                 {
8610                                   if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8611                                     found_tls_get_addr_arg = 1;
8612                                   if (retval > 1)
8613                                     toc_ref[toc_ref_index] = 1;
8614                                 }
8615                             }
8616                           continue;
8617                         }
8618
8619                       if (expecting_tls_get_addr != 1)
8620                         continue;
8621
8622                       /* Uh oh, we didn't find the expected call.  We
8623                          could just mark this symbol to exclude it
8624                          from tls optimization but it's safer to skip
8625                          the entire optimization.  */
8626                       info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8627                                                 "TLS optimization disabled\n"),
8628                                               ibfd, sec, rel->r_offset);
8629                       ret = TRUE;
8630                       goto err_free_rel;
8631                     }
8632
8633                   if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8634                     {
8635                       struct plt_entry *ent;
8636                       for (ent = htab->tls_get_addr->elf.plt.plist;
8637                            ent != NULL;
8638                            ent = ent->next)
8639                         if (ent->addend == 0)
8640                           {
8641                             if (ent->plt.refcount > 0)
8642                               {
8643                                 ent->plt.refcount -= 1;
8644                                 expecting_tls_get_addr = 0;
8645                               }
8646                             break;
8647                           }
8648                     }
8649
8650                   if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8651                     {
8652                       struct plt_entry *ent;
8653                       for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8654                            ent != NULL;
8655                            ent = ent->next)
8656                         if (ent->addend == 0)
8657                           {
8658                             if (ent->plt.refcount > 0)
8659                               ent->plt.refcount -= 1;
8660                             break;
8661                           }
8662                     }
8663
8664                   if (tls_clear == 0)
8665                     continue;
8666
8667                   if ((tls_set & TLS_EXPLICIT) == 0)
8668                     {
8669                       struct got_entry *ent;
8670
8671                       /* Adjust got entry for this reloc.  */
8672                       if (h != NULL)
8673                         ent = h->got.glist;
8674                       else
8675                         ent = elf_local_got_ents (ibfd)[r_symndx];
8676
8677                       for (; ent != NULL; ent = ent->next)
8678                         if (ent->addend == rel->r_addend
8679                             && ent->owner == ibfd
8680                             && ent->tls_type == tls_type)
8681                           break;
8682                       if (ent == NULL)
8683                         abort ();
8684
8685                       if (tls_set == 0)
8686                         {
8687                           /* We managed to get rid of a got entry.  */
8688                           if (ent->got.refcount > 0)
8689                             ent->got.refcount -= 1;
8690                         }
8691                     }
8692                   else
8693                     {
8694                       /* If we got rid of a DTPMOD/DTPREL reloc pair then
8695                          we'll lose one or two dyn relocs.  */
8696                       if (!dec_dynrel_count (rel->r_info, sec, info,
8697                                              NULL, h, sym))
8698                         return FALSE;
8699
8700                       if (tls_set == (TLS_EXPLICIT | TLS_GD))
8701                         {
8702                           if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8703                                                  NULL, h, sym))
8704                             return FALSE;
8705                         }
8706                     }
8707
8708                   *tls_mask |= tls_set;
8709                   *tls_mask &= ~tls_clear;
8710                 }
8711
8712               if (elf_section_data (sec)->relocs != relstart)
8713                 free (relstart);
8714             }
8715
8716         if (locsyms != NULL
8717             && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8718           {
8719             if (!info->keep_memory)
8720               free (locsyms);
8721             else
8722               elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8723           }
8724       }
8725
8726   if (toc_ref != NULL)
8727     free (toc_ref);
8728   return TRUE;
8729 }
8730
8731 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8732    the values of any global symbols in a toc section that has been
8733    edited.  Globals in toc sections should be a rarity, so this function
8734    sets a flag if any are found in toc sections other than the one just
8735    edited, so that futher hash table traversals can be avoided.  */
8736
8737 struct adjust_toc_info
8738 {
8739   asection *toc;
8740   unsigned long *skip;
8741   bfd_boolean global_toc_syms;
8742 };
8743
8744 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8745
8746 static bfd_boolean
8747 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8748 {
8749   struct ppc_link_hash_entry *eh;
8750   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8751   unsigned long i;
8752
8753   if (h->root.type != bfd_link_hash_defined
8754       && h->root.type != bfd_link_hash_defweak)
8755     return TRUE;
8756
8757   eh = (struct ppc_link_hash_entry *) h;
8758   if (eh->adjust_done)
8759     return TRUE;
8760
8761   if (eh->elf.root.u.def.section == toc_inf->toc)
8762     {
8763       if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8764         i = toc_inf->toc->rawsize >> 3;
8765       else
8766         i = eh->elf.root.u.def.value >> 3;
8767
8768       if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8769         {
8770           (*_bfd_error_handler)
8771             (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8772           do
8773             ++i;
8774           while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8775           eh->elf.root.u.def.value = (bfd_vma) i << 3;
8776         }
8777
8778       eh->elf.root.u.def.value -= toc_inf->skip[i];
8779       eh->adjust_done = 1;
8780     }
8781   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8782     toc_inf->global_toc_syms = TRUE;
8783
8784   return TRUE;
8785 }
8786
8787 /* Return TRUE iff INSN is one we expect on a _LO variety toc/got reloc.  */
8788
8789 static bfd_boolean
8790 ok_lo_toc_insn (unsigned int insn)
8791 {
8792   return ((insn & (0x3f << 26)) == 14u << 26 /* addi */
8793           || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8794           || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8795           || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8796           || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8797           || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8798           || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8799           || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8800           || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8801           || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8802           || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8803           || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8804           || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8805           || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8806           || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
8807               && (insn & 3) != 1)
8808           || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
8809               && ((insn & 3) == 0 || (insn & 3) == 3))
8810           || (insn & (0x3f << 26)) == 12u << 26 /* addic */);
8811 }
8812
8813 /* Examine all relocs referencing .toc sections in order to remove
8814    unused .toc entries.  */
8815
8816 bfd_boolean
8817 ppc64_elf_edit_toc (struct bfd_link_info *info)
8818 {
8819   bfd *ibfd;
8820   struct adjust_toc_info toc_inf;
8821   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8822
8823   htab->do_toc_opt = 1;
8824   toc_inf.global_toc_syms = TRUE;
8825   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8826     {
8827       asection *toc, *sec;
8828       Elf_Internal_Shdr *symtab_hdr;
8829       Elf_Internal_Sym *local_syms;
8830       Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8831       unsigned long *skip, *drop;
8832       unsigned char *used;
8833       unsigned char *keep, last, some_unused;
8834
8835       if (!is_ppc64_elf (ibfd))
8836         continue;
8837
8838       toc = bfd_get_section_by_name (ibfd, ".toc");
8839       if (toc == NULL
8840           || toc->size == 0
8841           || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8842           || discarded_section (toc))
8843         continue;
8844
8845       toc_relocs = NULL;
8846       local_syms = NULL;
8847       symtab_hdr = &elf_symtab_hdr (ibfd);
8848
8849       /* Look at sections dropped from the final link.  */
8850       skip = NULL;
8851       relstart = NULL;
8852       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8853         {
8854           if (sec->reloc_count == 0
8855               || !discarded_section (sec)
8856               || get_opd_info (sec)
8857               || (sec->flags & SEC_ALLOC) == 0
8858               || (sec->flags & SEC_DEBUGGING) != 0)
8859             continue;
8860
8861           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8862           if (relstart == NULL)
8863             goto error_ret;
8864
8865           /* Run through the relocs to see which toc entries might be
8866              unused.  */
8867           for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8868             {
8869               enum elf_ppc64_reloc_type r_type;
8870               unsigned long r_symndx;
8871               asection *sym_sec;
8872               struct elf_link_hash_entry *h;
8873               Elf_Internal_Sym *sym;
8874               bfd_vma val;
8875
8876               r_type = ELF64_R_TYPE (rel->r_info);
8877               switch (r_type)
8878                 {
8879                 default:
8880                   continue;
8881
8882                 case R_PPC64_TOC16:
8883                 case R_PPC64_TOC16_LO:
8884                 case R_PPC64_TOC16_HI:
8885                 case R_PPC64_TOC16_HA:
8886                 case R_PPC64_TOC16_DS:
8887                 case R_PPC64_TOC16_LO_DS:
8888                   break;
8889                 }
8890
8891               r_symndx = ELF64_R_SYM (rel->r_info);
8892               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8893                               r_symndx, ibfd))
8894                 goto error_ret;
8895
8896               if (sym_sec != toc)
8897                 continue;
8898
8899               if (h != NULL)
8900                 val = h->root.u.def.value;
8901               else
8902                 val = sym->st_value;
8903               val += rel->r_addend;
8904
8905               if (val >= toc->size)
8906                 continue;
8907
8908               /* Anything in the toc ought to be aligned to 8 bytes.
8909                  If not, don't mark as unused.  */
8910               if (val & 7)
8911                 continue;
8912
8913               if (skip == NULL)
8914                 {
8915                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8916                   if (skip == NULL)
8917                     goto error_ret;
8918                 }
8919
8920               skip[val >> 3] = ref_from_discarded;
8921             }
8922
8923           if (elf_section_data (sec)->relocs != relstart)
8924             free (relstart);
8925         }
8926
8927       /* For largetoc loads of address constants, we can convert
8928          .  addis rx,2,addr@got@ha
8929          .  ld ry,addr@got@l(rx)
8930          to
8931          .  addis rx,2,addr@toc@ha
8932          .  addi ry,rx,addr@toc@l
8933          when addr is within 2G of the toc pointer.  This then means
8934          that the word storing "addr" in the toc is no longer needed.  */
8935
8936       if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
8937           && toc->output_section->rawsize < (bfd_vma) 1 << 31
8938           && toc->reloc_count != 0)
8939         {
8940           /* Read toc relocs.  */
8941           toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8942                                                   info->keep_memory);
8943           if (toc_relocs == NULL)
8944             goto error_ret;
8945
8946           for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8947             {
8948               enum elf_ppc64_reloc_type r_type;
8949               unsigned long r_symndx;
8950               asection *sym_sec;
8951               struct elf_link_hash_entry *h;
8952               Elf_Internal_Sym *sym;
8953               bfd_vma val, addr;
8954
8955               r_type = ELF64_R_TYPE (rel->r_info);
8956               if (r_type != R_PPC64_ADDR64)
8957                 continue;
8958
8959               r_symndx = ELF64_R_SYM (rel->r_info);
8960               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8961                               r_symndx, ibfd))
8962                 goto error_ret;
8963
8964               if (sym_sec == NULL
8965                   || sym_sec->output_section == NULL
8966                   || discarded_section (sym_sec))
8967                 continue;
8968
8969               if (!SYMBOL_REFERENCES_LOCAL (info, h))
8970                 continue;
8971
8972               if (h != NULL)
8973                 {
8974                   if (h->type == STT_GNU_IFUNC)
8975                     continue;
8976                   val = h->root.u.def.value;
8977                 }
8978               else
8979                 {
8980                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
8981                     continue;
8982                   val = sym->st_value;
8983                 }
8984               val += rel->r_addend;
8985               val += sym_sec->output_section->vma + sym_sec->output_offset;
8986
8987               /* We don't yet know the exact toc pointer value, but we
8988                  know it will be somewhere in the toc section.  Don't
8989                  optimize if the difference from any possible toc
8990                  pointer is outside [ff..f80008000, 7fff7fff].  */
8991               addr = toc->output_section->vma + TOC_BASE_OFF;
8992               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8993                 continue;
8994
8995               addr = toc->output_section->vma + toc->output_section->rawsize;
8996               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8997                 continue;
8998
8999               if (skip == NULL)
9000                 {
9001                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9002                   if (skip == NULL)
9003                     goto error_ret;
9004                 }
9005
9006               skip[rel->r_offset >> 3]
9007                 |= can_optimize | ((rel - toc_relocs) << 2);
9008             }
9009         }
9010
9011       if (skip == NULL)
9012         continue;
9013
9014       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
9015       if (used == NULL)
9016         {
9017         error_ret:
9018           if (local_syms != NULL
9019               && symtab_hdr->contents != (unsigned char *) local_syms)
9020             free (local_syms);
9021           if (sec != NULL
9022               && relstart != NULL
9023               && elf_section_data (sec)->relocs != relstart)
9024             free (relstart);
9025           if (toc_relocs != NULL
9026               && elf_section_data (toc)->relocs != toc_relocs)
9027             free (toc_relocs);
9028           if (skip != NULL)
9029             free (skip);
9030           return FALSE;
9031         }
9032
9033       /* Now check all kept sections that might reference the toc.
9034          Check the toc itself last.  */
9035       for (sec = (ibfd->sections == toc && toc->next ? toc->next
9036                   : ibfd->sections);
9037            sec != NULL;
9038            sec = (sec == toc ? NULL
9039                   : sec->next == NULL ? toc
9040                   : sec->next == toc && toc->next ? toc->next
9041                   : sec->next))
9042         {
9043           int repeat;
9044
9045           if (sec->reloc_count == 0
9046               || discarded_section (sec)
9047               || get_opd_info (sec)
9048               || (sec->flags & SEC_ALLOC) == 0
9049               || (sec->flags & SEC_DEBUGGING) != 0)
9050             continue;
9051
9052           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9053                                                 info->keep_memory);
9054           if (relstart == NULL)
9055             {
9056               free (used);
9057               goto error_ret;
9058             }
9059
9060           /* Mark toc entries referenced as used.  */
9061           do
9062             {
9063               repeat = 0;
9064               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9065                 {
9066                   enum elf_ppc64_reloc_type r_type;
9067                   unsigned long r_symndx;
9068                   asection *sym_sec;
9069                   struct elf_link_hash_entry *h;
9070                   Elf_Internal_Sym *sym;
9071                   bfd_vma val;
9072                   enum {no_check, check_lo, check_ha} insn_check;
9073
9074                   r_type = ELF64_R_TYPE (rel->r_info);
9075                   switch (r_type)
9076                     {
9077                     default:
9078                       insn_check = no_check;
9079                       break;
9080
9081                     case R_PPC64_GOT_TLSLD16_HA:
9082                     case R_PPC64_GOT_TLSGD16_HA:
9083                     case R_PPC64_GOT_TPREL16_HA:
9084                     case R_PPC64_GOT_DTPREL16_HA:
9085                     case R_PPC64_GOT16_HA:
9086                     case R_PPC64_TOC16_HA:
9087                       insn_check = check_ha;
9088                       break;
9089
9090                     case R_PPC64_GOT_TLSLD16_LO:
9091                     case R_PPC64_GOT_TLSGD16_LO:
9092                     case R_PPC64_GOT_TPREL16_LO_DS:
9093                     case R_PPC64_GOT_DTPREL16_LO_DS:
9094                     case R_PPC64_GOT16_LO:
9095                     case R_PPC64_GOT16_LO_DS:
9096                     case R_PPC64_TOC16_LO:
9097                     case R_PPC64_TOC16_LO_DS:
9098                       insn_check = check_lo;
9099                       break;
9100                     }
9101
9102                   if (insn_check != no_check)
9103                     {
9104                       bfd_vma off = rel->r_offset & ~3;
9105                       unsigned char buf[4];
9106                       unsigned int insn;
9107
9108                       if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
9109                         {
9110                           free (used);
9111                           goto error_ret;
9112                         }
9113                       insn = bfd_get_32 (ibfd, buf);
9114                       if (insn_check == check_lo
9115                           ? !ok_lo_toc_insn (insn)
9116                           : ((insn & ((0x3f << 26) | 0x1f << 16))
9117                              != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9118                         {
9119                           char str[12];
9120
9121                           ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
9122                           sprintf (str, "%#08x", insn);
9123                           info->callbacks->einfo
9124                             (_("%P: %H: toc optimization is not supported for"
9125                                " %s instruction.\n"),
9126                              ibfd, sec, rel->r_offset & ~3, str);
9127                         }
9128                     }
9129
9130                   switch (r_type)
9131                     {
9132                     case R_PPC64_TOC16:
9133                     case R_PPC64_TOC16_LO:
9134                     case R_PPC64_TOC16_HI:
9135                     case R_PPC64_TOC16_HA:
9136                     case R_PPC64_TOC16_DS:
9137                     case R_PPC64_TOC16_LO_DS:
9138                       /* In case we're taking addresses of toc entries.  */
9139                     case R_PPC64_ADDR64:
9140                       break;
9141
9142                     default:
9143                       continue;
9144                     }
9145
9146                   r_symndx = ELF64_R_SYM (rel->r_info);
9147                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9148                                   r_symndx, ibfd))
9149                     {
9150                       free (used);
9151                       goto error_ret;
9152                     }
9153
9154                   if (sym_sec != toc)
9155                     continue;
9156
9157                   if (h != NULL)
9158                     val = h->root.u.def.value;
9159                   else
9160                     val = sym->st_value;
9161                   val += rel->r_addend;
9162
9163                   if (val >= toc->size)
9164                     continue;
9165
9166                   if ((skip[val >> 3] & can_optimize) != 0)
9167                     {
9168                       bfd_vma off;
9169                       unsigned char opc;
9170
9171                       switch (r_type)
9172                         {
9173                         case R_PPC64_TOC16_HA:
9174                           break;
9175
9176                         case R_PPC64_TOC16_LO_DS:
9177                           off = rel->r_offset;
9178                           off += (bfd_big_endian (ibfd) ? -2 : 3);
9179                           if (!bfd_get_section_contents (ibfd, sec, &opc,
9180                                                          off, 1))
9181                             {
9182                               free (used);
9183                               goto error_ret;
9184                             }
9185                           if ((opc & (0x3f << 2)) == (58u << 2))
9186                             break;
9187                           /* Fall thru */
9188
9189                         default:
9190                           /* Wrong sort of reloc, or not a ld.  We may
9191                              as well clear ref_from_discarded too.  */
9192                           skip[val >> 3] = 0;
9193                         }
9194                     }
9195
9196                   if (sec != toc)
9197                     used[val >> 3] = 1;
9198                   /* For the toc section, we only mark as used if this
9199                      entry itself isn't unused.  */
9200                   else if ((used[rel->r_offset >> 3]
9201                             || !(skip[rel->r_offset >> 3] & ref_from_discarded))
9202                            && !used[val >> 3])
9203                     {
9204                       /* Do all the relocs again, to catch reference
9205                          chains.  */
9206                       repeat = 1;
9207                       used[val >> 3] = 1;
9208                     }
9209                 }
9210             }
9211           while (repeat);
9212
9213           if (elf_section_data (sec)->relocs != relstart)
9214             free (relstart);
9215         }
9216
9217       /* Merge the used and skip arrays.  Assume that TOC
9218          doublewords not appearing as either used or unused belong
9219          to to an entry more than one doubleword in size.  */
9220       for (drop = skip, keep = used, last = 0, some_unused = 0;
9221            drop < skip + (toc->size + 7) / 8;
9222            ++drop, ++keep)
9223         {
9224           if (*keep)
9225             {
9226               *drop &= ~ref_from_discarded;
9227               if ((*drop & can_optimize) != 0)
9228                 some_unused = 1;
9229               last = 0;
9230             }
9231           else if ((*drop & ref_from_discarded) != 0)
9232             {
9233               some_unused = 1;
9234               last = ref_from_discarded;
9235             }
9236           else
9237             *drop = last;
9238         }
9239
9240       free (used);
9241
9242       if (some_unused)
9243         {
9244           bfd_byte *contents, *src;
9245           unsigned long off;
9246           Elf_Internal_Sym *sym;
9247           bfd_boolean local_toc_syms = FALSE;
9248
9249           /* Shuffle the toc contents, and at the same time convert the
9250              skip array from booleans into offsets.  */
9251           if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9252             goto error_ret;
9253
9254           elf_section_data (toc)->this_hdr.contents = contents;
9255
9256           for (src = contents, off = 0, drop = skip;
9257                src < contents + toc->size;
9258                src += 8, ++drop)
9259             {
9260               if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9261                 off += 8;
9262               else if (off != 0)
9263                 {
9264                   *drop = off;
9265                   memcpy (src - off, src, 8);
9266                 }
9267             }
9268           *drop = off;
9269           toc->rawsize = toc->size;
9270           toc->size = src - contents - off;
9271
9272           /* Adjust addends for relocs against the toc section sym,
9273              and optimize any accesses we can.  */
9274           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9275             {
9276               if (sec->reloc_count == 0
9277                   || discarded_section (sec))
9278                 continue;
9279
9280               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9281                                                     info->keep_memory);
9282               if (relstart == NULL)
9283                 goto error_ret;
9284
9285               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9286                 {
9287                   enum elf_ppc64_reloc_type r_type;
9288                   unsigned long r_symndx;
9289                   asection *sym_sec;
9290                   struct elf_link_hash_entry *h;
9291                   bfd_vma val;
9292
9293                   r_type = ELF64_R_TYPE (rel->r_info);
9294                   switch (r_type)
9295                     {
9296                     default:
9297                       continue;
9298
9299                     case R_PPC64_TOC16:
9300                     case R_PPC64_TOC16_LO:
9301                     case R_PPC64_TOC16_HI:
9302                     case R_PPC64_TOC16_HA:
9303                     case R_PPC64_TOC16_DS:
9304                     case R_PPC64_TOC16_LO_DS:
9305                     case R_PPC64_ADDR64:
9306                       break;
9307                     }
9308
9309                   r_symndx = ELF64_R_SYM (rel->r_info);
9310                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9311                                   r_symndx, ibfd))
9312                     goto error_ret;
9313
9314                   if (sym_sec != toc)
9315                     continue;
9316
9317                   if (h != NULL)
9318                     val = h->root.u.def.value;
9319                   else
9320                     {
9321                       val = sym->st_value;
9322                       if (val != 0)
9323                         local_toc_syms = TRUE;
9324                     }
9325
9326                   val += rel->r_addend;
9327
9328                   if (val > toc->rawsize)
9329                     val = toc->rawsize;
9330                   else if ((skip[val >> 3] & ref_from_discarded) != 0)
9331                     continue;
9332                   else if ((skip[val >> 3] & can_optimize) != 0)
9333                     {
9334                       Elf_Internal_Rela *tocrel
9335                         = toc_relocs + (skip[val >> 3] >> 2);
9336                       unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9337
9338                       switch (r_type)
9339                         {
9340                         case R_PPC64_TOC16_HA:
9341                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9342                           break;
9343
9344                         case R_PPC64_TOC16_LO_DS:
9345                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9346                           break;
9347
9348                         default:
9349                           if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9350                             ppc_howto_init ();
9351                           info->callbacks->einfo
9352                             (_("%P: %H: %s references "
9353                                "optimized away TOC entry\n"),
9354                              ibfd, sec, rel->r_offset,
9355                              ppc64_elf_howto_table[r_type]->name);
9356                           bfd_set_error (bfd_error_bad_value);
9357                           goto error_ret;
9358                         }
9359                       rel->r_addend = tocrel->r_addend;
9360                       elf_section_data (sec)->relocs = relstart;
9361                       continue;
9362                     }
9363
9364                   if (h != NULL || sym->st_value != 0)
9365                     continue;
9366
9367                   rel->r_addend -= skip[val >> 3];
9368                   elf_section_data (sec)->relocs = relstart;
9369                 }
9370
9371               if (elf_section_data (sec)->relocs != relstart)
9372                 free (relstart);
9373             }
9374
9375           /* We shouldn't have local or global symbols defined in the TOC,
9376              but handle them anyway.  */
9377           if (local_syms != NULL)
9378             for (sym = local_syms;
9379                  sym < local_syms + symtab_hdr->sh_info;
9380                  ++sym)
9381               if (sym->st_value != 0
9382                   && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9383                 {
9384                   unsigned long i;
9385
9386                   if (sym->st_value > toc->rawsize)
9387                     i = toc->rawsize >> 3;
9388                   else
9389                     i = sym->st_value >> 3;
9390
9391                   if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9392                     {
9393                       if (local_toc_syms)
9394                         (*_bfd_error_handler)
9395                           (_("%s defined on removed toc entry"),
9396                            bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9397                       do
9398                         ++i;
9399                       while ((skip[i] & (ref_from_discarded | can_optimize)));
9400                       sym->st_value = (bfd_vma) i << 3;
9401                     }
9402
9403                   sym->st_value -= skip[i];
9404                   symtab_hdr->contents = (unsigned char *) local_syms;
9405                 }
9406
9407           /* Adjust any global syms defined in this toc input section.  */
9408           if (toc_inf.global_toc_syms)
9409             {
9410               toc_inf.toc = toc;
9411               toc_inf.skip = skip;
9412               toc_inf.global_toc_syms = FALSE;
9413               elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9414                                       &toc_inf);
9415             }
9416
9417           if (toc->reloc_count != 0)
9418             {
9419               Elf_Internal_Shdr *rel_hdr;
9420               Elf_Internal_Rela *wrel;
9421               bfd_size_type sz;
9422
9423               /* Remove unused toc relocs, and adjust those we keep.  */
9424               if (toc_relocs == NULL)
9425                 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9426                                                         info->keep_memory);
9427               if (toc_relocs == NULL)
9428                 goto error_ret;
9429
9430               wrel = toc_relocs;
9431               for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9432                 if ((skip[rel->r_offset >> 3]
9433                      & (ref_from_discarded | can_optimize)) == 0)
9434                   {
9435                     wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9436                     wrel->r_info = rel->r_info;
9437                     wrel->r_addend = rel->r_addend;
9438                     ++wrel;
9439                   }
9440                 else if (!dec_dynrel_count (rel->r_info, toc, info,
9441                                             &local_syms, NULL, NULL))
9442                   goto error_ret;
9443
9444               elf_section_data (toc)->relocs = toc_relocs;
9445               toc->reloc_count = wrel - toc_relocs;
9446               rel_hdr = _bfd_elf_single_rel_hdr (toc);
9447               sz = rel_hdr->sh_entsize;
9448               rel_hdr->sh_size = toc->reloc_count * sz;
9449             }
9450         }
9451       else if (toc_relocs != NULL
9452                && elf_section_data (toc)->relocs != toc_relocs)
9453         free (toc_relocs);
9454
9455       if (local_syms != NULL
9456           && symtab_hdr->contents != (unsigned char *) local_syms)
9457         {
9458           if (!info->keep_memory)
9459             free (local_syms);
9460           else
9461             symtab_hdr->contents = (unsigned char *) local_syms;
9462         }
9463       free (skip);
9464     }
9465
9466   return TRUE;
9467 }
9468
9469 /* Return true iff input section I references the TOC using
9470    instructions limited to +/-32k offsets.  */
9471
9472 bfd_boolean
9473 ppc64_elf_has_small_toc_reloc (asection *i)
9474 {
9475   return (is_ppc64_elf (i->owner)
9476           && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9477 }
9478
9479 /* Allocate space for one GOT entry.  */
9480
9481 static void
9482 allocate_got (struct elf_link_hash_entry *h,
9483               struct bfd_link_info *info,
9484               struct got_entry *gent)
9485 {
9486   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9487   bfd_boolean dyn;
9488   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9489   int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9490                  ? 16 : 8);
9491   int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9492                   ? 2 : 1) * sizeof (Elf64_External_Rela);
9493   asection *got = ppc64_elf_tdata (gent->owner)->got;
9494
9495   gent->got.offset = got->size;
9496   got->size += entsize;
9497
9498   dyn = htab->elf.dynamic_sections_created;
9499   if (h->type == STT_GNU_IFUNC)
9500     {
9501       htab->elf.irelplt->size += rentsize;
9502       htab->got_reli_size += rentsize;
9503     }
9504   else if ((bfd_link_pic (info)
9505             || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
9506            && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9507                || h->root.type != bfd_link_hash_undefweak))
9508     {
9509       asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9510       relgot->size += rentsize;
9511     }
9512 }
9513
9514 /* This function merges got entries in the same toc group.  */
9515
9516 static void
9517 merge_got_entries (struct got_entry **pent)
9518 {
9519   struct got_entry *ent, *ent2;
9520
9521   for (ent = *pent; ent != NULL; ent = ent->next)
9522     if (!ent->is_indirect)
9523       for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9524         if (!ent2->is_indirect
9525             && ent2->addend == ent->addend
9526             && ent2->tls_type == ent->tls_type
9527             && elf_gp (ent2->owner) == elf_gp (ent->owner))
9528           {
9529             ent2->is_indirect = TRUE;
9530             ent2->got.ent = ent;
9531           }
9532 }
9533
9534 /* Allocate space in .plt, .got and associated reloc sections for
9535    dynamic relocs.  */
9536
9537 static bfd_boolean
9538 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9539 {
9540   struct bfd_link_info *info;
9541   struct ppc_link_hash_table *htab;
9542   asection *s;
9543   struct ppc_link_hash_entry *eh;
9544   struct elf_dyn_relocs *p;
9545   struct got_entry **pgent, *gent;
9546
9547   if (h->root.type == bfd_link_hash_indirect)
9548     return TRUE;
9549
9550   info = (struct bfd_link_info *) inf;
9551   htab = ppc_hash_table (info);
9552   if (htab == NULL)
9553     return FALSE;
9554
9555   if ((htab->elf.dynamic_sections_created
9556        && h->dynindx != -1
9557        && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
9558       || h->type == STT_GNU_IFUNC)
9559     {
9560       struct plt_entry *pent;
9561       bfd_boolean doneone = FALSE;
9562       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9563         if (pent->plt.refcount > 0)
9564           {
9565             if (!htab->elf.dynamic_sections_created
9566                 || h->dynindx == -1)
9567               {
9568                 s = htab->elf.iplt;
9569                 pent->plt.offset = s->size;
9570                 s->size += PLT_ENTRY_SIZE (htab);
9571                 s = htab->elf.irelplt;
9572               }
9573             else
9574               {
9575                 /* If this is the first .plt entry, make room for the special
9576                    first entry.  */
9577                 s = htab->elf.splt;
9578                 if (s->size == 0)
9579                   s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9580
9581                 pent->plt.offset = s->size;
9582
9583                 /* Make room for this entry.  */
9584                 s->size += PLT_ENTRY_SIZE (htab);
9585
9586                 /* Make room for the .glink code.  */
9587                 s = htab->glink;
9588                 if (s->size == 0)
9589                   s->size += GLINK_CALL_STUB_SIZE;
9590                 if (htab->opd_abi)
9591                   {
9592                     /* We need bigger stubs past index 32767.  */
9593                     if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9594                       s->size += 4;
9595                     s->size += 2*4;
9596                   }
9597                 else
9598                   s->size += 4;
9599
9600                 /* We also need to make an entry in the .rela.plt section.  */
9601                 s = htab->elf.srelplt;
9602               }
9603             s->size += sizeof (Elf64_External_Rela);
9604             doneone = TRUE;
9605           }
9606         else
9607           pent->plt.offset = (bfd_vma) -1;
9608       if (!doneone)
9609         {
9610           h->plt.plist = NULL;
9611           h->needs_plt = 0;
9612         }
9613     }
9614   else
9615     {
9616       h->plt.plist = NULL;
9617       h->needs_plt = 0;
9618     }
9619
9620   eh = (struct ppc_link_hash_entry *) h;
9621   /* Run through the TLS GD got entries first if we're changing them
9622      to TPREL.  */
9623   if ((eh->tls_mask & TLS_TPRELGD) != 0)
9624     for (gent = h->got.glist; gent != NULL; gent = gent->next)
9625       if (gent->got.refcount > 0
9626           && (gent->tls_type & TLS_GD) != 0)
9627         {
9628           /* This was a GD entry that has been converted to TPREL.  If
9629              there happens to be a TPREL entry we can use that one.  */
9630           struct got_entry *ent;
9631           for (ent = h->got.glist; ent != NULL; ent = ent->next)
9632             if (ent->got.refcount > 0
9633                 && (ent->tls_type & TLS_TPREL) != 0
9634                 && ent->addend == gent->addend
9635                 && ent->owner == gent->owner)
9636               {
9637                 gent->got.refcount = 0;
9638                 break;
9639               }
9640
9641           /* If not, then we'll be using our own TPREL entry.  */
9642           if (gent->got.refcount != 0)
9643             gent->tls_type = TLS_TLS | TLS_TPREL;
9644         }
9645
9646   /* Remove any list entry that won't generate a word in the GOT before
9647      we call merge_got_entries.  Otherwise we risk merging to empty
9648      entries.  */
9649   pgent = &h->got.glist;
9650   while ((gent = *pgent) != NULL)
9651     if (gent->got.refcount > 0)
9652       {
9653         if ((gent->tls_type & TLS_LD) != 0
9654             && !h->def_dynamic)
9655           {
9656             ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9657             *pgent = gent->next;
9658           }
9659         else
9660           pgent = &gent->next;
9661       }
9662     else
9663       *pgent = gent->next;
9664
9665   if (!htab->do_multi_toc)
9666     merge_got_entries (&h->got.glist);
9667
9668   for (gent = h->got.glist; gent != NULL; gent = gent->next)
9669     if (!gent->is_indirect)
9670       {
9671         /* Make sure this symbol is output as a dynamic symbol.
9672            Undefined weak syms won't yet be marked as dynamic,
9673            nor will all TLS symbols.  */
9674         if (h->dynindx == -1
9675             && !h->forced_local
9676             && h->type != STT_GNU_IFUNC
9677             && htab->elf.dynamic_sections_created)
9678           {
9679             if (! bfd_elf_link_record_dynamic_symbol (info, h))
9680               return FALSE;
9681           }
9682
9683         if (!is_ppc64_elf (gent->owner))
9684           abort ();
9685
9686         allocate_got (h, info, gent);
9687       }
9688
9689   if (eh->dyn_relocs == NULL
9690       || (!htab->elf.dynamic_sections_created
9691           && h->type != STT_GNU_IFUNC))
9692     return TRUE;
9693
9694   /* In the shared -Bsymbolic case, discard space allocated for
9695      dynamic pc-relative relocs against symbols which turn out to be
9696      defined in regular objects.  For the normal shared case, discard
9697      space for relocs that have become local due to symbol visibility
9698      changes.  */
9699
9700   if (bfd_link_pic (info))
9701     {
9702       /* Relocs that use pc_count are those that appear on a call insn,
9703          or certain REL relocs (see must_be_dyn_reloc) that can be
9704          generated via assembly.  We want calls to protected symbols to
9705          resolve directly to the function rather than going via the plt.
9706          If people want function pointer comparisons to work as expected
9707          then they should avoid writing weird assembly.  */
9708       if (SYMBOL_CALLS_LOCAL (info, h))
9709         {
9710           struct elf_dyn_relocs **pp;
9711
9712           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9713             {
9714               p->count -= p->pc_count;
9715               p->pc_count = 0;
9716               if (p->count == 0)
9717                 *pp = p->next;
9718               else
9719                 pp = &p->next;
9720             }
9721         }
9722
9723       /* Also discard relocs on undefined weak syms with non-default
9724          visibility.  */
9725       if (eh->dyn_relocs != NULL
9726           && h->root.type == bfd_link_hash_undefweak)
9727         {
9728           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9729             eh->dyn_relocs = NULL;
9730
9731           /* Make sure this symbol is output as a dynamic symbol.
9732              Undefined weak syms won't yet be marked as dynamic.  */
9733           else if (h->dynindx == -1
9734                    && !h->forced_local)
9735             {
9736               if (! bfd_elf_link_record_dynamic_symbol (info, h))
9737                 return FALSE;
9738             }
9739         }
9740     }
9741   else if (h->type == STT_GNU_IFUNC)
9742     {
9743       if (!h->non_got_ref)
9744         eh->dyn_relocs = NULL;
9745     }
9746   else if (ELIMINATE_COPY_RELOCS)
9747     {
9748       /* For the non-shared case, discard space for relocs against
9749          symbols which turn out to need copy relocs or are not
9750          dynamic.  */
9751
9752       if (!h->non_got_ref
9753           && !h->def_regular)
9754         {
9755           /* Make sure this symbol is output as a dynamic symbol.
9756              Undefined weak syms won't yet be marked as dynamic.  */
9757           if (h->dynindx == -1
9758               && !h->forced_local)
9759             {
9760               if (! bfd_elf_link_record_dynamic_symbol (info, h))
9761                 return FALSE;
9762             }
9763
9764           /* If that succeeded, we know we'll be keeping all the
9765              relocs.  */
9766           if (h->dynindx != -1)
9767             goto keep;
9768         }
9769
9770       eh->dyn_relocs = NULL;
9771
9772     keep: ;
9773     }
9774
9775   /* Finally, allocate space.  */
9776   for (p = eh->dyn_relocs; p != NULL; p = p->next)
9777     {
9778       asection *sreloc = elf_section_data (p->sec)->sreloc;
9779       if (eh->elf.type == STT_GNU_IFUNC)
9780         sreloc = htab->elf.irelplt;
9781       sreloc->size += p->count * sizeof (Elf64_External_Rela);
9782     }
9783
9784   return TRUE;
9785 }
9786
9787 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9788    to set up space for global entry stubs.  These are put in glink,
9789    after the branch table.  */
9790
9791 static bfd_boolean
9792 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
9793 {
9794   struct bfd_link_info *info;
9795   struct ppc_link_hash_table *htab;
9796   struct plt_entry *pent;
9797   asection *s;
9798
9799   if (h->root.type == bfd_link_hash_indirect)
9800     return TRUE;
9801
9802   if (!h->pointer_equality_needed)
9803     return TRUE;
9804
9805   if (h->def_regular)
9806     return TRUE;
9807
9808   info = inf;
9809   htab = ppc_hash_table (info);
9810   if (htab == NULL)
9811     return FALSE;
9812
9813   s = htab->glink;
9814   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9815     if (pent->plt.offset != (bfd_vma) -1
9816         && pent->addend == 0)
9817       {
9818         /* For ELFv2, if this symbol is not defined in a regular file
9819            and we are not generating a shared library or pie, then we
9820            need to define the symbol in the executable on a call stub.
9821            This is to avoid text relocations.  */
9822         s->size = (s->size + 15) & -16;
9823         h->root.u.def.section = s;
9824         h->root.u.def.value = s->size;
9825         s->size += 16;
9826         break;
9827       }
9828   return TRUE;
9829 }
9830
9831 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9832    read-only sections.  */
9833
9834 static bfd_boolean
9835 maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
9836 {
9837   if (h->root.type == bfd_link_hash_indirect)
9838     return TRUE;
9839
9840   if (readonly_dynrelocs (h))
9841     {
9842       ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
9843
9844       /* Not an error, just cut short the traversal.  */
9845       return FALSE;
9846     }
9847   return TRUE;
9848 }
9849
9850 /* Set the sizes of the dynamic sections.  */
9851
9852 static bfd_boolean
9853 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
9854                                  struct bfd_link_info *info)
9855 {
9856   struct ppc_link_hash_table *htab;
9857   bfd *dynobj;
9858   asection *s;
9859   bfd_boolean relocs;
9860   bfd *ibfd;
9861   struct got_entry *first_tlsld;
9862
9863   htab = ppc_hash_table (info);
9864   if (htab == NULL)
9865     return FALSE;
9866
9867   dynobj = htab->elf.dynobj;
9868   if (dynobj == NULL)
9869     abort ();
9870
9871   if (htab->elf.dynamic_sections_created)
9872     {
9873       /* Set the contents of the .interp section to the interpreter.  */
9874       if (bfd_link_executable (info) && !info->nointerp)
9875         {
9876           s = bfd_get_linker_section (dynobj, ".interp");
9877           if (s == NULL)
9878             abort ();
9879           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
9880           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
9881         }
9882     }
9883
9884   /* Set up .got offsets for local syms, and space for local dynamic
9885      relocs.  */
9886   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9887     {
9888       struct got_entry **lgot_ents;
9889       struct got_entry **end_lgot_ents;
9890       struct plt_entry **local_plt;
9891       struct plt_entry **end_local_plt;
9892       unsigned char *lgot_masks;
9893       bfd_size_type locsymcount;
9894       Elf_Internal_Shdr *symtab_hdr;
9895
9896       if (!is_ppc64_elf (ibfd))
9897         continue;
9898
9899       for (s = ibfd->sections; s != NULL; s = s->next)
9900         {
9901           struct ppc_dyn_relocs *p;
9902
9903           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
9904             {
9905               if (!bfd_is_abs_section (p->sec)
9906                   && bfd_is_abs_section (p->sec->output_section))
9907                 {
9908                   /* Input section has been discarded, either because
9909                      it is a copy of a linkonce section or due to
9910                      linker script /DISCARD/, so we'll be discarding
9911                      the relocs too.  */
9912                 }
9913               else if (p->count != 0)
9914                 {
9915                   asection *srel = elf_section_data (p->sec)->sreloc;
9916                   if (p->ifunc)
9917                     srel = htab->elf.irelplt;
9918                   srel->size += p->count * sizeof (Elf64_External_Rela);
9919                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
9920                     info->flags |= DF_TEXTREL;
9921                 }
9922             }
9923         }
9924
9925       lgot_ents = elf_local_got_ents (ibfd);
9926       if (!lgot_ents)
9927         continue;
9928
9929       symtab_hdr = &elf_symtab_hdr (ibfd);
9930       locsymcount = symtab_hdr->sh_info;
9931       end_lgot_ents = lgot_ents + locsymcount;
9932       local_plt = (struct plt_entry **) end_lgot_ents;
9933       end_local_plt = local_plt + locsymcount;
9934       lgot_masks = (unsigned char *) end_local_plt;
9935       s = ppc64_elf_tdata (ibfd)->got;
9936       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
9937         {
9938           struct got_entry **pent, *ent;
9939
9940           pent = lgot_ents;
9941           while ((ent = *pent) != NULL)
9942             if (ent->got.refcount > 0)
9943               {
9944                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
9945                   {
9946                     ppc64_tlsld_got (ibfd)->got.refcount += 1;
9947                     *pent = ent->next;
9948                   }
9949                 else
9950                   {
9951                     unsigned int ent_size = 8;
9952                     unsigned int rel_size = sizeof (Elf64_External_Rela);
9953
9954                     ent->got.offset = s->size;
9955                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
9956                       {
9957                         ent_size *= 2;
9958                         rel_size *= 2;
9959                       }
9960                     s->size += ent_size;
9961                     if ((*lgot_masks & PLT_IFUNC) != 0)
9962                       {
9963                         htab->elf.irelplt->size += rel_size;
9964                         htab->got_reli_size += rel_size;
9965                       }
9966                     else if (bfd_link_pic (info))
9967                       {
9968                         asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9969                         srel->size += rel_size;
9970                       }
9971                     pent = &ent->next;
9972                   }
9973               }
9974             else
9975               *pent = ent->next;
9976         }
9977
9978       /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt.  */
9979       for (; local_plt < end_local_plt; ++local_plt)
9980         {
9981           struct plt_entry *ent;
9982
9983           for (ent = *local_plt; ent != NULL; ent = ent->next)
9984             if (ent->plt.refcount > 0)
9985               {
9986                 s = htab->elf.iplt;
9987                 ent->plt.offset = s->size;
9988                 s->size += PLT_ENTRY_SIZE (htab);
9989
9990                 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
9991               }
9992             else
9993               ent->plt.offset = (bfd_vma) -1;
9994         }
9995     }
9996
9997   /* Allocate global sym .plt and .got entries, and space for global
9998      sym dynamic relocs.  */
9999   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
10000   /* Stash the end of glink branch table.  */
10001   if (htab->glink != NULL)
10002     htab->glink->rawsize = htab->glink->size;
10003
10004   if (!htab->opd_abi && !bfd_link_pic (info))
10005     elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
10006
10007   first_tlsld = NULL;
10008   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10009     {
10010       struct got_entry *ent;
10011
10012       if (!is_ppc64_elf (ibfd))
10013         continue;
10014
10015       ent = ppc64_tlsld_got (ibfd);
10016       if (ent->got.refcount > 0)
10017         {
10018           if (!htab->do_multi_toc && first_tlsld != NULL)
10019             {
10020               ent->is_indirect = TRUE;
10021               ent->got.ent = first_tlsld;
10022             }
10023           else
10024             {
10025               if (first_tlsld == NULL)
10026                 first_tlsld = ent;
10027               s = ppc64_elf_tdata (ibfd)->got;
10028               ent->got.offset = s->size;
10029               ent->owner = ibfd;
10030               s->size += 16;
10031               if (bfd_link_pic (info))
10032                 {
10033                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10034                   srel->size += sizeof (Elf64_External_Rela);
10035                 }
10036             }
10037         }
10038       else
10039         ent->got.offset = (bfd_vma) -1;
10040     }
10041
10042   /* We now have determined the sizes of the various dynamic sections.
10043      Allocate memory for them.  */
10044   relocs = FALSE;
10045   for (s = dynobj->sections; s != NULL; s = s->next)
10046     {
10047       if ((s->flags & SEC_LINKER_CREATED) == 0)
10048         continue;
10049
10050       if (s == htab->brlt || s == htab->relbrlt)
10051         /* These haven't been allocated yet;  don't strip.  */
10052         continue;
10053       else if (s == htab->elf.sgot
10054                || s == htab->elf.splt
10055                || s == htab->elf.iplt
10056                || s == htab->glink
10057                || s == htab->dynbss)
10058         {
10059           /* Strip this section if we don't need it; see the
10060              comment below.  */
10061         }
10062       else if (s == htab->glink_eh_frame)
10063         {
10064           if (!bfd_is_abs_section (s->output_section))
10065             /* Not sized yet.  */
10066             continue;
10067         }
10068       else if (CONST_STRNEQ (s->name, ".rela"))
10069         {
10070           if (s->size != 0)
10071             {
10072               if (s != htab->elf.srelplt)
10073                 relocs = TRUE;
10074
10075               /* We use the reloc_count field as a counter if we need
10076                  to copy relocs into the output file.  */
10077               s->reloc_count = 0;
10078             }
10079         }
10080       else
10081         {
10082           /* It's not one of our sections, so don't allocate space.  */
10083           continue;
10084         }
10085
10086       if (s->size == 0)
10087         {
10088           /* If we don't need this section, strip it from the
10089              output file.  This is mostly to handle .rela.bss and
10090              .rela.plt.  We must create both sections in
10091              create_dynamic_sections, because they must be created
10092              before the linker maps input sections to output
10093              sections.  The linker does that before
10094              adjust_dynamic_symbol is called, and it is that
10095              function which decides whether anything needs to go
10096              into these sections.  */
10097           s->flags |= SEC_EXCLUDE;
10098           continue;
10099         }
10100
10101       if ((s->flags & SEC_HAS_CONTENTS) == 0)
10102         continue;
10103
10104       /* Allocate memory for the section contents.  We use bfd_zalloc
10105          here in case unused entries are not reclaimed before the
10106          section's contents are written out.  This should not happen,
10107          but this way if it does we get a R_PPC64_NONE reloc in .rela
10108          sections instead of garbage.
10109          We also rely on the section contents being zero when writing
10110          the GOT.  */
10111       s->contents = bfd_zalloc (dynobj, s->size);
10112       if (s->contents == NULL)
10113         return FALSE;
10114     }
10115
10116   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10117     {
10118       if (!is_ppc64_elf (ibfd))
10119         continue;
10120
10121       s = ppc64_elf_tdata (ibfd)->got;
10122       if (s != NULL && s != htab->elf.sgot)
10123         {
10124           if (s->size == 0)
10125             s->flags |= SEC_EXCLUDE;
10126           else
10127             {
10128               s->contents = bfd_zalloc (ibfd, s->size);
10129               if (s->contents == NULL)
10130                 return FALSE;
10131             }
10132         }
10133       s = ppc64_elf_tdata (ibfd)->relgot;
10134       if (s != NULL)
10135         {
10136           if (s->size == 0)
10137             s->flags |= SEC_EXCLUDE;
10138           else
10139             {
10140               s->contents = bfd_zalloc (ibfd, s->size);
10141               if (s->contents == NULL)
10142                 return FALSE;
10143               relocs = TRUE;
10144               s->reloc_count = 0;
10145             }
10146         }
10147     }
10148
10149   if (htab->elf.dynamic_sections_created)
10150     {
10151       bfd_boolean tls_opt;
10152
10153       /* Add some entries to the .dynamic section.  We fill in the
10154          values later, in ppc64_elf_finish_dynamic_sections, but we
10155          must add the entries now so that we get the correct size for
10156          the .dynamic section.  The DT_DEBUG entry is filled in by the
10157          dynamic linker and used by the debugger.  */
10158 #define add_dynamic_entry(TAG, VAL) \
10159   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10160
10161       if (bfd_link_executable (info))
10162         {
10163           if (!add_dynamic_entry (DT_DEBUG, 0))
10164             return FALSE;
10165         }
10166
10167       if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
10168         {
10169           if (!add_dynamic_entry (DT_PLTGOT, 0)
10170               || !add_dynamic_entry (DT_PLTRELSZ, 0)
10171               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
10172               || !add_dynamic_entry (DT_JMPREL, 0)
10173               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
10174             return FALSE;
10175         }
10176
10177       if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
10178         {
10179           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
10180               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
10181             return FALSE;
10182         }
10183
10184       tls_opt = (htab->params->tls_get_addr_opt
10185                  && htab->tls_get_addr_fd != NULL
10186                  && htab->tls_get_addr_fd->elf.plt.plist != NULL);
10187       if (tls_opt || !htab->opd_abi)
10188         {
10189           if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
10190             return FALSE;
10191         }
10192
10193       if (relocs)
10194         {
10195           if (!add_dynamic_entry (DT_RELA, 0)
10196               || !add_dynamic_entry (DT_RELASZ, 0)
10197               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
10198             return FALSE;
10199
10200           /* If any dynamic relocs apply to a read-only section,
10201              then we need a DT_TEXTREL entry.  */
10202           if ((info->flags & DF_TEXTREL) == 0)
10203             elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
10204
10205           if ((info->flags & DF_TEXTREL) != 0)
10206             {
10207               if (!add_dynamic_entry (DT_TEXTREL, 0))
10208                 return FALSE;
10209             }
10210         }
10211     }
10212 #undef add_dynamic_entry
10213
10214   return TRUE;
10215 }
10216
10217 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
10218
10219 static bfd_boolean
10220 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
10221 {
10222   if (h->plt.plist != NULL
10223       && !h->def_regular
10224       && !h->pointer_equality_needed)
10225     return FALSE;
10226
10227   return _bfd_elf_hash_symbol (h);
10228 }
10229
10230 /* Determine the type of stub needed, if any, for a call.  */
10231
10232 static inline enum ppc_stub_type
10233 ppc_type_of_stub (asection *input_sec,
10234                   const Elf_Internal_Rela *rel,
10235                   struct ppc_link_hash_entry **hash,
10236                   struct plt_entry **plt_ent,
10237                   bfd_vma destination,
10238                   unsigned long local_off)
10239 {
10240   struct ppc_link_hash_entry *h = *hash;
10241   bfd_vma location;
10242   bfd_vma branch_offset;
10243   bfd_vma max_branch_offset;
10244   enum elf_ppc64_reloc_type r_type;
10245
10246   if (h != NULL)
10247     {
10248       struct plt_entry *ent;
10249       struct ppc_link_hash_entry *fdh = h;
10250       if (h->oh != NULL
10251           && h->oh->is_func_descriptor)
10252         {
10253           fdh = ppc_follow_link (h->oh);
10254           *hash = fdh;
10255         }
10256
10257       for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10258         if (ent->addend == rel->r_addend
10259             && ent->plt.offset != (bfd_vma) -1)
10260           {
10261             *plt_ent = ent;
10262             return ppc_stub_plt_call;
10263           }
10264
10265       /* Here, we know we don't have a plt entry.  If we don't have a
10266          either a defined function descriptor or a defined entry symbol
10267          in a regular object file, then it is pointless trying to make
10268          any other type of stub.  */
10269       if (!is_static_defined (&fdh->elf)
10270           && !is_static_defined (&h->elf))
10271         return ppc_stub_none;
10272     }
10273   else if (elf_local_got_ents (input_sec->owner) != NULL)
10274     {
10275       Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10276       struct plt_entry **local_plt = (struct plt_entry **)
10277         elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10278       unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10279
10280       if (local_plt[r_symndx] != NULL)
10281         {
10282           struct plt_entry *ent;
10283
10284           for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10285             if (ent->addend == rel->r_addend
10286                 && ent->plt.offset != (bfd_vma) -1)
10287               {
10288                 *plt_ent = ent;
10289                 return ppc_stub_plt_call;
10290               }
10291         }
10292     }
10293
10294   /* Determine where the call point is.  */
10295   location = (input_sec->output_offset
10296               + input_sec->output_section->vma
10297               + rel->r_offset);
10298
10299   branch_offset = destination - location;
10300   r_type = ELF64_R_TYPE (rel->r_info);
10301
10302   /* Determine if a long branch stub is needed.  */
10303   max_branch_offset = 1 << 25;
10304   if (r_type != R_PPC64_REL24)
10305     max_branch_offset = 1 << 15;
10306
10307   if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10308     /* We need a stub.  Figure out whether a long_branch or plt_branch
10309        is needed later.  */
10310     return ppc_stub_long_branch;
10311
10312   return ppc_stub_none;
10313 }
10314
10315 /* With power7 weakly ordered memory model, it is possible for ld.so
10316    to update a plt entry in one thread and have another thread see a
10317    stale zero toc entry.  To avoid this we need some sort of acquire
10318    barrier in the call stub.  One solution is to make the load of the
10319    toc word seem to appear to depend on the load of the function entry
10320    word.  Another solution is to test for r2 being zero, and branch to
10321    the appropriate glink entry if so.
10322
10323    .    fake dep barrier        compare
10324    .    ld 12,xxx(2)            ld 12,xxx(2)
10325    .    mtctr 12                mtctr 12
10326    .    xor 11,12,12            ld 2,xxx+8(2)
10327    .    add 2,2,11              cmpldi 2,0
10328    .    ld 2,xxx+8(2)           bnectr+
10329    .    bctr                    b <glink_entry>
10330
10331    The solution involving the compare turns out to be faster, so
10332    that's what we use unless the branch won't reach.  */
10333
10334 #define ALWAYS_USE_FAKE_DEP 0
10335 #define ALWAYS_EMIT_R2SAVE 0
10336
10337 #define PPC_LO(v) ((v) & 0xffff)
10338 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10339 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10340
10341 static inline unsigned int
10342 plt_stub_size (struct ppc_link_hash_table *htab,
10343                struct ppc_stub_hash_entry *stub_entry,
10344                bfd_vma off)
10345 {
10346   unsigned size = 12;
10347
10348   if (ALWAYS_EMIT_R2SAVE
10349       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10350     size += 4;
10351   if (PPC_HA (off) != 0)
10352     size += 4;
10353   if (htab->opd_abi)
10354     {
10355       size += 4;
10356       if (htab->params->plt_static_chain)
10357         size += 4;
10358       if (htab->params->plt_thread_safe
10359           && htab->elf.dynamic_sections_created
10360           && stub_entry->h != NULL
10361           && stub_entry->h->elf.dynindx != -1)
10362         size += 8;
10363       if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
10364         size += 4;
10365     }
10366   if (stub_entry->h != NULL
10367       && (stub_entry->h == htab->tls_get_addr_fd
10368           || stub_entry->h == htab->tls_get_addr)
10369       && htab->params->tls_get_addr_opt)
10370     size += 13 * 4;
10371   return size;
10372 }
10373
10374 /* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
10375    then return the padding needed to do so.  */
10376 static inline unsigned int
10377 plt_stub_pad (struct ppc_link_hash_table *htab,
10378               struct ppc_stub_hash_entry *stub_entry,
10379               bfd_vma plt_off)
10380 {
10381   int stub_align = 1 << htab->params->plt_stub_align;
10382   unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10383   bfd_vma stub_off = stub_entry->group->stub_sec->size;
10384
10385   if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10386       > ((stub_size - 1) & -stub_align))
10387     return stub_align - (stub_off & (stub_align - 1));
10388   return 0;
10389 }
10390
10391 /* Build a .plt call stub.  */
10392
10393 static inline bfd_byte *
10394 build_plt_stub (struct ppc_link_hash_table *htab,
10395                 struct ppc_stub_hash_entry *stub_entry,
10396                 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10397 {
10398   bfd *obfd = htab->params->stub_bfd;
10399   bfd_boolean plt_load_toc = htab->opd_abi;
10400   bfd_boolean plt_static_chain = htab->params->plt_static_chain;
10401   bfd_boolean plt_thread_safe = (htab->params->plt_thread_safe
10402                                  && htab->elf.dynamic_sections_created
10403                                  && stub_entry->h != NULL
10404                                  && stub_entry->h->elf.dynindx != -1);
10405   bfd_boolean use_fake_dep = plt_thread_safe;
10406   bfd_vma cmp_branch_off = 0;
10407
10408   if (!ALWAYS_USE_FAKE_DEP
10409       && plt_load_toc
10410       && plt_thread_safe
10411       && !((stub_entry->h == htab->tls_get_addr_fd
10412             || stub_entry->h == htab->tls_get_addr)
10413            && htab->params->tls_get_addr_opt))
10414     {
10415       bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10416       bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10417                           / PLT_ENTRY_SIZE (htab));
10418       bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10419       bfd_vma to, from;
10420
10421       if (pltindex > 32768)
10422         glinkoff += (pltindex - 32768) * 4;
10423       to = (glinkoff
10424             + htab->glink->output_offset
10425             + htab->glink->output_section->vma);
10426       from = (p - stub_entry->group->stub_sec->contents
10427               + 4 * (ALWAYS_EMIT_R2SAVE
10428                      || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10429               + 4 * (PPC_HA (offset) != 0)
10430               + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10431                      != PPC_HA (offset))
10432               + 4 * (plt_static_chain != 0)
10433               + 20
10434               + stub_entry->group->stub_sec->output_offset
10435               + stub_entry->group->stub_sec->output_section->vma);
10436       cmp_branch_off = to - from;
10437       use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10438     }
10439
10440   if (PPC_HA (offset) != 0)
10441     {
10442       if (r != NULL)
10443         {
10444           if (ALWAYS_EMIT_R2SAVE
10445               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10446             r[0].r_offset += 4;
10447           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10448           r[1].r_offset = r[0].r_offset + 4;
10449           r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10450           r[1].r_addend = r[0].r_addend;
10451           if (plt_load_toc)
10452             {
10453               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10454                 {
10455                   r[2].r_offset = r[1].r_offset + 4;
10456                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10457                   r[2].r_addend = r[0].r_addend;
10458                 }
10459               else
10460                 {
10461                   r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10462                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10463                   r[2].r_addend = r[0].r_addend + 8;
10464                   if (plt_static_chain)
10465                     {
10466                       r[3].r_offset = r[2].r_offset + 4;
10467                       r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10468                       r[3].r_addend = r[0].r_addend + 16;
10469                     }
10470                 }
10471             }
10472         }
10473       if (ALWAYS_EMIT_R2SAVE
10474           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10475         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10476       if (plt_load_toc)
10477         {
10478           bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10479           bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p),  p += 4;
10480         }
10481       else
10482         {
10483           bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
10484           bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p),  p += 4;
10485         }
10486       if (plt_load_toc
10487           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10488         {
10489           bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10490           offset = 0;
10491         }
10492       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10493       if (plt_load_toc)
10494         {
10495           if (use_fake_dep)
10496             {
10497               bfd_put_32 (obfd, XOR_R2_R12_R12, p),             p += 4;
10498               bfd_put_32 (obfd, ADD_R11_R11_R2, p),             p += 4;
10499             }
10500           bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10501           if (plt_static_chain)
10502             bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10503         }
10504     }
10505   else
10506     {
10507       if (r != NULL)
10508         {
10509           if (ALWAYS_EMIT_R2SAVE
10510               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10511             r[0].r_offset += 4;
10512           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10513           if (plt_load_toc)
10514             {
10515               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10516                 {
10517                   r[1].r_offset = r[0].r_offset + 4;
10518                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10519                   r[1].r_addend = r[0].r_addend;
10520                 }
10521               else
10522                 {
10523                   r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10524                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10525                   r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10526                   if (plt_static_chain)
10527                     {
10528                       r[2].r_offset = r[1].r_offset + 4;
10529                       r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10530                       r[2].r_addend = r[0].r_addend + 8;
10531                     }
10532                 }
10533             }
10534         }
10535       if (ALWAYS_EMIT_R2SAVE
10536           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10537         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10538       bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p),       p += 4;
10539       if (plt_load_toc
10540           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10541         {
10542           bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),   p += 4;
10543           offset = 0;
10544         }
10545       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10546       if (plt_load_toc)
10547         {
10548           if (use_fake_dep)
10549             {
10550               bfd_put_32 (obfd, XOR_R11_R12_R12, p),            p += 4;
10551               bfd_put_32 (obfd, ADD_R2_R2_R11, p),              p += 4;
10552             }
10553           if (plt_static_chain)
10554             bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10555           bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10556         }
10557     }
10558   if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10559     {
10560       bfd_put_32 (obfd, CMPLDI_R2_0, p),                        p += 4;
10561       bfd_put_32 (obfd, BNECTR_P4, p),                          p += 4;
10562       bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10563     }
10564   else
10565     bfd_put_32 (obfd, BCTR, p),                                 p += 4;
10566   return p;
10567 }
10568
10569 /* Build a special .plt call stub for __tls_get_addr.  */
10570
10571 #define LD_R11_0R3      0xe9630000
10572 #define LD_R12_0R3      0xe9830000
10573 #define MR_R0_R3        0x7c601b78
10574 #define CMPDI_R11_0     0x2c2b0000
10575 #define ADD_R3_R12_R13  0x7c6c6a14
10576 #define BEQLR           0x4d820020
10577 #define MR_R3_R0        0x7c030378
10578 #define STD_R11_0R1     0xf9610000
10579 #define BCTRL           0x4e800421
10580 #define LD_R11_0R1      0xe9610000
10581 #define MTLR_R11        0x7d6803a6
10582
10583 static inline bfd_byte *
10584 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10585                          struct ppc_stub_hash_entry *stub_entry,
10586                          bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10587 {
10588   bfd *obfd = htab->params->stub_bfd;
10589
10590   bfd_put_32 (obfd, LD_R11_0R3 + 0, p),         p += 4;
10591   bfd_put_32 (obfd, LD_R12_0R3 + 8, p),         p += 4;
10592   bfd_put_32 (obfd, MR_R0_R3, p),               p += 4;
10593   bfd_put_32 (obfd, CMPDI_R11_0, p),            p += 4;
10594   bfd_put_32 (obfd, ADD_R3_R12_R13, p),         p += 4;
10595   bfd_put_32 (obfd, BEQLR, p),                  p += 4;
10596   bfd_put_32 (obfd, MR_R3_R0, p),               p += 4;
10597   bfd_put_32 (obfd, MFLR_R11, p),               p += 4;
10598   bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10599
10600   if (r != NULL)
10601     r[0].r_offset += 9 * 4;
10602   p = build_plt_stub (htab, stub_entry, p, offset, r);
10603   bfd_put_32 (obfd, BCTRL, p - 4);
10604
10605   bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p),     p += 4;
10606   bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10607   bfd_put_32 (obfd, MTLR_R11, p),               p += 4;
10608   bfd_put_32 (obfd, BLR, p),                    p += 4;
10609
10610   return p;
10611 }
10612
10613 static Elf_Internal_Rela *
10614 get_relocs (asection *sec, int count)
10615 {
10616   Elf_Internal_Rela *relocs;
10617   struct bfd_elf_section_data *elfsec_data;
10618
10619   elfsec_data = elf_section_data (sec);
10620   relocs = elfsec_data->relocs;
10621   if (relocs == NULL)
10622     {
10623       bfd_size_type relsize;
10624       relsize = sec->reloc_count * sizeof (*relocs);
10625       relocs = bfd_alloc (sec->owner, relsize);
10626       if (relocs == NULL)
10627         return NULL;
10628       elfsec_data->relocs = relocs;
10629       elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10630                                           sizeof (Elf_Internal_Shdr));
10631       if (elfsec_data->rela.hdr == NULL)
10632         return NULL;
10633       elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10634                                         * sizeof (Elf64_External_Rela));
10635       elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10636       sec->reloc_count = 0;
10637     }
10638   relocs += sec->reloc_count;
10639   sec->reloc_count += count;
10640   return relocs;
10641 }
10642
10643 static bfd_vma
10644 get_r2off (struct bfd_link_info *info,
10645            struct ppc_stub_hash_entry *stub_entry)
10646 {
10647   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10648   bfd_vma r2off = htab->sec_info[stub_entry->target_section->id].toc_off;
10649
10650   if (r2off == 0)
10651     {
10652       /* Support linking -R objects.  Get the toc pointer from the
10653          opd entry.  */
10654       char buf[8];
10655       if (!htab->opd_abi)
10656         return r2off;
10657       asection *opd = stub_entry->h->elf.root.u.def.section;
10658       bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10659
10660       if (strcmp (opd->name, ".opd") != 0
10661           || opd->reloc_count != 0)
10662         {
10663           info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
10664                                   stub_entry->h->elf.root.root.string);
10665           bfd_set_error (bfd_error_bad_value);
10666           return (bfd_vma) -1;
10667         }
10668       if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10669         return (bfd_vma) -1;
10670       r2off = bfd_get_64 (opd->owner, buf);
10671       r2off -= elf_gp (info->output_bfd);
10672     }
10673   r2off -= htab->sec_info[stub_entry->group->link_sec->id].toc_off;
10674   return r2off;
10675 }
10676
10677 static bfd_boolean
10678 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10679 {
10680   struct ppc_stub_hash_entry *stub_entry;
10681   struct ppc_branch_hash_entry *br_entry;
10682   struct bfd_link_info *info;
10683   struct ppc_link_hash_table *htab;
10684   bfd_byte *loc;
10685   bfd_byte *p;
10686   bfd_vma dest, off;
10687   int size;
10688   Elf_Internal_Rela *r;
10689   asection *plt;
10690
10691   /* Massage our args to the form they really have.  */
10692   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10693   info = in_arg;
10694
10695   htab = ppc_hash_table (info);
10696   if (htab == NULL)
10697     return FALSE;
10698
10699   /* Make a note of the offset within the stubs for this entry.  */
10700   stub_entry->stub_offset = stub_entry->group->stub_sec->size;
10701   loc = stub_entry->group->stub_sec->contents + stub_entry->stub_offset;
10702
10703   htab->stub_count[stub_entry->stub_type - 1] += 1;
10704   switch (stub_entry->stub_type)
10705     {
10706     case ppc_stub_long_branch:
10707     case ppc_stub_long_branch_r2off:
10708       /* Branches are relative.  This is where we are going to.  */
10709       dest = (stub_entry->target_value
10710               + stub_entry->target_section->output_offset
10711               + stub_entry->target_section->output_section->vma);
10712       dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10713       off = dest;
10714
10715       /* And this is where we are coming from.  */
10716       off -= (stub_entry->stub_offset
10717               + stub_entry->group->stub_sec->output_offset
10718               + stub_entry->group->stub_sec->output_section->vma);
10719
10720       size = 4;
10721       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10722         {
10723           bfd_vma r2off = get_r2off (info, stub_entry);
10724
10725           if (r2off == (bfd_vma) -1)
10726             {
10727               htab->stub_error = TRUE;
10728               return FALSE;
10729             }
10730           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10731           loc += 4;
10732           size = 8;
10733           if (PPC_HA (r2off) != 0)
10734             {
10735               bfd_put_32 (htab->params->stub_bfd,
10736                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
10737               loc += 4;
10738               size += 4;
10739             }
10740           if (PPC_LO (r2off) != 0)
10741             {
10742               bfd_put_32 (htab->params->stub_bfd,
10743                           ADDI_R2_R2 | PPC_LO (r2off), loc);
10744               loc += 4;
10745               size += 4;
10746             }
10747           off -= size - 4;
10748         }
10749       bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10750
10751       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10752         {
10753           info->callbacks->einfo
10754             (_("%P: long branch stub `%s' offset overflow\n"),
10755              stub_entry->root.string);
10756           htab->stub_error = TRUE;
10757           return FALSE;
10758         }
10759
10760       if (info->emitrelocations)
10761         {
10762           r = get_relocs (stub_entry->group->stub_sec, 1);
10763           if (r == NULL)
10764             return FALSE;
10765           r->r_offset = loc - stub_entry->group->stub_sec->contents;
10766           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10767           r->r_addend = dest;
10768           if (stub_entry->h != NULL)
10769             {
10770               struct elf_link_hash_entry **hashes;
10771               unsigned long symndx;
10772               struct ppc_link_hash_entry *h;
10773
10774               hashes = elf_sym_hashes (htab->params->stub_bfd);
10775               if (hashes == NULL)
10776                 {
10777                   bfd_size_type hsize;
10778
10779                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10780                   hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
10781                   if (hashes == NULL)
10782                     return FALSE;
10783                   elf_sym_hashes (htab->params->stub_bfd) = hashes;
10784                   htab->stub_globals = 1;
10785                 }
10786               symndx = htab->stub_globals++;
10787               h = stub_entry->h;
10788               hashes[symndx] = &h->elf;
10789               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10790               if (h->oh != NULL && h->oh->is_func)
10791                 h = ppc_follow_link (h->oh);
10792               if (h->elf.root.u.def.section != stub_entry->target_section)
10793                 /* H is an opd symbol.  The addend must be zero.  */
10794                 r->r_addend = 0;
10795               else
10796                 {
10797                   off = (h->elf.root.u.def.value
10798                          + h->elf.root.u.def.section->output_offset
10799                          + h->elf.root.u.def.section->output_section->vma);
10800                   r->r_addend -= off;
10801                 }
10802             }
10803         }
10804       break;
10805
10806     case ppc_stub_plt_branch:
10807     case ppc_stub_plt_branch_r2off:
10808       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10809                                          stub_entry->root.string + 9,
10810                                          FALSE, FALSE);
10811       if (br_entry == NULL)
10812         {
10813           info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
10814                                   stub_entry->root.string);
10815           htab->stub_error = TRUE;
10816           return FALSE;
10817         }
10818
10819       dest = (stub_entry->target_value
10820               + stub_entry->target_section->output_offset
10821               + stub_entry->target_section->output_section->vma);
10822       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10823         dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10824
10825       bfd_put_64 (htab->brlt->owner, dest,
10826                   htab->brlt->contents + br_entry->offset);
10827
10828       if (br_entry->iter == htab->stub_iteration)
10829         {
10830           br_entry->iter = 0;
10831
10832           if (htab->relbrlt != NULL)
10833             {
10834               /* Create a reloc for the branch lookup table entry.  */
10835               Elf_Internal_Rela rela;
10836               bfd_byte *rl;
10837
10838               rela.r_offset = (br_entry->offset
10839                                + htab->brlt->output_offset
10840                                + htab->brlt->output_section->vma);
10841               rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10842               rela.r_addend = dest;
10843
10844               rl = htab->relbrlt->contents;
10845               rl += (htab->relbrlt->reloc_count++
10846                      * sizeof (Elf64_External_Rela));
10847               bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
10848             }
10849           else if (info->emitrelocations)
10850             {
10851               r = get_relocs (htab->brlt, 1);
10852               if (r == NULL)
10853                 return FALSE;
10854               /* brlt, being SEC_LINKER_CREATED does not go through the
10855                  normal reloc processing.  Symbols and offsets are not
10856                  translated from input file to output file form, so
10857                  set up the offset per the output file.  */
10858               r->r_offset = (br_entry->offset
10859                              + htab->brlt->output_offset
10860                              + htab->brlt->output_section->vma);
10861               r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10862               r->r_addend = dest;
10863             }
10864         }
10865
10866       dest = (br_entry->offset
10867               + htab->brlt->output_offset
10868               + htab->brlt->output_section->vma);
10869
10870       off = (dest
10871              - elf_gp (htab->brlt->output_section->owner)
10872              - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
10873
10874       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10875         {
10876           info->callbacks->einfo
10877             (_("%P: linkage table error against `%T'\n"),
10878              stub_entry->root.string);
10879           bfd_set_error (bfd_error_bad_value);
10880           htab->stub_error = TRUE;
10881           return FALSE;
10882         }
10883
10884       if (info->emitrelocations)
10885         {
10886           r = get_relocs (stub_entry->group->stub_sec, 1 + (PPC_HA (off) != 0));
10887           if (r == NULL)
10888             return FALSE;
10889           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
10890           if (bfd_big_endian (info->output_bfd))
10891             r[0].r_offset += 2;
10892           if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
10893             r[0].r_offset += 4;
10894           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10895           r[0].r_addend = dest;
10896           if (PPC_HA (off) != 0)
10897             {
10898               r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10899               r[1].r_offset = r[0].r_offset + 4;
10900               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10901               r[1].r_addend = r[0].r_addend;
10902             }
10903         }
10904
10905       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10906         {
10907           if (PPC_HA (off) != 0)
10908             {
10909               size = 16;
10910               bfd_put_32 (htab->params->stub_bfd,
10911                           ADDIS_R12_R2 | PPC_HA (off), loc);
10912               loc += 4;
10913               bfd_put_32 (htab->params->stub_bfd,
10914                           LD_R12_0R12 | PPC_LO (off), loc);
10915             }
10916           else
10917             {
10918               size = 12;
10919               bfd_put_32 (htab->params->stub_bfd,
10920                           LD_R12_0R2 | PPC_LO (off), loc);
10921             }
10922         }
10923       else
10924         {
10925           bfd_vma r2off = get_r2off (info, stub_entry);
10926
10927           if (r2off == (bfd_vma) -1)
10928             {
10929               htab->stub_error = TRUE;
10930               return FALSE;
10931             }
10932
10933           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10934           loc += 4;
10935           size = 16;
10936           if (PPC_HA (off) != 0)
10937             {
10938               size += 4;
10939               bfd_put_32 (htab->params->stub_bfd,
10940                           ADDIS_R12_R2 | PPC_HA (off), loc);
10941               loc += 4;
10942               bfd_put_32 (htab->params->stub_bfd,
10943                           LD_R12_0R12 | PPC_LO (off), loc);
10944             }
10945           else
10946             bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
10947
10948           if (PPC_HA (r2off) != 0)
10949             {
10950               size += 4;
10951               loc += 4;
10952               bfd_put_32 (htab->params->stub_bfd,
10953                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
10954             }
10955           if (PPC_LO (r2off) != 0)
10956             {
10957               size += 4;
10958               loc += 4;
10959               bfd_put_32 (htab->params->stub_bfd,
10960                           ADDI_R2_R2 | PPC_LO (r2off), loc);
10961             }
10962         }
10963       loc += 4;
10964       bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, loc);
10965       loc += 4;
10966       bfd_put_32 (htab->params->stub_bfd, BCTR, loc);
10967       break;
10968
10969     case ppc_stub_plt_call:
10970     case ppc_stub_plt_call_r2save:
10971       if (stub_entry->h != NULL
10972           && stub_entry->h->is_func_descriptor
10973           && stub_entry->h->oh != NULL)
10974         {
10975           struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
10976
10977           /* If the old-ABI "dot-symbol" is undefined make it weak so
10978              we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.  */
10979           if (fh->elf.root.type == bfd_link_hash_undefined)
10980             fh->elf.root.type = bfd_link_hash_undefweak;
10981           /* Stop undo_symbol_twiddle changing it back to undefined.  */
10982           fh->was_undefined = 0;
10983         }
10984
10985       /* Now build the stub.  */
10986       dest = stub_entry->plt_ent->plt.offset & ~1;
10987       if (dest >= (bfd_vma) -2)
10988         abort ();
10989
10990       plt = htab->elf.splt;
10991       if (!htab->elf.dynamic_sections_created
10992           || stub_entry->h == NULL
10993           || stub_entry->h->elf.dynindx == -1)
10994         plt = htab->elf.iplt;
10995
10996       dest += plt->output_offset + plt->output_section->vma;
10997
10998       if (stub_entry->h == NULL
10999           && (stub_entry->plt_ent->plt.offset & 1) == 0)
11000         {
11001           Elf_Internal_Rela rela;
11002           bfd_byte *rl;
11003
11004           rela.r_offset = dest;
11005           if (htab->opd_abi)
11006             rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
11007           else
11008             rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
11009           rela.r_addend = (stub_entry->target_value
11010                            + stub_entry->target_section->output_offset
11011                            + stub_entry->target_section->output_section->vma);
11012
11013           rl = (htab->elf.irelplt->contents
11014                 + (htab->elf.irelplt->reloc_count++
11015                    * sizeof (Elf64_External_Rela)));
11016           bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
11017           stub_entry->plt_ent->plt.offset |= 1;
11018         }
11019
11020       off = (dest
11021              - elf_gp (plt->output_section->owner)
11022              - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11023
11024       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11025         {
11026           info->callbacks->einfo
11027             (_("%P: linkage table error against `%T'\n"),
11028              stub_entry->h != NULL
11029              ? stub_entry->h->elf.root.root.string
11030              : "<local sym>");
11031           bfd_set_error (bfd_error_bad_value);
11032           htab->stub_error = TRUE;
11033           return FALSE;
11034         }
11035
11036       if (htab->params->plt_stub_align != 0)
11037         {
11038           unsigned pad = plt_stub_pad (htab, stub_entry, off);
11039
11040           stub_entry->group->stub_sec->size += pad;
11041           stub_entry->stub_offset = stub_entry->group->stub_sec->size;
11042           loc += pad;
11043         }
11044
11045       r = NULL;
11046       if (info->emitrelocations)
11047         {
11048           r = get_relocs (stub_entry->group->stub_sec,
11049                           ((PPC_HA (off) != 0)
11050                            + (htab->opd_abi
11051                               ? 2 + (htab->params->plt_static_chain
11052                                      && PPC_HA (off + 16) == PPC_HA (off))
11053                               : 1)));
11054           if (r == NULL)
11055             return FALSE;
11056           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11057           if (bfd_big_endian (info->output_bfd))
11058             r[0].r_offset += 2;
11059           r[0].r_addend = dest;
11060         }
11061       if (stub_entry->h != NULL
11062           && (stub_entry->h == htab->tls_get_addr_fd
11063               || stub_entry->h == htab->tls_get_addr)
11064           && htab->params->tls_get_addr_opt)
11065         p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
11066       else
11067         p = build_plt_stub (htab, stub_entry, loc, off, r);
11068       size = p - loc;
11069       break;
11070
11071     case ppc_stub_save_res:
11072       return TRUE;
11073
11074     default:
11075       BFD_FAIL ();
11076       return FALSE;
11077     }
11078
11079   stub_entry->group->stub_sec->size += size;
11080
11081   if (htab->params->emit_stub_syms)
11082     {
11083       struct elf_link_hash_entry *h;
11084       size_t len1, len2;
11085       char *name;
11086       const char *const stub_str[] = { "long_branch",
11087                                        "long_branch_r2off",
11088                                        "plt_branch",
11089                                        "plt_branch_r2off",
11090                                        "plt_call",
11091                                        "plt_call" };
11092
11093       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
11094       len2 = strlen (stub_entry->root.string);
11095       name = bfd_malloc (len1 + len2 + 2);
11096       if (name == NULL)
11097         return FALSE;
11098       memcpy (name, stub_entry->root.string, 9);
11099       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
11100       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
11101       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
11102       if (h == NULL)
11103         return FALSE;
11104       if (h->root.type == bfd_link_hash_new)
11105         {
11106           h->root.type = bfd_link_hash_defined;
11107           h->root.u.def.section = stub_entry->group->stub_sec;
11108           h->root.u.def.value = stub_entry->stub_offset;
11109           h->ref_regular = 1;
11110           h->def_regular = 1;
11111           h->ref_regular_nonweak = 1;
11112           h->forced_local = 1;
11113           h->non_elf = 0;
11114           h->root.linker_def = 1;
11115         }
11116     }
11117
11118   return TRUE;
11119 }
11120
11121 /* As above, but don't actually build the stub.  Just bump offset so
11122    we know stub section sizes, and select plt_branch stubs where
11123    long_branch stubs won't do.  */
11124
11125 static bfd_boolean
11126 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11127 {
11128   struct ppc_stub_hash_entry *stub_entry;
11129   struct bfd_link_info *info;
11130   struct ppc_link_hash_table *htab;
11131   bfd_vma off;
11132   int size;
11133
11134   /* Massage our args to the form they really have.  */
11135   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11136   info = in_arg;
11137
11138   htab = ppc_hash_table (info);
11139   if (htab == NULL)
11140     return FALSE;
11141
11142   if (stub_entry->h != NULL
11143       && stub_entry->h->save_res
11144       && stub_entry->h->elf.root.type == bfd_link_hash_defined
11145       && stub_entry->h->elf.root.u.def.section == htab->sfpr)
11146     {
11147       /* Don't make stubs to out-of-line register save/restore
11148          functions.  Instead, emit copies of the functions.  */
11149       stub_entry->group->needs_save_res = 1;
11150       stub_entry->stub_type = ppc_stub_save_res;
11151       return TRUE;
11152     }
11153
11154   if (stub_entry->stub_type == ppc_stub_plt_call
11155       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11156     {
11157       asection *plt;
11158       off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
11159       if (off >= (bfd_vma) -2)
11160         abort ();
11161       plt = htab->elf.splt;
11162       if (!htab->elf.dynamic_sections_created
11163           || stub_entry->h == NULL
11164           || stub_entry->h->elf.dynindx == -1)
11165         plt = htab->elf.iplt;
11166       off += (plt->output_offset
11167               + plt->output_section->vma
11168               - elf_gp (plt->output_section->owner)
11169               - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11170
11171       size = plt_stub_size (htab, stub_entry, off);
11172       if (htab->params->plt_stub_align)
11173         size += plt_stub_pad (htab, stub_entry, off);
11174       if (info->emitrelocations)
11175         {
11176           stub_entry->group->stub_sec->reloc_count
11177             += ((PPC_HA (off) != 0)
11178                 + (htab->opd_abi
11179                    ? 2 + (htab->params->plt_static_chain
11180                           && PPC_HA (off + 16) == PPC_HA (off))
11181                    : 1));
11182           stub_entry->group->stub_sec->flags |= SEC_RELOC;
11183         }
11184     }
11185   else
11186     {
11187       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
11188          variants.  */
11189       bfd_vma r2off = 0;
11190       bfd_vma local_off = 0;
11191
11192       off = (stub_entry->target_value
11193              + stub_entry->target_section->output_offset
11194              + stub_entry->target_section->output_section->vma);
11195       off -= (stub_entry->group->stub_sec->size
11196               + stub_entry->group->stub_sec->output_offset
11197               + stub_entry->group->stub_sec->output_section->vma);
11198
11199       /* Reset the stub type from the plt variant in case we now
11200          can reach with a shorter stub.  */
11201       if (stub_entry->stub_type >= ppc_stub_plt_branch)
11202         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
11203
11204       size = 4;
11205       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11206         {
11207           r2off = get_r2off (info, stub_entry);
11208           if (r2off == (bfd_vma) -1)
11209             {
11210               htab->stub_error = TRUE;
11211               return FALSE;
11212             }
11213           size = 8;
11214           if (PPC_HA (r2off) != 0)
11215             size += 4;
11216           if (PPC_LO (r2off) != 0)
11217             size += 4;
11218           off -= size - 4;
11219         }
11220
11221       local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11222
11223       /* If the branch offset if too big, use a ppc_stub_plt_branch.
11224          Do the same for -R objects without function descriptors.  */
11225       if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
11226           || (stub_entry->stub_type == ppc_stub_long_branch_r2off
11227               && r2off == 0
11228               && htab->sec_info[stub_entry->target_section->id].toc_off == 0))
11229         {
11230           struct ppc_branch_hash_entry *br_entry;
11231
11232           br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11233                                              stub_entry->root.string + 9,
11234                                              TRUE, FALSE);
11235           if (br_entry == NULL)
11236             {
11237               info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
11238                                       stub_entry->root.string);
11239               htab->stub_error = TRUE;
11240               return FALSE;
11241             }
11242
11243           if (br_entry->iter != htab->stub_iteration)
11244             {
11245               br_entry->iter = htab->stub_iteration;
11246               br_entry->offset = htab->brlt->size;
11247               htab->brlt->size += 8;
11248
11249               if (htab->relbrlt != NULL)
11250                 htab->relbrlt->size += sizeof (Elf64_External_Rela);
11251               else if (info->emitrelocations)
11252                 {
11253                   htab->brlt->reloc_count += 1;
11254                   htab->brlt->flags |= SEC_RELOC;
11255                 }
11256             }
11257
11258           stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
11259           off = (br_entry->offset
11260                  + htab->brlt->output_offset
11261                  + htab->brlt->output_section->vma
11262                  - elf_gp (htab->brlt->output_section->owner)
11263                  - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11264
11265           if (info->emitrelocations)
11266             {
11267               stub_entry->group->stub_sec->reloc_count
11268                 += 1 + (PPC_HA (off) != 0);
11269               stub_entry->group->stub_sec->flags |= SEC_RELOC;
11270             }
11271
11272           if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11273             {
11274               size = 12;
11275               if (PPC_HA (off) != 0)
11276                 size = 16;
11277             }
11278           else
11279             {
11280               size = 16;
11281               if (PPC_HA (off) != 0)
11282                 size += 4;
11283
11284               if (PPC_HA (r2off) != 0)
11285                 size += 4;
11286               if (PPC_LO (r2off) != 0)
11287                 size += 4;
11288             }
11289         }
11290       else if (info->emitrelocations)
11291         {
11292           stub_entry->group->stub_sec->reloc_count += 1;
11293           stub_entry->group->stub_sec->flags |= SEC_RELOC;
11294         }
11295     }
11296
11297   stub_entry->group->stub_sec->size += size;
11298   return TRUE;
11299 }
11300
11301 /* Set up various things so that we can make a list of input sections
11302    for each output section included in the link.  Returns -1 on error,
11303    0 when no stubs will be needed, and 1 on success.  */
11304
11305 int
11306 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
11307 {
11308   unsigned int id;
11309   bfd_size_type amt;
11310   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11311
11312   if (htab == NULL)
11313     return -1;
11314
11315   htab->sec_info_arr_size = bfd_get_next_section_id ();
11316   amt = sizeof (*htab->sec_info) * (htab->sec_info_arr_size);
11317   htab->sec_info = bfd_zmalloc (amt);
11318   if (htab->sec_info == NULL)
11319     return -1;
11320
11321   /* Set toc_off for com, und, abs and ind sections.  */
11322   for (id = 0; id < 3; id++)
11323     htab->sec_info[id].toc_off = TOC_BASE_OFF;
11324
11325   return 1;
11326 }
11327
11328 /* Set up for first pass at multitoc partitioning.  */
11329
11330 void
11331 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11332 {
11333   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11334
11335   htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11336   htab->toc_bfd = NULL;
11337   htab->toc_first_sec = NULL;
11338 }
11339
11340 /* The linker repeatedly calls this function for each TOC input section
11341    and linker generated GOT section.  Group input bfds such that the toc
11342    within a group is less than 64k in size.  */
11343
11344 bfd_boolean
11345 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11346 {
11347   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11348   bfd_vma addr, off, limit;
11349
11350   if (htab == NULL)
11351     return FALSE;
11352
11353   if (!htab->second_toc_pass)
11354     {
11355       /* Keep track of the first .toc or .got section for this input bfd.  */
11356       bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11357
11358       if (new_bfd)
11359         {
11360           htab->toc_bfd = isec->owner;
11361           htab->toc_first_sec = isec;
11362         }
11363
11364       addr = isec->output_offset + isec->output_section->vma;
11365       off = addr - htab->toc_curr;
11366       limit = 0x80008000;
11367       if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11368         limit = 0x10000;
11369       if (off + isec->size > limit)
11370         {
11371           addr = (htab->toc_first_sec->output_offset
11372                   + htab->toc_first_sec->output_section->vma);
11373           htab->toc_curr = addr;
11374           htab->toc_curr &= -TOC_BASE_ALIGN;
11375         }
11376
11377       /* toc_curr is the base address of this toc group.  Set elf_gp
11378          for the input section to be the offset relative to the
11379          output toc base plus 0x8000.  Making the input elf_gp an
11380          offset allows us to move the toc as a whole without
11381          recalculating input elf_gp.  */
11382       off = htab->toc_curr - elf_gp (isec->output_section->owner);
11383       off += TOC_BASE_OFF;
11384
11385       /* Die if someone uses a linker script that doesn't keep input
11386          file .toc and .got together.  */
11387       if (new_bfd
11388           && elf_gp (isec->owner) != 0
11389           && elf_gp (isec->owner) != off)
11390         return FALSE;
11391
11392       elf_gp (isec->owner) = off;
11393       return TRUE;
11394     }
11395
11396   /* During the second pass toc_first_sec points to the start of
11397      a toc group, and toc_curr is used to track the old elf_gp.
11398      We use toc_bfd to ensure we only look at each bfd once.  */
11399   if (htab->toc_bfd == isec->owner)
11400     return TRUE;
11401   htab->toc_bfd = isec->owner;
11402
11403   if (htab->toc_first_sec == NULL
11404       || htab->toc_curr != elf_gp (isec->owner))
11405     {
11406       htab->toc_curr = elf_gp (isec->owner);
11407       htab->toc_first_sec = isec;
11408     }
11409   addr = (htab->toc_first_sec->output_offset
11410           + htab->toc_first_sec->output_section->vma);
11411   off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
11412   elf_gp (isec->owner) = off;
11413
11414   return TRUE;
11415 }
11416
11417 /* Called via elf_link_hash_traverse to merge GOT entries for global
11418    symbol H.  */
11419
11420 static bfd_boolean
11421 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11422 {
11423   if (h->root.type == bfd_link_hash_indirect)
11424     return TRUE;
11425
11426   merge_got_entries (&h->got.glist);
11427
11428   return TRUE;
11429 }
11430
11431 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11432    symbol H.  */
11433
11434 static bfd_boolean
11435 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11436 {
11437   struct got_entry *gent;
11438
11439   if (h->root.type == bfd_link_hash_indirect)
11440     return TRUE;
11441
11442   for (gent = h->got.glist; gent != NULL; gent = gent->next)
11443     if (!gent->is_indirect)
11444       allocate_got (h, (struct bfd_link_info *) inf, gent);
11445   return TRUE;
11446 }
11447
11448 /* Called on the first multitoc pass after the last call to
11449    ppc64_elf_next_toc_section.  This function removes duplicate GOT
11450    entries.  */
11451
11452 bfd_boolean
11453 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11454 {
11455   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11456   struct bfd *ibfd, *ibfd2;
11457   bfd_boolean done_something;
11458
11459   htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11460
11461   if (!htab->do_multi_toc)
11462     return FALSE;
11463
11464   /* Merge global sym got entries within a toc group.  */
11465   elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11466
11467   /* And tlsld_got.  */
11468   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11469     {
11470       struct got_entry *ent, *ent2;
11471
11472       if (!is_ppc64_elf (ibfd))
11473         continue;
11474
11475       ent = ppc64_tlsld_got (ibfd);
11476       if (!ent->is_indirect
11477           && ent->got.offset != (bfd_vma) -1)
11478         {
11479           for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
11480             {
11481               if (!is_ppc64_elf (ibfd2))
11482                 continue;
11483
11484               ent2 = ppc64_tlsld_got (ibfd2);
11485               if (!ent2->is_indirect
11486                   && ent2->got.offset != (bfd_vma) -1
11487                   && elf_gp (ibfd2) == elf_gp (ibfd))
11488                 {
11489                   ent2->is_indirect = TRUE;
11490                   ent2->got.ent = ent;
11491                 }
11492             }
11493         }
11494     }
11495
11496   /* Zap sizes of got sections.  */
11497   htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11498   htab->elf.irelplt->size -= htab->got_reli_size;
11499   htab->got_reli_size = 0;
11500
11501   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11502     {
11503       asection *got, *relgot;
11504
11505       if (!is_ppc64_elf (ibfd))
11506         continue;
11507
11508       got = ppc64_elf_tdata (ibfd)->got;
11509       if (got != NULL)
11510         {
11511           got->rawsize = got->size;
11512           got->size = 0;
11513           relgot = ppc64_elf_tdata (ibfd)->relgot;
11514           relgot->rawsize = relgot->size;
11515           relgot->size = 0;
11516         }
11517     }
11518
11519   /* Now reallocate the got, local syms first.  We don't need to
11520      allocate section contents again since we never increase size.  */
11521   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11522     {
11523       struct got_entry **lgot_ents;
11524       struct got_entry **end_lgot_ents;
11525       struct plt_entry **local_plt;
11526       struct plt_entry **end_local_plt;
11527       unsigned char *lgot_masks;
11528       bfd_size_type locsymcount;
11529       Elf_Internal_Shdr *symtab_hdr;
11530       asection *s;
11531
11532       if (!is_ppc64_elf (ibfd))
11533         continue;
11534
11535       lgot_ents = elf_local_got_ents (ibfd);
11536       if (!lgot_ents)
11537         continue;
11538
11539       symtab_hdr = &elf_symtab_hdr (ibfd);
11540       locsymcount = symtab_hdr->sh_info;
11541       end_lgot_ents = lgot_ents + locsymcount;
11542       local_plt = (struct plt_entry **) end_lgot_ents;
11543       end_local_plt = local_plt + locsymcount;
11544       lgot_masks = (unsigned char *) end_local_plt;
11545       s = ppc64_elf_tdata (ibfd)->got;
11546       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11547         {
11548           struct got_entry *ent;
11549
11550           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11551             {
11552               unsigned int ent_size = 8;
11553               unsigned int rel_size = sizeof (Elf64_External_Rela);
11554
11555               ent->got.offset = s->size;
11556               if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11557                 {
11558                   ent_size *= 2;
11559                   rel_size *= 2;
11560                 }
11561               s->size += ent_size;
11562               if ((*lgot_masks & PLT_IFUNC) != 0)
11563                 {
11564                   htab->elf.irelplt->size += rel_size;
11565                   htab->got_reli_size += rel_size;
11566                 }
11567               else if (bfd_link_pic (info))
11568                 {
11569                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11570                   srel->size += rel_size;
11571                 }
11572             }
11573         }
11574     }
11575
11576   elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11577
11578   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11579     {
11580       struct got_entry *ent;
11581
11582       if (!is_ppc64_elf (ibfd))
11583         continue;
11584
11585       ent = ppc64_tlsld_got (ibfd);
11586       if (!ent->is_indirect
11587           && ent->got.offset != (bfd_vma) -1)
11588         {
11589           asection *s = ppc64_elf_tdata (ibfd)->got;
11590           ent->got.offset = s->size;
11591           s->size += 16;
11592           if (bfd_link_pic (info))
11593             {
11594               asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11595               srel->size += sizeof (Elf64_External_Rela);
11596             }
11597         }
11598     }
11599
11600   done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11601   if (!done_something)
11602     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11603       {
11604         asection *got;
11605
11606         if (!is_ppc64_elf (ibfd))
11607           continue;
11608
11609         got = ppc64_elf_tdata (ibfd)->got;
11610         if (got != NULL)
11611           {
11612             done_something = got->rawsize != got->size;
11613             if (done_something)
11614               break;
11615           }
11616       }
11617
11618   if (done_something)
11619     (*htab->params->layout_sections_again) ();
11620
11621   /* Set up for second pass over toc sections to recalculate elf_gp
11622      on input sections.  */
11623   htab->toc_bfd = NULL;
11624   htab->toc_first_sec = NULL;
11625   htab->second_toc_pass = TRUE;
11626   return done_something;
11627 }
11628
11629 /* Called after second pass of multitoc partitioning.  */
11630
11631 void
11632 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11633 {
11634   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11635
11636   /* After the second pass, toc_curr tracks the TOC offset used
11637      for code sections below in ppc64_elf_next_input_section.  */
11638   htab->toc_curr = TOC_BASE_OFF;
11639 }
11640
11641 /* No toc references were found in ISEC.  If the code in ISEC makes no
11642    calls, then there's no need to use toc adjusting stubs when branching
11643    into ISEC.  Actually, indirect calls from ISEC are OK as they will
11644    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
11645    needed, and 2 if a cyclical call-graph was found but no other reason
11646    for a stub was detected.  If called from the top level, a return of
11647    2 means the same as a return of 0.  */
11648
11649 static int
11650 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11651 {
11652   int ret;
11653
11654   /* Mark this section as checked.  */
11655   isec->call_check_done = 1;
11656
11657   /* We know none of our code bearing sections will need toc stubs.  */
11658   if ((isec->flags & SEC_LINKER_CREATED) != 0)
11659     return 0;
11660
11661   if (isec->size == 0)
11662     return 0;
11663
11664   if (isec->output_section == NULL)
11665     return 0;
11666
11667   ret = 0;
11668   if (isec->reloc_count != 0)
11669     {
11670       Elf_Internal_Rela *relstart, *rel;
11671       Elf_Internal_Sym *local_syms;
11672       struct ppc_link_hash_table *htab;
11673
11674       relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11675                                             info->keep_memory);
11676       if (relstart == NULL)
11677         return -1;
11678
11679       /* Look for branches to outside of this section.  */
11680       local_syms = NULL;
11681       htab = ppc_hash_table (info);
11682       if (htab == NULL)
11683         return -1;
11684
11685       for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11686         {
11687           enum elf_ppc64_reloc_type r_type;
11688           unsigned long r_symndx;
11689           struct elf_link_hash_entry *h;
11690           struct ppc_link_hash_entry *eh;
11691           Elf_Internal_Sym *sym;
11692           asection *sym_sec;
11693           struct _opd_sec_data *opd;
11694           bfd_vma sym_value;
11695           bfd_vma dest;
11696
11697           r_type = ELF64_R_TYPE (rel->r_info);
11698           if (r_type != R_PPC64_REL24
11699               && r_type != R_PPC64_REL14
11700               && r_type != R_PPC64_REL14_BRTAKEN
11701               && r_type != R_PPC64_REL14_BRNTAKEN)
11702             continue;
11703
11704           r_symndx = ELF64_R_SYM (rel->r_info);
11705           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11706                           isec->owner))
11707             {
11708               ret = -1;
11709               break;
11710             }
11711
11712           /* Calls to dynamic lib functions go through a plt call stub
11713              that uses r2.  */
11714           eh = (struct ppc_link_hash_entry *) h;
11715           if (eh != NULL
11716               && (eh->elf.plt.plist != NULL
11717                   || (eh->oh != NULL
11718                       && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11719             {
11720               ret = 1;
11721               break;
11722             }
11723
11724           if (sym_sec == NULL)
11725             /* Ignore other undefined symbols.  */
11726             continue;
11727
11728           /* Assume branches to other sections not included in the
11729              link need stubs too, to cover -R and absolute syms.  */
11730           if (sym_sec->output_section == NULL)
11731             {
11732               ret = 1;
11733               break;
11734             }
11735
11736           if (h == NULL)
11737             sym_value = sym->st_value;
11738           else
11739             {
11740               if (h->root.type != bfd_link_hash_defined
11741                   && h->root.type != bfd_link_hash_defweak)
11742                 abort ();
11743               sym_value = h->root.u.def.value;
11744             }
11745           sym_value += rel->r_addend;
11746
11747           /* If this branch reloc uses an opd sym, find the code section.  */
11748           opd = get_opd_info (sym_sec);
11749           if (opd != NULL)
11750             {
11751               if (h == NULL && opd->adjust != NULL)
11752                 {
11753                   long adjust;
11754
11755                   adjust = opd->adjust[OPD_NDX (sym_value)];
11756                   if (adjust == -1)
11757                     /* Assume deleted functions won't ever be called.  */
11758                     continue;
11759                   sym_value += adjust;
11760                 }
11761
11762               dest = opd_entry_value (sym_sec, sym_value,
11763                                       &sym_sec, NULL, FALSE);
11764               if (dest == (bfd_vma) -1)
11765                 continue;
11766             }
11767           else
11768             dest = (sym_value
11769                     + sym_sec->output_offset
11770                     + sym_sec->output_section->vma);
11771
11772           /* Ignore branch to self.  */
11773           if (sym_sec == isec)
11774             continue;
11775
11776           /* If the called function uses the toc, we need a stub.  */
11777           if (sym_sec->has_toc_reloc
11778               || sym_sec->makes_toc_func_call)
11779             {
11780               ret = 1;
11781               break;
11782             }
11783
11784           /* Assume any branch that needs a long branch stub might in fact
11785              need a plt_branch stub.  A plt_branch stub uses r2.  */
11786           else if (dest - (isec->output_offset
11787                            + isec->output_section->vma
11788                            + rel->r_offset) + (1 << 25)
11789                    >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
11790                                                              ? h->other
11791                                                              : sym->st_other))
11792             {
11793               ret = 1;
11794               break;
11795             }
11796
11797           /* If calling back to a section in the process of being
11798              tested, we can't say for sure that no toc adjusting stubs
11799              are needed, so don't return zero.  */
11800           else if (sym_sec->call_check_in_progress)
11801             ret = 2;
11802
11803           /* Branches to another section that itself doesn't have any TOC
11804              references are OK.  Recursively call ourselves to check.  */
11805           else if (!sym_sec->call_check_done)
11806             {
11807               int recur;
11808
11809               /* Mark current section as indeterminate, so that other
11810                  sections that call back to current won't be marked as
11811                  known.  */
11812               isec->call_check_in_progress = 1;
11813               recur = toc_adjusting_stub_needed (info, sym_sec);
11814               isec->call_check_in_progress = 0;
11815
11816               if (recur != 0)
11817                 {
11818                   ret = recur;
11819                   if (recur != 2)
11820                     break;
11821                 }
11822             }
11823         }
11824
11825       if (local_syms != NULL
11826           && (elf_symtab_hdr (isec->owner).contents
11827               != (unsigned char *) local_syms))
11828         free (local_syms);
11829       if (elf_section_data (isec)->relocs != relstart)
11830         free (relstart);
11831     }
11832
11833   if ((ret & 1) == 0
11834       && isec->map_head.s != NULL
11835       && (strcmp (isec->output_section->name, ".init") == 0
11836           || strcmp (isec->output_section->name, ".fini") == 0))
11837     {
11838       if (isec->map_head.s->has_toc_reloc
11839           || isec->map_head.s->makes_toc_func_call)
11840         ret = 1;
11841       else if (!isec->map_head.s->call_check_done)
11842         {
11843           int recur;
11844           isec->call_check_in_progress = 1;
11845           recur = toc_adjusting_stub_needed (info, isec->map_head.s);
11846           isec->call_check_in_progress = 0;
11847           if (recur != 0)
11848             ret = recur;
11849         }
11850     }
11851
11852   if (ret == 1)
11853     isec->makes_toc_func_call = 1;
11854
11855   return ret;
11856 }
11857
11858 /* The linker repeatedly calls this function for each input section,
11859    in the order that input sections are linked into output sections.
11860    Build lists of input sections to determine groupings between which
11861    we may insert linker stubs.  */
11862
11863 bfd_boolean
11864 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
11865 {
11866   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11867
11868   if (htab == NULL)
11869     return FALSE;
11870
11871   if ((isec->output_section->flags & SEC_CODE) != 0
11872       && isec->output_section->id < htab->sec_info_arr_size)
11873     {
11874       /* This happens to make the list in reverse order,
11875          which is what we want.  */
11876       htab->sec_info[isec->id].u.list
11877         = htab->sec_info[isec->output_section->id].u.list;
11878       htab->sec_info[isec->output_section->id].u.list = isec;
11879     }
11880
11881   if (htab->multi_toc_needed)
11882     {
11883       /* Analyse sections that aren't already flagged as needing a
11884          valid toc pointer.  Exclude .fixup for the linux kernel.
11885          .fixup contains branches, but only back to the function that
11886          hit an exception.  */
11887       if (!(isec->has_toc_reloc
11888             || (isec->flags & SEC_CODE) == 0
11889             || strcmp (isec->name, ".fixup") == 0
11890             || isec->call_check_done))
11891         {
11892           if (toc_adjusting_stub_needed (info, isec) < 0)
11893             return FALSE;
11894         }
11895       /* Make all sections use the TOC assigned for this object file.
11896          This will be wrong for pasted sections;  We fix that in
11897          check_pasted_section().  */
11898       if (elf_gp (isec->owner) != 0)
11899         htab->toc_curr = elf_gp (isec->owner);
11900     }
11901
11902   htab->sec_info[isec->id].toc_off = htab->toc_curr;
11903   return TRUE;
11904 }
11905
11906 /* Check that all .init and .fini sections use the same toc, if they
11907    have toc relocs.  */
11908
11909 static bfd_boolean
11910 check_pasted_section (struct bfd_link_info *info, const char *name)
11911 {
11912   asection *o = bfd_get_section_by_name (info->output_bfd, name);
11913
11914   if (o != NULL)
11915     {
11916       struct ppc_link_hash_table *htab = ppc_hash_table (info);
11917       bfd_vma toc_off = 0;
11918       asection *i;
11919
11920       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11921         if (i->has_toc_reloc)
11922           {
11923             if (toc_off == 0)
11924               toc_off = htab->sec_info[i->id].toc_off;
11925             else if (toc_off != htab->sec_info[i->id].toc_off)
11926               return FALSE;
11927           }
11928
11929       if (toc_off == 0)
11930         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11931           if (i->makes_toc_func_call)
11932             {
11933               toc_off = htab->sec_info[i->id].toc_off;
11934               break;
11935             }
11936
11937       /* Make sure the whole pasted function uses the same toc offset.  */
11938       if (toc_off != 0)
11939         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11940           htab->sec_info[i->id].toc_off = toc_off;
11941     }
11942   return TRUE;
11943 }
11944
11945 bfd_boolean
11946 ppc64_elf_check_init_fini (struct bfd_link_info *info)
11947 {
11948   return (check_pasted_section (info, ".init")
11949           & check_pasted_section (info, ".fini"));
11950 }
11951
11952 /* See whether we can group stub sections together.  Grouping stub
11953    sections may result in fewer stubs.  More importantly, we need to
11954    put all .init* and .fini* stubs at the beginning of the .init or
11955    .fini output sections respectively, because glibc splits the
11956    _init and _fini functions into multiple parts.  Putting a stub in
11957    the middle of a function is not a good idea.  */
11958
11959 static bfd_boolean
11960 group_sections (struct bfd_link_info *info,
11961                 bfd_size_type stub_group_size,
11962                 bfd_boolean stubs_always_before_branch)
11963 {
11964   struct ppc_link_hash_table *htab;
11965   asection *osec;
11966   bfd_size_type stub14_group_size;
11967   bfd_boolean suppress_size_errors;
11968
11969   htab = ppc_hash_table (info);
11970   if (htab == NULL)
11971     return FALSE;
11972
11973   suppress_size_errors = FALSE;
11974   stub14_group_size = stub_group_size >> 10;
11975   if (stub_group_size == 1)
11976     {
11977       /* Default values.  */
11978       if (stubs_always_before_branch)
11979         {
11980           stub_group_size = 0x1e00000;
11981           stub14_group_size = 0x7800;
11982         }
11983       else
11984         {
11985           stub_group_size = 0x1c00000;
11986           stub14_group_size = 0x7000;
11987         }
11988       suppress_size_errors = TRUE;
11989     }
11990
11991   for (osec = info->output_bfd->sections; osec != NULL; osec = osec->next)
11992     {
11993       asection *tail;
11994
11995       if (osec->id >= htab->sec_info_arr_size)
11996         continue;
11997
11998       tail = htab->sec_info[osec->id].u.list;
11999       while (tail != NULL)
12000         {
12001           asection *curr;
12002           asection *prev;
12003           bfd_size_type total;
12004           bfd_boolean big_sec;
12005           bfd_vma curr_toc;
12006           struct map_stub *group;
12007
12008           curr = tail;
12009           total = tail->size;
12010           big_sec = total > (ppc64_elf_section_data (tail) != NULL
12011                              && ppc64_elf_section_data (tail)->has_14bit_branch
12012                              ? stub14_group_size : stub_group_size);
12013           if (big_sec && !suppress_size_errors)
12014             (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
12015                                      tail->owner, tail);
12016           curr_toc = htab->sec_info[tail->id].toc_off;
12017
12018           while ((prev = htab->sec_info[curr->id].u.list) != NULL
12019                  && ((total += curr->output_offset - prev->output_offset)
12020                      < (ppc64_elf_section_data (prev) != NULL
12021                         && ppc64_elf_section_data (prev)->has_14bit_branch
12022                         ? stub14_group_size : stub_group_size))
12023                  && htab->sec_info[prev->id].toc_off == curr_toc)
12024             curr = prev;
12025
12026           /* OK, the size from the start of CURR to the end is less
12027              than stub_group_size and thus can be handled by one stub
12028              section.  (or the tail section is itself larger than
12029              stub_group_size, in which case we may be toast.)  We
12030              should really be keeping track of the total size of stubs
12031              added here, as stubs contribute to the final output
12032              section size.  That's a little tricky, and this way will
12033              only break if stubs added make the total size more than
12034              2^25, ie. for the default stub_group_size, if stubs total
12035              more than 2097152 bytes, or nearly 75000 plt call stubs.  */
12036           group = bfd_alloc (curr->owner, sizeof (*group));
12037           if (group == NULL)
12038             return FALSE;
12039           group->link_sec = curr;
12040           group->stub_sec = NULL;
12041           group->needs_save_res = 0;
12042           group->next = htab->group;
12043           htab->group = group;
12044           do
12045             {
12046               prev = htab->sec_info[tail->id].u.list;
12047               /* Set up this stub group.  */
12048               htab->sec_info[tail->id].u.group = group;
12049             }
12050           while (tail != curr && (tail = prev) != NULL);
12051
12052           /* But wait, there's more!  Input sections up to stub_group_size
12053              bytes before the stub section can be handled by it too.
12054              Don't do this if we have a really large section after the
12055              stubs, as adding more stubs increases the chance that
12056              branches may not reach into the stub section.  */
12057           if (!stubs_always_before_branch && !big_sec)
12058             {
12059               total = 0;
12060               while (prev != NULL
12061                      && ((total += tail->output_offset - prev->output_offset)
12062                          < (ppc64_elf_section_data (prev) != NULL
12063                             && ppc64_elf_section_data (prev)->has_14bit_branch
12064                             ? stub14_group_size : stub_group_size))
12065                      && htab->sec_info[prev->id].toc_off == curr_toc)
12066                 {
12067                   tail = prev;
12068                   prev = htab->sec_info[tail->id].u.list;
12069                   htab->sec_info[tail->id].u.group = group;
12070                 }
12071             }
12072           tail = prev;
12073         }
12074     }
12075   return TRUE;
12076 }
12077
12078 static const unsigned char glink_eh_frame_cie[] =
12079 {
12080   0, 0, 0, 16,                          /* length.  */
12081   0, 0, 0, 0,                           /* id.  */
12082   1,                                    /* CIE version.  */
12083   'z', 'R', 0,                          /* Augmentation string.  */
12084   4,                                    /* Code alignment.  */
12085   0x78,                                 /* Data alignment.  */
12086   65,                                   /* RA reg.  */
12087   1,                                    /* Augmentation size.  */
12088   DW_EH_PE_pcrel | DW_EH_PE_sdata4,     /* FDE encoding.  */
12089   DW_CFA_def_cfa, 1, 0,                 /* def_cfa: r1 offset 0.  */
12090   0, 0, 0, 0
12091 };
12092
12093 /* Stripping output sections is normally done before dynamic section
12094    symbols have been allocated.  This function is called later, and
12095    handles cases like htab->brlt which is mapped to its own output
12096    section.  */
12097
12098 static void
12099 maybe_strip_output (struct bfd_link_info *info, asection *isec)
12100 {
12101   if (isec->size == 0
12102       && isec->output_section->size == 0
12103       && !(isec->output_section->flags & SEC_KEEP)
12104       && !bfd_section_removed_from_list (info->output_bfd,
12105                                          isec->output_section)
12106       && elf_section_data (isec->output_section)->dynindx == 0)
12107     {
12108       isec->output_section->flags |= SEC_EXCLUDE;
12109       bfd_section_list_remove (info->output_bfd, isec->output_section);
12110       info->output_bfd->section_count--;
12111     }
12112 }
12113
12114 /* Determine and set the size of the stub section for a final link.
12115
12116    The basic idea here is to examine all the relocations looking for
12117    PC-relative calls to a target that is unreachable with a "bl"
12118    instruction.  */
12119
12120 bfd_boolean
12121 ppc64_elf_size_stubs (struct bfd_link_info *info)
12122 {
12123   bfd_size_type stub_group_size;
12124   bfd_boolean stubs_always_before_branch;
12125   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12126
12127   if (htab == NULL)
12128     return FALSE;
12129
12130   if (htab->params->plt_thread_safe == -1 && !bfd_link_executable (info))
12131     htab->params->plt_thread_safe = 1;
12132   if (!htab->opd_abi)
12133     htab->params->plt_thread_safe = 0;
12134   else if (htab->params->plt_thread_safe == -1)
12135     {
12136       static const char *const thread_starter[] =
12137         {
12138           "pthread_create",
12139           /* libstdc++ */
12140           "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
12141           /* librt */
12142           "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
12143           "mq_notify", "create_timer",
12144           /* libanl */
12145           "getaddrinfo_a",
12146           /* libgomp */
12147           "GOMP_parallel",
12148           "GOMP_parallel_start",
12149           "GOMP_parallel_loop_static",
12150           "GOMP_parallel_loop_static_start",
12151           "GOMP_parallel_loop_dynamic",
12152           "GOMP_parallel_loop_dynamic_start",
12153           "GOMP_parallel_loop_guided",
12154           "GOMP_parallel_loop_guided_start",
12155           "GOMP_parallel_loop_runtime",
12156           "GOMP_parallel_loop_runtime_start",
12157           "GOMP_parallel_sections",
12158           "GOMP_parallel_sections_start",
12159           /* libgo */
12160           "__go_go",
12161         };
12162       unsigned i;
12163
12164       for (i = 0; i < ARRAY_SIZE (thread_starter); i++)
12165         {
12166           struct elf_link_hash_entry *h;
12167           h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
12168                                     FALSE, FALSE, TRUE);
12169           htab->params->plt_thread_safe = h != NULL && h->ref_regular;
12170           if (htab->params->plt_thread_safe)
12171             break;
12172         }
12173     }
12174   stubs_always_before_branch = htab->params->group_size < 0;
12175   if (htab->params->group_size < 0)
12176     stub_group_size = -htab->params->group_size;
12177   else
12178     stub_group_size = htab->params->group_size;
12179
12180   if (!group_sections (info, stub_group_size, stubs_always_before_branch))
12181     return FALSE;
12182
12183   while (1)
12184     {
12185       bfd *input_bfd;
12186       unsigned int bfd_indx;
12187       struct map_stub *group;
12188       asection *stub_sec;
12189
12190       htab->stub_iteration += 1;
12191
12192       for (input_bfd = info->input_bfds, bfd_indx = 0;
12193            input_bfd != NULL;
12194            input_bfd = input_bfd->link.next, bfd_indx++)
12195         {
12196           Elf_Internal_Shdr *symtab_hdr;
12197           asection *section;
12198           Elf_Internal_Sym *local_syms = NULL;
12199
12200           if (!is_ppc64_elf (input_bfd))
12201             continue;
12202
12203           /* We'll need the symbol table in a second.  */
12204           symtab_hdr = &elf_symtab_hdr (input_bfd);
12205           if (symtab_hdr->sh_info == 0)
12206             continue;
12207
12208           /* Walk over each section attached to the input bfd.  */
12209           for (section = input_bfd->sections;
12210                section != NULL;
12211                section = section->next)
12212             {
12213               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
12214
12215               /* If there aren't any relocs, then there's nothing more
12216                  to do.  */
12217               if ((section->flags & SEC_RELOC) == 0
12218                   || (section->flags & SEC_ALLOC) == 0
12219                   || (section->flags & SEC_LOAD) == 0
12220                   || (section->flags & SEC_CODE) == 0
12221                   || section->reloc_count == 0)
12222                 continue;
12223
12224               /* If this section is a link-once section that will be
12225                  discarded, then don't create any stubs.  */
12226               if (section->output_section == NULL
12227                   || section->output_section->owner != info->output_bfd)
12228                 continue;
12229
12230               /* Get the relocs.  */
12231               internal_relocs
12232                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
12233                                              info->keep_memory);
12234               if (internal_relocs == NULL)
12235                 goto error_ret_free_local;
12236
12237               /* Now examine each relocation.  */
12238               irela = internal_relocs;
12239               irelaend = irela + section->reloc_count;
12240               for (; irela < irelaend; irela++)
12241                 {
12242                   enum elf_ppc64_reloc_type r_type;
12243                   unsigned int r_indx;
12244                   enum ppc_stub_type stub_type;
12245                   struct ppc_stub_hash_entry *stub_entry;
12246                   asection *sym_sec, *code_sec;
12247                   bfd_vma sym_value, code_value;
12248                   bfd_vma destination;
12249                   unsigned long local_off;
12250                   bfd_boolean ok_dest;
12251                   struct ppc_link_hash_entry *hash;
12252                   struct ppc_link_hash_entry *fdh;
12253                   struct elf_link_hash_entry *h;
12254                   Elf_Internal_Sym *sym;
12255                   char *stub_name;
12256                   const asection *id_sec;
12257                   struct _opd_sec_data *opd;
12258                   struct plt_entry *plt_ent;
12259
12260                   r_type = ELF64_R_TYPE (irela->r_info);
12261                   r_indx = ELF64_R_SYM (irela->r_info);
12262
12263                   if (r_type >= R_PPC64_max)
12264                     {
12265                       bfd_set_error (bfd_error_bad_value);
12266                       goto error_ret_free_internal;
12267                     }
12268
12269                   /* Only look for stubs on branch instructions.  */
12270                   if (r_type != R_PPC64_REL24
12271                       && r_type != R_PPC64_REL14
12272                       && r_type != R_PPC64_REL14_BRTAKEN
12273                       && r_type != R_PPC64_REL14_BRNTAKEN)
12274                     continue;
12275
12276                   /* Now determine the call target, its name, value,
12277                      section.  */
12278                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12279                                   r_indx, input_bfd))
12280                     goto error_ret_free_internal;
12281                   hash = (struct ppc_link_hash_entry *) h;
12282
12283                   ok_dest = FALSE;
12284                   fdh = NULL;
12285                   sym_value = 0;
12286                   if (hash == NULL)
12287                     {
12288                       sym_value = sym->st_value;
12289                       if (sym_sec != NULL
12290                           && sym_sec->output_section != NULL)
12291                         ok_dest = TRUE;
12292                     }
12293                   else if (hash->elf.root.type == bfd_link_hash_defined
12294                            || hash->elf.root.type == bfd_link_hash_defweak)
12295                     {
12296                       sym_value = hash->elf.root.u.def.value;
12297                       if (sym_sec->output_section != NULL)
12298                         ok_dest = TRUE;
12299                     }
12300                   else if (hash->elf.root.type == bfd_link_hash_undefweak
12301                            || hash->elf.root.type == bfd_link_hash_undefined)
12302                     {
12303                       /* Recognise an old ABI func code entry sym, and
12304                          use the func descriptor sym instead if it is
12305                          defined.  */
12306                       if (hash->elf.root.root.string[0] == '.'
12307                           && (fdh = lookup_fdh (hash, htab)) != NULL)
12308                         {
12309                           if (fdh->elf.root.type == bfd_link_hash_defined
12310                               || fdh->elf.root.type == bfd_link_hash_defweak)
12311                             {
12312                               sym_sec = fdh->elf.root.u.def.section;
12313                               sym_value = fdh->elf.root.u.def.value;
12314                               if (sym_sec->output_section != NULL)
12315                                 ok_dest = TRUE;
12316                             }
12317                           else
12318                             fdh = NULL;
12319                         }
12320                     }
12321                   else
12322                     {
12323                       bfd_set_error (bfd_error_bad_value);
12324                       goto error_ret_free_internal;
12325                     }
12326
12327                   destination = 0;
12328                   local_off = 0;
12329                   if (ok_dest)
12330                     {
12331                       sym_value += irela->r_addend;
12332                       destination = (sym_value
12333                                      + sym_sec->output_offset
12334                                      + sym_sec->output_section->vma);
12335                       local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12336                                                             ? hash->elf.other
12337                                                             : sym->st_other);
12338                     }
12339
12340                   code_sec = sym_sec;
12341                   code_value = sym_value;
12342                   opd = get_opd_info (sym_sec);
12343                   if (opd != NULL)
12344                     {
12345                       bfd_vma dest;
12346
12347                       if (hash == NULL && opd->adjust != NULL)
12348                         {
12349                           long adjust = opd->adjust[OPD_NDX (sym_value)];
12350                           if (adjust == -1)
12351                             continue;
12352                           code_value += adjust;
12353                           sym_value += adjust;
12354                         }
12355                       dest = opd_entry_value (sym_sec, sym_value,
12356                                               &code_sec, &code_value, FALSE);
12357                       if (dest != (bfd_vma) -1)
12358                         {
12359                           destination = dest;
12360                           if (fdh != NULL)
12361                             {
12362                               /* Fixup old ABI sym to point at code
12363                                  entry.  */
12364                               hash->elf.root.type = bfd_link_hash_defweak;
12365                               hash->elf.root.u.def.section = code_sec;
12366                               hash->elf.root.u.def.value = code_value;
12367                             }
12368                         }
12369                     }
12370
12371                   /* Determine what (if any) linker stub is needed.  */
12372                   plt_ent = NULL;
12373                   stub_type = ppc_type_of_stub (section, irela, &hash,
12374                                                 &plt_ent, destination,
12375                                                 local_off);
12376
12377                   if (stub_type != ppc_stub_plt_call)
12378                     {
12379                       /* Check whether we need a TOC adjusting stub.
12380                          Since the linker pastes together pieces from
12381                          different object files when creating the
12382                          _init and _fini functions, it may be that a
12383                          call to what looks like a local sym is in
12384                          fact a call needing a TOC adjustment.  */
12385                       if (code_sec != NULL
12386                           && code_sec->output_section != NULL
12387                           && (htab->sec_info[code_sec->id].toc_off
12388                               != htab->sec_info[section->id].toc_off)
12389                           && (code_sec->has_toc_reloc
12390                               || code_sec->makes_toc_func_call))
12391                         stub_type = ppc_stub_long_branch_r2off;
12392                     }
12393
12394                   if (stub_type == ppc_stub_none)
12395                     continue;
12396
12397                   /* __tls_get_addr calls might be eliminated.  */
12398                   if (stub_type != ppc_stub_plt_call
12399                       && hash != NULL
12400                       && (hash == htab->tls_get_addr
12401                           || hash == htab->tls_get_addr_fd)
12402                       && section->has_tls_reloc
12403                       && irela != internal_relocs)
12404                     {
12405                       /* Get tls info.  */
12406                       unsigned char *tls_mask;
12407
12408                       if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12409                                          irela - 1, input_bfd))
12410                         goto error_ret_free_internal;
12411                       if (*tls_mask != 0)
12412                         continue;
12413                     }
12414
12415                   if (stub_type == ppc_stub_plt_call
12416                       && irela + 1 < irelaend
12417                       && irela[1].r_offset == irela->r_offset + 4
12418                       && ELF64_R_TYPE (irela[1].r_info) == R_PPC64_TOCSAVE)
12419                     {
12420                       if (!tocsave_find (htab, INSERT,
12421                                          &local_syms, irela + 1, input_bfd))
12422                         goto error_ret_free_internal;
12423                     }
12424                   else if (stub_type == ppc_stub_plt_call)
12425                     stub_type = ppc_stub_plt_call_r2save;
12426
12427                   /* Support for grouping stub sections.  */
12428                   id_sec = htab->sec_info[section->id].u.group->link_sec;
12429
12430                   /* Get the name of this stub.  */
12431                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12432                   if (!stub_name)
12433                     goto error_ret_free_internal;
12434
12435                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12436                                                      stub_name, FALSE, FALSE);
12437                   if (stub_entry != NULL)
12438                     {
12439                       /* The proper stub has already been created.  */
12440                       free (stub_name);
12441                       if (stub_type == ppc_stub_plt_call_r2save)
12442                         stub_entry->stub_type = stub_type;
12443                       continue;
12444                     }
12445
12446                   stub_entry = ppc_add_stub (stub_name, section, info);
12447                   if (stub_entry == NULL)
12448                     {
12449                       free (stub_name);
12450                     error_ret_free_internal:
12451                       if (elf_section_data (section)->relocs == NULL)
12452                         free (internal_relocs);
12453                     error_ret_free_local:
12454                       if (local_syms != NULL
12455                           && (symtab_hdr->contents
12456                               != (unsigned char *) local_syms))
12457                         free (local_syms);
12458                       return FALSE;
12459                     }
12460
12461                   stub_entry->stub_type = stub_type;
12462                   if (stub_type != ppc_stub_plt_call
12463                       && stub_type != ppc_stub_plt_call_r2save)
12464                     {
12465                       stub_entry->target_value = code_value;
12466                       stub_entry->target_section = code_sec;
12467                     }
12468                   else
12469                     {
12470                       stub_entry->target_value = sym_value;
12471                       stub_entry->target_section = sym_sec;
12472                     }
12473                   stub_entry->h = hash;
12474                   stub_entry->plt_ent = plt_ent;
12475                   stub_entry->other = hash ? hash->elf.other : sym->st_other;
12476
12477                   if (stub_entry->h != NULL)
12478                     htab->stub_globals += 1;
12479                 }
12480
12481               /* We're done with the internal relocs, free them.  */
12482               if (elf_section_data (section)->relocs != internal_relocs)
12483                 free (internal_relocs);
12484             }
12485
12486           if (local_syms != NULL
12487               && symtab_hdr->contents != (unsigned char *) local_syms)
12488             {
12489               if (!info->keep_memory)
12490                 free (local_syms);
12491               else
12492                 symtab_hdr->contents = (unsigned char *) local_syms;
12493             }
12494         }
12495
12496       /* We may have added some stubs.  Find out the new size of the
12497          stub sections.  */
12498       for (stub_sec = htab->params->stub_bfd->sections;
12499            stub_sec != NULL;
12500            stub_sec = stub_sec->next)
12501         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12502           {
12503             stub_sec->rawsize = stub_sec->size;
12504             stub_sec->size = 0;
12505             stub_sec->reloc_count = 0;
12506             stub_sec->flags &= ~SEC_RELOC;
12507           }
12508
12509       htab->brlt->size = 0;
12510       htab->brlt->reloc_count = 0;
12511       htab->brlt->flags &= ~SEC_RELOC;
12512       if (htab->relbrlt != NULL)
12513         htab->relbrlt->size = 0;
12514
12515       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12516
12517       for (group = htab->group; group != NULL; group = group->next)
12518         if (group->needs_save_res)
12519           group->stub_sec->size += htab->sfpr->size;
12520
12521       if (info->emitrelocations
12522           && htab->glink != NULL && htab->glink->size != 0)
12523         {
12524           htab->glink->reloc_count = 1;
12525           htab->glink->flags |= SEC_RELOC;
12526         }
12527
12528       if (htab->glink_eh_frame != NULL
12529           && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12530           && htab->glink_eh_frame->output_section->size != 0)
12531         {
12532           size_t size = 0, align;
12533
12534           for (stub_sec = htab->params->stub_bfd->sections;
12535                stub_sec != NULL;
12536                stub_sec = stub_sec->next)
12537             if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12538               size += 24;
12539           if (htab->glink != NULL && htab->glink->size != 0)
12540             size += 24;
12541           if (size != 0)
12542             size += sizeof (glink_eh_frame_cie);
12543           align = 1;
12544           align <<= htab->glink_eh_frame->output_section->alignment_power;
12545           align -= 1;
12546           size = (size + align) & ~align;
12547           htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12548           htab->glink_eh_frame->size = size;
12549         }
12550
12551       if (htab->params->plt_stub_align != 0)
12552         for (stub_sec = htab->params->stub_bfd->sections;
12553              stub_sec != NULL;
12554              stub_sec = stub_sec->next)
12555           if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12556             stub_sec->size = ((stub_sec->size
12557                                + (1 << htab->params->plt_stub_align) - 1)
12558                               & -(1 << htab->params->plt_stub_align));
12559
12560       for (stub_sec = htab->params->stub_bfd->sections;
12561            stub_sec != NULL;
12562            stub_sec = stub_sec->next)
12563         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12564             && stub_sec->rawsize != stub_sec->size)
12565           break;
12566
12567       /* Exit from this loop when no stubs have been added, and no stubs
12568          have changed size.  */
12569       if (stub_sec == NULL
12570           && (htab->glink_eh_frame == NULL
12571               || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12572         break;
12573
12574       /* Ask the linker to do its stuff.  */
12575       (*htab->params->layout_sections_again) ();
12576     }
12577
12578   if (htab->glink_eh_frame != NULL
12579       && htab->glink_eh_frame->size != 0)
12580     {
12581       bfd_vma val;
12582       bfd_byte *p, *last_fde;
12583       size_t last_fde_len, size, align, pad;
12584       asection *stub_sec;
12585
12586       p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12587       if (p == NULL)
12588         return FALSE;
12589       htab->glink_eh_frame->contents = p;
12590       last_fde = p;
12591
12592       memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12593       /* CIE length (rewrite in case little-endian).  */
12594       last_fde_len = sizeof (glink_eh_frame_cie) - 4;
12595       bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12596       p += sizeof (glink_eh_frame_cie);
12597
12598       for (stub_sec = htab->params->stub_bfd->sections;
12599            stub_sec != NULL;
12600            stub_sec = stub_sec->next)
12601         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12602           {
12603             last_fde = p;
12604             last_fde_len = 20;
12605             /* FDE length.  */
12606             bfd_put_32 (htab->elf.dynobj, 20, p);
12607             p += 4;
12608             /* CIE pointer.  */
12609             val = p - htab->glink_eh_frame->contents;
12610             bfd_put_32 (htab->elf.dynobj, val, p);
12611             p += 4;
12612             /* Offset to stub section, written later.  */
12613             p += 4;
12614             /* stub section size.  */
12615             bfd_put_32 (htab->elf.dynobj, stub_sec->size, p);
12616             p += 4;
12617             /* Augmentation.  */
12618             p += 1;
12619             /* Pad.  */
12620             p += 7;
12621           }
12622       if (htab->glink != NULL && htab->glink->size != 0)
12623         {
12624           last_fde = p;
12625           last_fde_len = 20;
12626           /* FDE length.  */
12627           bfd_put_32 (htab->elf.dynobj, 20, p);
12628           p += 4;
12629           /* CIE pointer.  */
12630           val = p - htab->glink_eh_frame->contents;
12631           bfd_put_32 (htab->elf.dynobj, val, p);
12632           p += 4;
12633           /* Offset to .glink, written later.  */
12634           p += 4;
12635           /* .glink size.  */
12636           bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12637           p += 4;
12638           /* Augmentation.  */
12639           p += 1;
12640
12641           *p++ = DW_CFA_advance_loc + 1;
12642           *p++ = DW_CFA_register;
12643           *p++ = 65;
12644           *p++ = htab->opd_abi ? 12 : 0;
12645           *p++ = DW_CFA_advance_loc + 4;
12646           *p++ = DW_CFA_restore_extended;
12647           *p++ = 65;
12648         }
12649       /* Subsume any padding into the last FDE if user .eh_frame
12650          sections are aligned more than glink_eh_frame.  Otherwise any
12651          zero padding will be seen as a terminator.  */
12652       size = p - htab->glink_eh_frame->contents;
12653       align = 1;
12654       align <<= htab->glink_eh_frame->output_section->alignment_power;
12655       align -= 1;
12656       pad = ((size + align) & ~align) - size;
12657       htab->glink_eh_frame->size = size + pad;
12658       bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12659     }
12660
12661   maybe_strip_output (info, htab->brlt);
12662   if (htab->glink_eh_frame != NULL)
12663     maybe_strip_output (info, htab->glink_eh_frame);
12664
12665   return TRUE;
12666 }
12667
12668 /* Called after we have determined section placement.  If sections
12669    move, we'll be called again.  Provide a value for TOCstart.  */
12670
12671 bfd_vma
12672 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12673 {
12674   asection *s;
12675   bfd_vma TOCstart, adjust;
12676
12677   if (info != NULL)
12678     {
12679       struct elf_link_hash_entry *h;
12680       struct elf_link_hash_table *htab = elf_hash_table (info);
12681
12682       if (is_elf_hash_table (htab)
12683           && htab->hgot != NULL)
12684         h = htab->hgot;
12685       else
12686         {
12687           h = elf_link_hash_lookup (htab, ".TOC.", FALSE, FALSE, TRUE);
12688           if (is_elf_hash_table (htab))
12689             htab->hgot = h;
12690         }
12691       if (h != NULL
12692           && h->root.type == bfd_link_hash_defined
12693           && !h->root.linker_def
12694           && (!is_elf_hash_table (htab)
12695               || h->def_regular))
12696         {
12697           TOCstart = (h->root.u.def.value - TOC_BASE_OFF
12698                       + h->root.u.def.section->output_offset
12699                       + h->root.u.def.section->output_section->vma);
12700           _bfd_set_gp_value (obfd, TOCstart);
12701           return TOCstart;
12702         }
12703     }
12704
12705   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12706      order.  The TOC starts where the first of these sections starts.  */
12707   s = bfd_get_section_by_name (obfd, ".got");
12708   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12709     s = bfd_get_section_by_name (obfd, ".toc");
12710   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12711     s = bfd_get_section_by_name (obfd, ".tocbss");
12712   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12713     s = bfd_get_section_by_name (obfd, ".plt");
12714   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12715     {
12716       /* This may happen for
12717          o  references to TOC base (SYM@toc / TOC[tc0]) without a
12718          .toc directive
12719          o  bad linker script
12720          o --gc-sections and empty TOC sections
12721
12722          FIXME: Warn user?  */
12723
12724       /* Look for a likely section.  We probably won't even be
12725          using TOCstart.  */
12726       for (s = obfd->sections; s != NULL; s = s->next)
12727         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
12728                          | SEC_EXCLUDE))
12729             == (SEC_ALLOC | SEC_SMALL_DATA))
12730           break;
12731       if (s == NULL)
12732         for (s = obfd->sections; s != NULL; s = s->next)
12733           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
12734               == (SEC_ALLOC | SEC_SMALL_DATA))
12735             break;
12736       if (s == NULL)
12737         for (s = obfd->sections; s != NULL; s = s->next)
12738           if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
12739               == SEC_ALLOC)
12740             break;
12741       if (s == NULL)
12742         for (s = obfd->sections; s != NULL; s = s->next)
12743           if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
12744             break;
12745     }
12746
12747   TOCstart = 0;
12748   if (s != NULL)
12749     TOCstart = s->output_section->vma + s->output_offset;
12750
12751   /* Force alignment.  */
12752   adjust = TOCstart & (TOC_BASE_ALIGN - 1);
12753   TOCstart -= adjust;
12754   _bfd_set_gp_value (obfd, TOCstart);
12755
12756   if (info != NULL && s != NULL)
12757     {
12758       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12759
12760       if (htab != NULL)
12761         {
12762           if (htab->elf.hgot != NULL)
12763             {
12764               htab->elf.hgot->root.u.def.value = TOC_BASE_OFF - adjust;
12765               htab->elf.hgot->root.u.def.section = s;
12766             }
12767         }
12768       else
12769         {
12770           struct bfd_link_hash_entry *bh = NULL;
12771           _bfd_generic_link_add_one_symbol (info, obfd, ".TOC.", BSF_GLOBAL,
12772                                             s, TOC_BASE_OFF - adjust,
12773                                             NULL, FALSE, FALSE, &bh);
12774         }
12775     }
12776   return TOCstart;
12777 }
12778
12779 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
12780    write out any global entry stubs.  */
12781
12782 static bfd_boolean
12783 build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
12784 {
12785   struct bfd_link_info *info;
12786   struct ppc_link_hash_table *htab;
12787   struct plt_entry *pent;
12788   asection *s;
12789
12790   if (h->root.type == bfd_link_hash_indirect)
12791     return TRUE;
12792
12793   if (!h->pointer_equality_needed)
12794     return TRUE;
12795
12796   if (h->def_regular)
12797     return TRUE;
12798
12799   info = inf;
12800   htab = ppc_hash_table (info);
12801   if (htab == NULL)
12802     return FALSE;
12803
12804   s = htab->glink;
12805   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
12806     if (pent->plt.offset != (bfd_vma) -1
12807         && pent->addend == 0)
12808       {
12809         bfd_byte *p;
12810         asection *plt;
12811         bfd_vma off;
12812
12813         p = s->contents + h->root.u.def.value;
12814         plt = htab->elf.splt;
12815         if (!htab->elf.dynamic_sections_created
12816             || h->dynindx == -1)
12817           plt = htab->elf.iplt;
12818         off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
12819         off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
12820
12821         if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
12822           {
12823             info->callbacks->einfo
12824               (_("%P: linkage table error against `%T'\n"),
12825                h->root.root.string);
12826             bfd_set_error (bfd_error_bad_value);
12827             htab->stub_error = TRUE;
12828           }
12829
12830         htab->stub_count[ppc_stub_global_entry - 1] += 1;
12831         if (htab->params->emit_stub_syms)
12832           {
12833             size_t len = strlen (h->root.root.string);
12834             char *name = bfd_malloc (sizeof "12345678.global_entry." + len);
12835
12836             if (name == NULL)
12837               return FALSE;
12838
12839             sprintf (name, "%08x.global_entry.%s", s->id, h->root.root.string);
12840             h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
12841             if (h == NULL)
12842               return FALSE;
12843             if (h->root.type == bfd_link_hash_new)
12844               {
12845                 h->root.type = bfd_link_hash_defined;
12846                 h->root.u.def.section = s;
12847                 h->root.u.def.value = p - s->contents;
12848                 h->ref_regular = 1;
12849                 h->def_regular = 1;
12850                 h->ref_regular_nonweak = 1;
12851                 h->forced_local = 1;
12852                 h->non_elf = 0;
12853                 h->root.linker_def = 1;
12854               }
12855           }
12856
12857         if (PPC_HA (off) != 0)
12858           {
12859             bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
12860             p += 4;
12861           }
12862         bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
12863         p += 4;
12864         bfd_put_32 (s->owner, MTCTR_R12, p);
12865         p += 4;
12866         bfd_put_32 (s->owner, BCTR, p);
12867         break;
12868       }
12869   return TRUE;
12870 }
12871
12872 /* Build all the stubs associated with the current output file.
12873    The stubs are kept in a hash table attached to the main linker
12874    hash table.  This function is called via gldelf64ppc_finish.  */
12875
12876 bfd_boolean
12877 ppc64_elf_build_stubs (struct bfd_link_info *info,
12878                        char **stats)
12879 {
12880   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12881   struct map_stub *group;
12882   asection *stub_sec;
12883   bfd_byte *p;
12884   int stub_sec_count = 0;
12885
12886   if (htab == NULL)
12887     return FALSE;
12888
12889   /* Allocate memory to hold the linker stubs.  */
12890   for (stub_sec = htab->params->stub_bfd->sections;
12891        stub_sec != NULL;
12892        stub_sec = stub_sec->next)
12893     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12894         && stub_sec->size != 0)
12895       {
12896         stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
12897         if (stub_sec->contents == NULL)
12898           return FALSE;
12899         /* We want to check that built size is the same as calculated
12900            size.  rawsize is a convenient location to use.  */
12901         stub_sec->rawsize = stub_sec->size;
12902         stub_sec->size = 0;
12903       }
12904
12905   if (htab->glink != NULL && htab->glink->size != 0)
12906     {
12907       unsigned int indx;
12908       bfd_vma plt0;
12909
12910       /* Build the .glink plt call stub.  */
12911       if (htab->params->emit_stub_syms)
12912         {
12913           struct elf_link_hash_entry *h;
12914           h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
12915                                     TRUE, FALSE, FALSE);
12916           if (h == NULL)
12917             return FALSE;
12918           if (h->root.type == bfd_link_hash_new)
12919             {
12920               h->root.type = bfd_link_hash_defined;
12921               h->root.u.def.section = htab->glink;
12922               h->root.u.def.value = 8;
12923               h->ref_regular = 1;
12924               h->def_regular = 1;
12925               h->ref_regular_nonweak = 1;
12926               h->forced_local = 1;
12927               h->non_elf = 0;
12928               h->root.linker_def = 1;
12929             }
12930         }
12931       plt0 = (htab->elf.splt->output_section->vma
12932               + htab->elf.splt->output_offset
12933               - 16);
12934       if (info->emitrelocations)
12935         {
12936           Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
12937           if (r == NULL)
12938             return FALSE;
12939           r->r_offset = (htab->glink->output_offset
12940                          + htab->glink->output_section->vma);
12941           r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
12942           r->r_addend = plt0;
12943         }
12944       p = htab->glink->contents;
12945       plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
12946       bfd_put_64 (htab->glink->owner, plt0, p);
12947       p += 8;
12948       if (htab->opd_abi)
12949         {
12950           bfd_put_32 (htab->glink->owner, MFLR_R12, p);
12951           p += 4;
12952           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12953           p += 4;
12954           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12955           p += 4;
12956           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12957           p += 4;
12958           bfd_put_32 (htab->glink->owner, MTLR_R12, p);
12959           p += 4;
12960           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12961           p += 4;
12962           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12963           p += 4;
12964           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
12965           p += 4;
12966           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12967           p += 4;
12968           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
12969           p += 4;
12970         }
12971       else
12972         {
12973           bfd_put_32 (htab->glink->owner, MFLR_R0, p);
12974           p += 4;
12975           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12976           p += 4;
12977           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12978           p += 4;
12979           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12980           p += 4;
12981           bfd_put_32 (htab->glink->owner, MTLR_R0, p);
12982           p += 4;
12983           bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
12984           p += 4;
12985           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12986           p += 4;
12987           bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
12988           p += 4;
12989           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12990           p += 4;
12991           bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
12992           p += 4;
12993           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12994           p += 4;
12995           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
12996           p += 4;
12997         }
12998       bfd_put_32 (htab->glink->owner, BCTR, p);
12999       p += 4;
13000       while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
13001         {
13002           bfd_put_32 (htab->glink->owner, NOP, p);
13003           p += 4;
13004         }
13005
13006       /* Build the .glink lazy link call stubs.  */
13007       indx = 0;
13008       while (p < htab->glink->contents + htab->glink->rawsize)
13009         {
13010           if (htab->opd_abi)
13011             {
13012               if (indx < 0x8000)
13013                 {
13014                   bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
13015                   p += 4;
13016                 }
13017               else
13018                 {
13019                   bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
13020                   p += 4;
13021                   bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
13022                               p);
13023                   p += 4;
13024                 }
13025             }
13026           bfd_put_32 (htab->glink->owner,
13027                       B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
13028           indx++;
13029           p += 4;
13030         }
13031
13032       /* Build .glink global entry stubs.  */
13033       if (htab->glink->size > htab->glink->rawsize)
13034         elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
13035     }
13036
13037   if (htab->brlt != NULL && htab->brlt->size != 0)
13038     {
13039       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
13040                                          htab->brlt->size);
13041       if (htab->brlt->contents == NULL)
13042         return FALSE;
13043     }
13044   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
13045     {
13046       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
13047                                             htab->relbrlt->size);
13048       if (htab->relbrlt->contents == NULL)
13049         return FALSE;
13050     }
13051
13052   /* Build the stubs as directed by the stub hash table.  */
13053   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
13054
13055   for (group = htab->group; group != NULL; group = group->next)
13056     if (group->needs_save_res)
13057       {
13058         stub_sec = group->stub_sec;
13059         memcpy (stub_sec->contents + stub_sec->size, htab->sfpr->contents,
13060                 htab->sfpr->size);
13061         if (htab->params->emit_stub_syms)
13062           {
13063             unsigned int i;
13064
13065             for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
13066               if (!sfpr_define (info, &save_res_funcs[i], stub_sec))
13067                 return FALSE;
13068           }
13069         stub_sec->size += htab->sfpr->size;
13070       }
13071
13072   if (htab->relbrlt != NULL)
13073     htab->relbrlt->reloc_count = 0;
13074
13075   if (htab->params->plt_stub_align != 0)
13076     for (stub_sec = htab->params->stub_bfd->sections;
13077          stub_sec != NULL;
13078          stub_sec = stub_sec->next)
13079       if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
13080         stub_sec->size = ((stub_sec->size
13081                            + (1 << htab->params->plt_stub_align) - 1)
13082                           & -(1 << htab->params->plt_stub_align));
13083
13084   for (stub_sec = htab->params->stub_bfd->sections;
13085        stub_sec != NULL;
13086        stub_sec = stub_sec->next)
13087     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
13088       {
13089         stub_sec_count += 1;
13090         if (stub_sec->rawsize != stub_sec->size)
13091           break;
13092       }
13093
13094   /* Note that the glink_eh_frame check here is not only testing that
13095      the generated size matched the calculated size but also that
13096      bfd_elf_discard_info didn't make any changes to the section.  */
13097   if (stub_sec != NULL
13098       || (htab->glink_eh_frame != NULL
13099           && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
13100     {
13101       htab->stub_error = TRUE;
13102       info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
13103     }
13104
13105   if (htab->stub_error)
13106     return FALSE;
13107
13108   if (stats != NULL)
13109     {
13110       *stats = bfd_malloc (500);
13111       if (*stats == NULL)
13112         return FALSE;
13113
13114       sprintf (*stats, _("linker stubs in %u group%s\n"
13115                          "  branch       %lu\n"
13116                          "  toc adjust   %lu\n"
13117                          "  long branch  %lu\n"
13118                          "  long toc adj %lu\n"
13119                          "  plt call     %lu\n"
13120                          "  plt call toc %lu\n"
13121                          "  global entry %lu"),
13122                stub_sec_count,
13123                stub_sec_count == 1 ? "" : "s",
13124                htab->stub_count[ppc_stub_long_branch - 1],
13125                htab->stub_count[ppc_stub_long_branch_r2off - 1],
13126                htab->stub_count[ppc_stub_plt_branch - 1],
13127                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
13128                htab->stub_count[ppc_stub_plt_call - 1],
13129                htab->stub_count[ppc_stub_plt_call_r2save - 1],
13130                htab->stub_count[ppc_stub_global_entry - 1]);
13131     }
13132   return TRUE;
13133 }
13134
13135 /* This function undoes the changes made by add_symbol_adjust.  */
13136
13137 static bfd_boolean
13138 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
13139 {
13140   struct ppc_link_hash_entry *eh;
13141
13142   if (h->root.type == bfd_link_hash_indirect)
13143     return TRUE;
13144
13145   eh = (struct ppc_link_hash_entry *) h;
13146   if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
13147     return TRUE;
13148
13149   eh->elf.root.type = bfd_link_hash_undefined;
13150   return TRUE;
13151 }
13152
13153 void
13154 ppc64_elf_restore_symbols (struct bfd_link_info *info)
13155 {
13156   struct ppc_link_hash_table *htab = ppc_hash_table (info);
13157
13158   if (htab != NULL)
13159     elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
13160 }
13161
13162 /* What to do when ld finds relocations against symbols defined in
13163    discarded sections.  */
13164
13165 static unsigned int
13166 ppc64_elf_action_discarded (asection *sec)
13167 {
13168   if (strcmp (".opd", sec->name) == 0)
13169     return 0;
13170
13171   if (strcmp (".toc", sec->name) == 0)
13172     return 0;
13173
13174   if (strcmp (".toc1", sec->name) == 0)
13175     return 0;
13176
13177   return _bfd_elf_default_action_discarded (sec);
13178 }
13179
13180 /* The RELOCATE_SECTION function is called by the ELF backend linker
13181    to handle the relocations for a section.
13182
13183    The relocs are always passed as Rela structures; if the section
13184    actually uses Rel structures, the r_addend field will always be
13185    zero.
13186
13187    This function is responsible for adjust the section contents as
13188    necessary, and (if using Rela relocs and generating a
13189    relocatable output file) adjusting the reloc addend as
13190    necessary.
13191
13192    This function does not have to worry about setting the reloc
13193    address or the reloc symbol index.
13194
13195    LOCAL_SYMS is a pointer to the swapped in local symbols.
13196
13197    LOCAL_SECTIONS is an array giving the section in the input file
13198    corresponding to the st_shndx field of each local symbol.
13199
13200    The global hash table entry for the global symbols can be found
13201    via elf_sym_hashes (input_bfd).
13202
13203    When generating relocatable output, this function must handle
13204    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
13205    going to be the section symbol corresponding to the output
13206    section, which means that the addend must be adjusted
13207    accordingly.  */
13208
13209 static bfd_boolean
13210 ppc64_elf_relocate_section (bfd *output_bfd,
13211                             struct bfd_link_info *info,
13212                             bfd *input_bfd,
13213                             asection *input_section,
13214                             bfd_byte *contents,
13215                             Elf_Internal_Rela *relocs,
13216                             Elf_Internal_Sym *local_syms,
13217                             asection **local_sections)
13218 {
13219   struct ppc_link_hash_table *htab;
13220   Elf_Internal_Shdr *symtab_hdr;
13221   struct elf_link_hash_entry **sym_hashes;
13222   Elf_Internal_Rela *rel;
13223   Elf_Internal_Rela *wrel;
13224   Elf_Internal_Rela *relend;
13225   Elf_Internal_Rela outrel;
13226   bfd_byte *loc;
13227   struct got_entry **local_got_ents;
13228   bfd_vma TOCstart;
13229   bfd_boolean ret = TRUE;
13230   bfd_boolean is_opd;
13231   /* Assume 'at' branch hints.  */
13232   bfd_boolean is_isa_v2 = TRUE;
13233   bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
13234
13235   /* Initialize howto table if needed.  */
13236   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
13237     ppc_howto_init ();
13238
13239   htab = ppc_hash_table (info);
13240   if (htab == NULL)
13241     return FALSE;
13242
13243   /* Don't relocate stub sections.  */
13244   if (input_section->owner == htab->params->stub_bfd)
13245     return TRUE;
13246
13247   BFD_ASSERT (is_ppc64_elf (input_bfd));
13248
13249   local_got_ents = elf_local_got_ents (input_bfd);
13250   TOCstart = elf_gp (output_bfd);
13251   symtab_hdr = &elf_symtab_hdr (input_bfd);
13252   sym_hashes = elf_sym_hashes (input_bfd);
13253   is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
13254
13255   rel = wrel = relocs;
13256   relend = relocs + input_section->reloc_count;
13257   for (; rel < relend; wrel++, rel++)
13258     {
13259       enum elf_ppc64_reloc_type r_type;
13260       bfd_vma addend;
13261       bfd_reloc_status_type r;
13262       Elf_Internal_Sym *sym;
13263       asection *sec;
13264       struct elf_link_hash_entry *h_elf;
13265       struct ppc_link_hash_entry *h;
13266       struct ppc_link_hash_entry *fdh;
13267       const char *sym_name;
13268       unsigned long r_symndx, toc_symndx;
13269       bfd_vma toc_addend;
13270       unsigned char tls_mask, tls_gd, tls_type;
13271       unsigned char sym_type;
13272       bfd_vma relocation;
13273       bfd_boolean unresolved_reloc;
13274       bfd_boolean warned;
13275       enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
13276       unsigned int insn;
13277       unsigned int mask;
13278       struct ppc_stub_hash_entry *stub_entry;
13279       bfd_vma max_br_offset;
13280       bfd_vma from;
13281       Elf_Internal_Rela orig_rel;
13282       reloc_howto_type *howto;
13283       struct reloc_howto_struct alt_howto;
13284
13285     again:
13286       orig_rel = *rel;
13287
13288       r_type = ELF64_R_TYPE (rel->r_info);
13289       r_symndx = ELF64_R_SYM (rel->r_info);
13290
13291       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
13292          symbol of the previous ADDR64 reloc.  The symbol gives us the
13293          proper TOC base to use.  */
13294       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
13295           && wrel != relocs
13296           && ELF64_R_TYPE (wrel[-1].r_info) == R_PPC64_ADDR64
13297           && is_opd)
13298         r_symndx = ELF64_R_SYM (wrel[-1].r_info);
13299
13300       sym = NULL;
13301       sec = NULL;
13302       h_elf = NULL;
13303       sym_name = NULL;
13304       unresolved_reloc = FALSE;
13305       warned = FALSE;
13306
13307       if (r_symndx < symtab_hdr->sh_info)
13308         {
13309           /* It's a local symbol.  */
13310           struct _opd_sec_data *opd;
13311
13312           sym = local_syms + r_symndx;
13313           sec = local_sections[r_symndx];
13314           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
13315           sym_type = ELF64_ST_TYPE (sym->st_info);
13316           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
13317           opd = get_opd_info (sec);
13318           if (opd != NULL && opd->adjust != NULL)
13319             {
13320               long adjust = opd->adjust[OPD_NDX (sym->st_value
13321                                                  + rel->r_addend)];
13322               if (adjust == -1)
13323                 relocation = 0;
13324               else
13325                 {
13326                   /* If this is a relocation against the opd section sym
13327                      and we have edited .opd, adjust the reloc addend so
13328                      that ld -r and ld --emit-relocs output is correct.
13329                      If it is a reloc against some other .opd symbol,
13330                      then the symbol value will be adjusted later.  */
13331                   if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
13332                     rel->r_addend += adjust;
13333                   else
13334                     relocation += adjust;
13335                 }
13336             }
13337         }
13338       else
13339         {
13340           bfd_boolean ignored;
13341
13342           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
13343                                    r_symndx, symtab_hdr, sym_hashes,
13344                                    h_elf, sec, relocation,
13345                                    unresolved_reloc, warned, ignored);
13346           sym_name = h_elf->root.root.string;
13347           sym_type = h_elf->type;
13348           if (sec != NULL
13349               && sec->owner == output_bfd
13350               && strcmp (sec->name, ".opd") == 0)
13351             {
13352               /* This is a symbol defined in a linker script.  All
13353                  such are defined in output sections, even those
13354                  defined by simple assignment from a symbol defined in
13355                  an input section.  Transfer the symbol to an
13356                  appropriate input .opd section, so that a branch to
13357                  this symbol will be mapped to the location specified
13358                  by the opd entry.  */
13359               struct bfd_link_order *lo;
13360               for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
13361                 if (lo->type == bfd_indirect_link_order)
13362                   {
13363                     asection *isec = lo->u.indirect.section;
13364                     if (h_elf->root.u.def.value >= isec->output_offset
13365                         && h_elf->root.u.def.value < (isec->output_offset
13366                                                       + isec->size))
13367                       {
13368                         h_elf->root.u.def.value -= isec->output_offset;
13369                         h_elf->root.u.def.section = isec;
13370                         sec = isec;
13371                         break;
13372                       }
13373                   }
13374             }
13375         }
13376       h = (struct ppc_link_hash_entry *) h_elf;
13377
13378       if (sec != NULL && discarded_section (sec))
13379         {
13380           _bfd_clear_contents (ppc64_elf_howto_table[r_type],
13381                                input_bfd, input_section,
13382                                contents + rel->r_offset);
13383           wrel->r_offset = rel->r_offset;
13384           wrel->r_info = 0;
13385           wrel->r_addend = 0;
13386
13387           /* For ld -r, remove relocations in debug sections against
13388              sections defined in discarded sections.  Not done for
13389              non-debug to preserve relocs in .eh_frame which the
13390              eh_frame editing code expects to be present.  */
13391           if (bfd_link_relocatable (info)
13392               && (input_section->flags & SEC_DEBUGGING))
13393             wrel--;
13394
13395           continue;
13396         }
13397
13398       if (bfd_link_relocatable (info))
13399         goto copy_reloc;
13400
13401       if (h != NULL && &h->elf == htab->elf.hgot)
13402         {
13403           relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
13404           sec = bfd_abs_section_ptr;
13405           unresolved_reloc = FALSE;
13406         }
13407
13408       /* TLS optimizations.  Replace instruction sequences and relocs
13409          based on information we collected in tls_optimize.  We edit
13410          RELOCS so that --emit-relocs will output something sensible
13411          for the final instruction stream.  */
13412       tls_mask = 0;
13413       tls_gd = 0;
13414       toc_symndx = 0;
13415       if (h != NULL)
13416         tls_mask = h->tls_mask;
13417       else if (local_got_ents != NULL)
13418         {
13419           struct plt_entry **local_plt = (struct plt_entry **)
13420             (local_got_ents + symtab_hdr->sh_info);
13421           unsigned char *lgot_masks = (unsigned char *)
13422             (local_plt + symtab_hdr->sh_info);
13423           tls_mask = lgot_masks[r_symndx];
13424         }
13425       if (tls_mask == 0
13426           && (r_type == R_PPC64_TLS
13427               || r_type == R_PPC64_TLSGD
13428               || r_type == R_PPC64_TLSLD))
13429         {
13430           /* Check for toc tls entries.  */
13431           unsigned char *toc_tls;
13432
13433           if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13434                              &local_syms, rel, input_bfd))
13435             return FALSE;
13436
13437           if (toc_tls)
13438             tls_mask = *toc_tls;
13439         }
13440
13441       /* Check that tls relocs are used with tls syms, and non-tls
13442          relocs are used with non-tls syms.  */
13443       if (r_symndx != STN_UNDEF
13444           && r_type != R_PPC64_NONE
13445           && (h == NULL
13446               || h->elf.root.type == bfd_link_hash_defined
13447               || h->elf.root.type == bfd_link_hash_defweak)
13448           && (IS_PPC64_TLS_RELOC (r_type)
13449               != (sym_type == STT_TLS
13450                   || (sym_type == STT_SECTION
13451                       && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13452         {
13453           if (tls_mask != 0
13454               && (r_type == R_PPC64_TLS
13455                   || r_type == R_PPC64_TLSGD
13456                   || r_type == R_PPC64_TLSLD))
13457             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
13458             ;
13459           else
13460             info->callbacks->einfo
13461               (!IS_PPC64_TLS_RELOC (r_type)
13462                ? _("%P: %H: %s used with TLS symbol `%T'\n")
13463                : _("%P: %H: %s used with non-TLS symbol `%T'\n"),
13464                input_bfd, input_section, rel->r_offset,
13465                ppc64_elf_howto_table[r_type]->name,
13466                sym_name);
13467         }
13468
13469       /* Ensure reloc mapping code below stays sane.  */
13470       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13471           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13472           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
13473           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13474           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13475           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13476           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
13477           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13478           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13479           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13480         abort ();
13481
13482       switch (r_type)
13483         {
13484         default:
13485           break;
13486
13487         case R_PPC64_LO_DS_OPT:
13488           insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13489           if ((insn & (0x3f << 26)) != 58u << 26)
13490             abort ();
13491           insn += (14u << 26) - (58u << 26);
13492           bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13493           r_type = R_PPC64_TOC16_LO;
13494           rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13495           break;
13496
13497         case R_PPC64_TOC16:
13498         case R_PPC64_TOC16_LO:
13499         case R_PPC64_TOC16_DS:
13500         case R_PPC64_TOC16_LO_DS:
13501           {
13502             /* Check for toc tls entries.  */
13503             unsigned char *toc_tls;
13504             int retval;
13505
13506             retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13507                                    &local_syms, rel, input_bfd);
13508             if (retval == 0)
13509               return FALSE;
13510
13511             if (toc_tls)
13512               {
13513                 tls_mask = *toc_tls;
13514                 if (r_type == R_PPC64_TOC16_DS
13515                     || r_type == R_PPC64_TOC16_LO_DS)
13516                   {
13517                     if (tls_mask != 0
13518                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13519                       goto toctprel;
13520                   }
13521                 else
13522                   {
13523                     /* If we found a GD reloc pair, then we might be
13524                        doing a GD->IE transition.  */
13525                     if (retval == 2)
13526                       {
13527                         tls_gd = TLS_TPRELGD;
13528                         if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13529                           goto tls_ldgd_opt;
13530                       }
13531                     else if (retval == 3)
13532                       {
13533                         if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13534                           goto tls_ldgd_opt;
13535                       }
13536                   }
13537               }
13538           }
13539           break;
13540
13541         case R_PPC64_GOT_TPREL16_HI:
13542         case R_PPC64_GOT_TPREL16_HA:
13543           if (tls_mask != 0
13544               && (tls_mask & TLS_TPREL) == 0)
13545             {
13546               rel->r_offset -= d_offset;
13547               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13548               r_type = R_PPC64_NONE;
13549               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13550             }
13551           break;
13552
13553         case R_PPC64_GOT_TPREL16_DS:
13554         case R_PPC64_GOT_TPREL16_LO_DS:
13555           if (tls_mask != 0
13556               && (tls_mask & TLS_TPREL) == 0)
13557             {
13558             toctprel:
13559               insn = bfd_get_32 (output_bfd,
13560                                  contents + rel->r_offset - d_offset);
13561               insn &= 31 << 21;
13562               insn |= 0x3c0d0000;       /* addis 0,13,0 */
13563               bfd_put_32 (output_bfd, insn,
13564                           contents + rel->r_offset - d_offset);
13565               r_type = R_PPC64_TPREL16_HA;
13566               if (toc_symndx != 0)
13567                 {
13568                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13569                   rel->r_addend = toc_addend;
13570                   /* We changed the symbol.  Start over in order to
13571                      get h, sym, sec etc. right.  */
13572                   goto again;
13573                 }
13574               else
13575                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13576             }
13577           break;
13578
13579         case R_PPC64_TLS:
13580           if (tls_mask != 0
13581               && (tls_mask & TLS_TPREL) == 0)
13582             {
13583               insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
13584               insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13585               if (insn == 0)
13586                 abort ();
13587               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13588               /* Was PPC64_TLS which sits on insn boundary, now
13589                  PPC64_TPREL16_LO which is at low-order half-word.  */
13590               rel->r_offset += d_offset;
13591               r_type = R_PPC64_TPREL16_LO;
13592               if (toc_symndx != 0)
13593                 {
13594                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13595                   rel->r_addend = toc_addend;
13596                   /* We changed the symbol.  Start over in order to
13597                      get h, sym, sec etc. right.  */
13598                   goto again;
13599                 }
13600               else
13601                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13602             }
13603           break;
13604
13605         case R_PPC64_GOT_TLSGD16_HI:
13606         case R_PPC64_GOT_TLSGD16_HA:
13607           tls_gd = TLS_TPRELGD;
13608           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13609             goto tls_gdld_hi;
13610           break;
13611
13612         case R_PPC64_GOT_TLSLD16_HI:
13613         case R_PPC64_GOT_TLSLD16_HA:
13614           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13615             {
13616             tls_gdld_hi:
13617               if ((tls_mask & tls_gd) != 0)
13618                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13619                           + R_PPC64_GOT_TPREL16_DS);
13620               else
13621                 {
13622                   rel->r_offset -= d_offset;
13623                   bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13624                   r_type = R_PPC64_NONE;
13625                 }
13626               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13627             }
13628           break;
13629
13630         case R_PPC64_GOT_TLSGD16:
13631         case R_PPC64_GOT_TLSGD16_LO:
13632           tls_gd = TLS_TPRELGD;
13633           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13634             goto tls_ldgd_opt;
13635           break;
13636
13637         case R_PPC64_GOT_TLSLD16:
13638         case R_PPC64_GOT_TLSLD16_LO:
13639           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13640             {
13641               unsigned int insn1, insn2, insn3;
13642               bfd_vma offset;
13643
13644             tls_ldgd_opt:
13645               offset = (bfd_vma) -1;
13646               /* If not using the newer R_PPC64_TLSGD/LD to mark
13647                  __tls_get_addr calls, we must trust that the call
13648                  stays with its arg setup insns, ie. that the next
13649                  reloc is the __tls_get_addr call associated with
13650                  the current reloc.  Edit both insns.  */
13651               if (input_section->has_tls_get_addr_call
13652                   && rel + 1 < relend
13653                   && branch_reloc_hash_match (input_bfd, rel + 1,
13654                                               htab->tls_get_addr,
13655                                               htab->tls_get_addr_fd))
13656                 offset = rel[1].r_offset;
13657               /* We read the low GOT_TLS (or TOC16) insn because we
13658                  need to keep the destination reg.  It may be
13659                  something other than the usual r3, and moved to r3
13660                  before the call by intervening code.  */
13661               insn1 = bfd_get_32 (output_bfd,
13662                                   contents + rel->r_offset - d_offset);
13663               if ((tls_mask & tls_gd) != 0)
13664                 {
13665                   /* IE */
13666                   insn1 &= (0x1f << 21) | (0x1f << 16);
13667                   insn1 |= 58 << 26;    /* ld */
13668                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13669                   if (offset != (bfd_vma) -1)
13670                     rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13671                   if ((tls_mask & TLS_EXPLICIT) == 0)
13672                     r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13673                               + R_PPC64_GOT_TPREL16_DS);
13674                   else
13675                     r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13676                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13677                 }
13678               else
13679                 {
13680                   /* LE */
13681                   insn1 &= 0x1f << 21;
13682                   insn1 |= 0x3c0d0000;  /* addis r,13,0 */
13683                   insn2 = 0x38630000;   /* addi 3,3,0 */
13684                   if (tls_gd == 0)
13685                     {
13686                       /* Was an LD reloc.  */
13687                       if (toc_symndx)
13688                         sec = local_sections[toc_symndx];
13689                       for (r_symndx = 0;
13690                            r_symndx < symtab_hdr->sh_info;
13691                            r_symndx++)
13692                         if (local_sections[r_symndx] == sec)
13693                           break;
13694                       if (r_symndx >= symtab_hdr->sh_info)
13695                         r_symndx = STN_UNDEF;
13696                       rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13697                       if (r_symndx != STN_UNDEF)
13698                         rel->r_addend -= (local_syms[r_symndx].st_value
13699                                           + sec->output_offset
13700                                           + sec->output_section->vma);
13701                     }
13702                   else if (toc_symndx != 0)
13703                     {
13704                       r_symndx = toc_symndx;
13705                       rel->r_addend = toc_addend;
13706                     }
13707                   r_type = R_PPC64_TPREL16_HA;
13708                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13709                   if (offset != (bfd_vma) -1)
13710                     {
13711                       rel[1].r_info = ELF64_R_INFO (r_symndx,
13712                                                     R_PPC64_TPREL16_LO);
13713                       rel[1].r_offset = offset + d_offset;
13714                       rel[1].r_addend = rel->r_addend;
13715                     }
13716                 }
13717               bfd_put_32 (output_bfd, insn1,
13718                           contents + rel->r_offset - d_offset);
13719               if (offset != (bfd_vma) -1)
13720                 {
13721                   insn3 = bfd_get_32 (output_bfd,
13722                                       contents + offset + 4);
13723                   if (insn3 == NOP
13724                       || insn3 == CROR_151515 || insn3 == CROR_313131)
13725                     {
13726                       rel[1].r_offset += 4;
13727                       bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13728                       insn2 = NOP;
13729                     }
13730                   bfd_put_32 (output_bfd, insn2, contents + offset);
13731                 }
13732               if ((tls_mask & tls_gd) == 0
13733                   && (tls_gd == 0 || toc_symndx != 0))
13734                 {
13735                   /* We changed the symbol.  Start over in order
13736                      to get h, sym, sec etc. right.  */
13737                   goto again;
13738                 }
13739             }
13740           break;
13741
13742         case R_PPC64_TLSGD:
13743           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13744             {
13745               unsigned int insn2, insn3;
13746               bfd_vma offset = rel->r_offset;
13747
13748               if ((tls_mask & TLS_TPRELGD) != 0)
13749                 {
13750                   /* IE */
13751                   r_type = R_PPC64_NONE;
13752                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13753                 }
13754               else
13755                 {
13756                   /* LE */
13757                   if (toc_symndx != 0)
13758                     {
13759                       r_symndx = toc_symndx;
13760                       rel->r_addend = toc_addend;
13761                     }
13762                   r_type = R_PPC64_TPREL16_LO;
13763                   rel->r_offset = offset + d_offset;
13764                   insn2 = 0x38630000;   /* addi 3,3,0 */
13765                 }
13766               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13767               /* Zap the reloc on the _tls_get_addr call too.  */
13768               BFD_ASSERT (offset == rel[1].r_offset);
13769               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13770               insn3 = bfd_get_32 (output_bfd,
13771                                   contents + offset + 4);
13772               if (insn3 == NOP
13773                   || insn3 == CROR_151515 || insn3 == CROR_313131)
13774                 {
13775                   rel->r_offset += 4;
13776                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13777                   insn2 = NOP;
13778                 }
13779               bfd_put_32 (output_bfd, insn2, contents + offset);
13780               if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
13781                 goto again;
13782             }
13783           break;
13784
13785         case R_PPC64_TLSLD:
13786           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13787             {
13788               unsigned int insn2, insn3;
13789               bfd_vma offset = rel->r_offset;
13790
13791               if (toc_symndx)
13792                 sec = local_sections[toc_symndx];
13793               for (r_symndx = 0;
13794                    r_symndx < symtab_hdr->sh_info;
13795                    r_symndx++)
13796                 if (local_sections[r_symndx] == sec)
13797                   break;
13798               if (r_symndx >= symtab_hdr->sh_info)
13799                 r_symndx = STN_UNDEF;
13800               rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13801               if (r_symndx != STN_UNDEF)
13802                 rel->r_addend -= (local_syms[r_symndx].st_value
13803                                   + sec->output_offset
13804                                   + sec->output_section->vma);
13805
13806               r_type = R_PPC64_TPREL16_LO;
13807               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13808               rel->r_offset = offset + d_offset;
13809               /* Zap the reloc on the _tls_get_addr call too.  */
13810               BFD_ASSERT (offset == rel[1].r_offset);
13811               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13812               insn2 = 0x38630000;       /* addi 3,3,0 */
13813               insn3 = bfd_get_32 (output_bfd,
13814                                   contents + offset + 4);
13815               if (insn3 == NOP
13816                   || insn3 == CROR_151515 || insn3 == CROR_313131)
13817                 {
13818                   rel->r_offset += 4;
13819                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13820                   insn2 = NOP;
13821                 }
13822               bfd_put_32 (output_bfd, insn2, contents + offset);
13823               goto again;
13824             }
13825           break;
13826
13827         case R_PPC64_DTPMOD64:
13828           if (rel + 1 < relend
13829               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
13830               && rel[1].r_offset == rel->r_offset + 8)
13831             {
13832               if ((tls_mask & TLS_GD) == 0)
13833                 {
13834                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
13835                   if ((tls_mask & TLS_TPRELGD) != 0)
13836                     r_type = R_PPC64_TPREL64;
13837                   else
13838                     {
13839                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13840                       r_type = R_PPC64_NONE;
13841                     }
13842                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13843                 }
13844             }
13845           else
13846             {
13847               if ((tls_mask & TLS_LD) == 0)
13848                 {
13849                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13850                   r_type = R_PPC64_NONE;
13851                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13852                 }
13853             }
13854           break;
13855
13856         case R_PPC64_TPREL64:
13857           if ((tls_mask & TLS_TPREL) == 0)
13858             {
13859               r_type = R_PPC64_NONE;
13860               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13861             }
13862           break;
13863
13864         case R_PPC64_ENTRY:
13865           relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
13866           if (!bfd_link_pic (info)
13867               && !info->traditional_format
13868               && relocation + 0x80008000 <= 0xffffffff)
13869             {
13870               unsigned int insn1, insn2;
13871
13872               insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
13873               insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
13874               if ((insn1 & ~0xfffc) == LD_R2_0R12
13875                   && insn2 == ADD_R2_R2_R12)
13876                 {
13877                   bfd_put_32 (output_bfd,
13878                               LIS_R2 + PPC_HA (relocation),
13879                               contents + rel->r_offset);
13880                   bfd_put_32 (output_bfd,
13881                               ADDI_R2_R2 + PPC_LO (relocation),
13882                               contents + rel->r_offset + 4);
13883                 }
13884             }
13885           else
13886             {
13887               relocation -= (rel->r_offset
13888                              + input_section->output_offset
13889                              + input_section->output_section->vma);
13890               if (relocation + 0x80008000 <= 0xffffffff)
13891                 {
13892                   unsigned int insn1, insn2;
13893
13894                   insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
13895                   insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
13896                   if ((insn1 & ~0xfffc) == LD_R2_0R12
13897                       && insn2 == ADD_R2_R2_R12)
13898                     {
13899                       bfd_put_32 (output_bfd,
13900                                   ADDIS_R2_R12 + PPC_HA (relocation),
13901                                   contents + rel->r_offset);
13902                       bfd_put_32 (output_bfd,
13903                                   ADDI_R2_R2 + PPC_LO (relocation),
13904                                   contents + rel->r_offset + 4);
13905                     }
13906                 }
13907             }
13908           break;
13909
13910         case R_PPC64_REL16_HA:
13911           /* If we are generating a non-PIC executable, edit
13912              .  0:      addis 2,12,.TOC.-0b@ha
13913              .          addi 2,2,.TOC.-0b@l
13914              used by ELFv2 global entry points to set up r2, to
13915              .          lis 2,.TOC.@ha
13916              .          addi 2,2,.TOC.@l
13917              if .TOC. is in range.  */
13918           if (!bfd_link_pic (info)
13919               && !info->traditional_format
13920               && !htab->opd_abi
13921               && rel->r_addend == d_offset
13922               && h != NULL && &h->elf == htab->elf.hgot
13923               && rel + 1 < relend
13924               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
13925               && rel[1].r_offset == rel->r_offset + 4
13926               && rel[1].r_addend == rel->r_addend + 4
13927               && relocation + 0x80008000 <= 0xffffffff)
13928             {
13929               unsigned int insn1, insn2;
13930               bfd_vma offset = rel->r_offset - d_offset;
13931               insn1 = bfd_get_32 (output_bfd, contents + offset);
13932               insn2 = bfd_get_32 (output_bfd, contents + offset + 4);
13933               if ((insn1 & 0xffff0000) == ADDIS_R2_R12
13934                   && (insn2 & 0xffff0000) == ADDI_R2_R2)
13935                 {
13936                   r_type = R_PPC64_ADDR16_HA;
13937                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13938                   rel->r_addend -= d_offset;
13939                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
13940                   rel[1].r_addend -= d_offset + 4;
13941                   bfd_put_32 (output_bfd, LIS_R2, contents + offset);
13942                 }
13943             }
13944           break;
13945         }
13946
13947       /* Handle other relocations that tweak non-addend part of insn.  */
13948       insn = 0;
13949       max_br_offset = 1 << 25;
13950       addend = rel->r_addend;
13951       reloc_dest = DEST_NORMAL;
13952       switch (r_type)
13953         {
13954         default:
13955           break;
13956
13957         case R_PPC64_TOCSAVE:
13958           if (relocation + addend == (rel->r_offset
13959                                       + input_section->output_offset
13960                                       + input_section->output_section->vma)
13961               && tocsave_find (htab, NO_INSERT,
13962                                &local_syms, rel, input_bfd))
13963             {
13964               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
13965               if (insn == NOP
13966                   || insn == CROR_151515 || insn == CROR_313131)
13967                 bfd_put_32 (input_bfd,
13968                             STD_R2_0R1 + STK_TOC (htab),
13969                             contents + rel->r_offset);
13970             }
13971           break;
13972
13973           /* Branch taken prediction relocations.  */
13974         case R_PPC64_ADDR14_BRTAKEN:
13975         case R_PPC64_REL14_BRTAKEN:
13976           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
13977           /* Fall thru.  */
13978
13979           /* Branch not taken prediction relocations.  */
13980         case R_PPC64_ADDR14_BRNTAKEN:
13981         case R_PPC64_REL14_BRNTAKEN:
13982           insn |= bfd_get_32 (output_bfd,
13983                               contents + rel->r_offset) & ~(0x01 << 21);
13984           /* Fall thru.  */
13985
13986         case R_PPC64_REL14:
13987           max_br_offset = 1 << 15;
13988           /* Fall thru.  */
13989
13990         case R_PPC64_REL24:
13991           /* Calls to functions with a different TOC, such as calls to
13992              shared objects, need to alter the TOC pointer.  This is
13993              done using a linkage stub.  A REL24 branching to these
13994              linkage stubs needs to be followed by a nop, as the nop
13995              will be replaced with an instruction to restore the TOC
13996              base pointer.  */
13997           fdh = h;
13998           if (h != NULL
13999               && h->oh != NULL
14000               && h->oh->is_func_descriptor)
14001             fdh = ppc_follow_link (h->oh);
14002           stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
14003                                            htab);
14004           if (stub_entry != NULL
14005               && (stub_entry->stub_type == ppc_stub_plt_call
14006                   || stub_entry->stub_type == ppc_stub_plt_call_r2save
14007                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
14008                   || stub_entry->stub_type == ppc_stub_long_branch_r2off))
14009             {
14010               bfd_boolean can_plt_call = FALSE;
14011
14012               /* All of these stubs will modify r2, so there must be a
14013                  branch and link followed by a nop.  The nop is
14014                  replaced by an insn to restore r2.  */
14015               if (rel->r_offset + 8 <= input_section->size)
14016                 {
14017                   unsigned long br;
14018
14019                   br = bfd_get_32 (input_bfd,
14020                                    contents + rel->r_offset);
14021                   if ((br & 1) != 0)
14022                     {
14023                       unsigned long nop;
14024
14025                       nop = bfd_get_32 (input_bfd,
14026                                         contents + rel->r_offset + 4);
14027                       if (nop == NOP
14028                           || nop == CROR_151515 || nop == CROR_313131)
14029                         {
14030                           if (h != NULL
14031                               && (h == htab->tls_get_addr_fd
14032                                   || h == htab->tls_get_addr)
14033                               && htab->params->tls_get_addr_opt)
14034                             {
14035                               /* Special stub used, leave nop alone.  */
14036                             }
14037                           else
14038                             bfd_put_32 (input_bfd,
14039                                         LD_R2_0R1 + STK_TOC (htab),
14040                                         contents + rel->r_offset + 4);
14041                           can_plt_call = TRUE;
14042                         }
14043                     }
14044                 }
14045
14046               if (!can_plt_call && h != NULL)
14047                 {
14048                   const char *name = h->elf.root.root.string;
14049
14050                   if (*name == '.')
14051                     ++name;
14052
14053                   if (strncmp (name, "__libc_start_main", 17) == 0
14054                       && (name[17] == 0 || name[17] == '@'))
14055                     {
14056                       /* Allow crt1 branch to go via a toc adjusting
14057                          stub.  Other calls that never return could do
14058                          the same, if we could detect such.  */
14059                       can_plt_call = TRUE;
14060                     }
14061                 }
14062
14063               if (!can_plt_call)
14064                 {
14065                   /* g++ as of 20130507 emits self-calls without a
14066                      following nop.  This is arguably wrong since we
14067                      have conflicting information.  On the one hand a
14068                      global symbol and on the other a local call
14069                      sequence, but don't error for this special case.
14070                      It isn't possible to cheaply verify we have
14071                      exactly such a call.  Allow all calls to the same
14072                      section.  */
14073                   asection *code_sec = sec;
14074
14075                   if (get_opd_info (sec) != NULL)
14076                     {
14077                       bfd_vma off = (relocation + addend
14078                                      - sec->output_section->vma
14079                                      - sec->output_offset);
14080
14081                       opd_entry_value (sec, off, &code_sec, NULL, FALSE);
14082                     }
14083                   if (code_sec == input_section)
14084                     can_plt_call = TRUE;
14085                 }
14086
14087               if (!can_plt_call)
14088                 {
14089                   if (stub_entry->stub_type == ppc_stub_plt_call
14090                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14091                     info->callbacks->einfo
14092                       (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
14093                          "recompile with -fPIC\n"),
14094                        input_bfd, input_section, rel->r_offset, sym_name);
14095                   else
14096                     info->callbacks->einfo
14097                       (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
14098                          "(-mcmodel=small toc adjust stub)\n"),
14099                        input_bfd, input_section, rel->r_offset, sym_name);
14100
14101                   bfd_set_error (bfd_error_bad_value);
14102                   ret = FALSE;
14103                 }
14104
14105               if (can_plt_call
14106                   && (stub_entry->stub_type == ppc_stub_plt_call
14107                       || stub_entry->stub_type == ppc_stub_plt_call_r2save))
14108                 unresolved_reloc = FALSE;
14109             }
14110
14111           if ((stub_entry == NULL
14112                || stub_entry->stub_type == ppc_stub_long_branch
14113                || stub_entry->stub_type == ppc_stub_plt_branch)
14114               && get_opd_info (sec) != NULL)
14115             {
14116               /* The branch destination is the value of the opd entry. */
14117               bfd_vma off = (relocation + addend
14118                              - sec->output_section->vma
14119                              - sec->output_offset);
14120               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
14121               if (dest != (bfd_vma) -1)
14122                 {
14123                   relocation = dest;
14124                   addend = 0;
14125                   reloc_dest = DEST_OPD;
14126                 }
14127             }
14128
14129           /* If the branch is out of reach we ought to have a long
14130              branch stub.  */
14131           from = (rel->r_offset
14132                   + input_section->output_offset
14133                   + input_section->output_section->vma);
14134
14135           relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
14136                                                   ? fdh->elf.other
14137                                                   : sym->st_other);
14138
14139           if (stub_entry != NULL
14140               && (stub_entry->stub_type == ppc_stub_long_branch
14141                   || stub_entry->stub_type == ppc_stub_plt_branch)
14142               && (r_type == R_PPC64_ADDR14_BRTAKEN
14143                   || r_type == R_PPC64_ADDR14_BRNTAKEN
14144                   || (relocation + addend - from + max_br_offset
14145                       < 2 * max_br_offset)))
14146             /* Don't use the stub if this branch is in range.  */
14147             stub_entry = NULL;
14148
14149           if (stub_entry != NULL)
14150             {
14151               /* Munge up the value and addend so that we call the stub
14152                  rather than the procedure directly.  */
14153               asection *stub_sec = stub_entry->group->stub_sec;
14154
14155               if (stub_entry->stub_type == ppc_stub_save_res)
14156                 relocation += (stub_sec->output_offset
14157                                + stub_sec->output_section->vma
14158                                + stub_sec->size - htab->sfpr->size
14159                                - htab->sfpr->output_offset
14160                                - htab->sfpr->output_section->vma);
14161               else
14162                 relocation = (stub_entry->stub_offset
14163                               + stub_sec->output_offset
14164                               + stub_sec->output_section->vma);
14165               addend = 0;
14166               reloc_dest = DEST_STUB;
14167
14168               if ((stub_entry->stub_type == ppc_stub_plt_call
14169                    || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14170                   && (ALWAYS_EMIT_R2SAVE
14171                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14172                   && rel + 1 < relend
14173                   && rel[1].r_offset == rel->r_offset + 4
14174                   && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
14175                 relocation += 4;
14176             }
14177
14178           if (insn != 0)
14179             {
14180               if (is_isa_v2)
14181                 {
14182                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
14183                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
14184                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
14185                   if ((insn & (0x14 << 21)) == (0x04 << 21))
14186                     insn |= 0x02 << 21;
14187                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
14188                     insn |= 0x08 << 21;
14189                   else
14190                     break;
14191                 }
14192               else
14193                 {
14194                   /* Invert 'y' bit if not the default.  */
14195                   if ((bfd_signed_vma) (relocation + addend - from) < 0)
14196                     insn ^= 0x01 << 21;
14197                 }
14198
14199               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
14200             }
14201
14202           /* NOP out calls to undefined weak functions.
14203              We can thus call a weak function without first
14204              checking whether the function is defined.  */
14205           else if (h != NULL
14206                    && h->elf.root.type == bfd_link_hash_undefweak
14207                    && h->elf.dynindx == -1
14208                    && r_type == R_PPC64_REL24
14209                    && relocation == 0
14210                    && addend == 0)
14211             {
14212               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
14213               goto copy_reloc;
14214             }
14215           break;
14216         }
14217
14218       /* Set `addend'.  */
14219       tls_type = 0;
14220       switch (r_type)
14221         {
14222         default:
14223           info->callbacks->einfo
14224             (_("%P: %B: unknown relocation type %d for `%T'\n"),
14225              input_bfd, (int) r_type, sym_name);
14226
14227           bfd_set_error (bfd_error_bad_value);
14228           ret = FALSE;
14229           goto copy_reloc;
14230
14231         case R_PPC64_NONE:
14232         case R_PPC64_TLS:
14233         case R_PPC64_TLSGD:
14234         case R_PPC64_TLSLD:
14235         case R_PPC64_TOCSAVE:
14236         case R_PPC64_GNU_VTINHERIT:
14237         case R_PPC64_GNU_VTENTRY:
14238         case R_PPC64_ENTRY:
14239           goto copy_reloc;
14240
14241           /* GOT16 relocations.  Like an ADDR16 using the symbol's
14242              address in the GOT as relocation value instead of the
14243              symbol's value itself.  Also, create a GOT entry for the
14244              symbol and put the symbol value there.  */
14245         case R_PPC64_GOT_TLSGD16:
14246         case R_PPC64_GOT_TLSGD16_LO:
14247         case R_PPC64_GOT_TLSGD16_HI:
14248         case R_PPC64_GOT_TLSGD16_HA:
14249           tls_type = TLS_TLS | TLS_GD;
14250           goto dogot;
14251
14252         case R_PPC64_GOT_TLSLD16:
14253         case R_PPC64_GOT_TLSLD16_LO:
14254         case R_PPC64_GOT_TLSLD16_HI:
14255         case R_PPC64_GOT_TLSLD16_HA:
14256           tls_type = TLS_TLS | TLS_LD;
14257           goto dogot;
14258
14259         case R_PPC64_GOT_TPREL16_DS:
14260         case R_PPC64_GOT_TPREL16_LO_DS:
14261         case R_PPC64_GOT_TPREL16_HI:
14262         case R_PPC64_GOT_TPREL16_HA:
14263           tls_type = TLS_TLS | TLS_TPREL;
14264           goto dogot;
14265
14266         case R_PPC64_GOT_DTPREL16_DS:
14267         case R_PPC64_GOT_DTPREL16_LO_DS:
14268         case R_PPC64_GOT_DTPREL16_HI:
14269         case R_PPC64_GOT_DTPREL16_HA:
14270           tls_type = TLS_TLS | TLS_DTPREL;
14271           goto dogot;
14272
14273         case R_PPC64_GOT16:
14274         case R_PPC64_GOT16_LO:
14275         case R_PPC64_GOT16_HI:
14276         case R_PPC64_GOT16_HA:
14277         case R_PPC64_GOT16_DS:
14278         case R_PPC64_GOT16_LO_DS:
14279         dogot:
14280           {
14281             /* Relocation is to the entry for this symbol in the global
14282                offset table.  */
14283             asection *got;
14284             bfd_vma *offp;
14285             bfd_vma off;
14286             unsigned long indx = 0;
14287             struct got_entry *ent;
14288
14289             if (tls_type == (TLS_TLS | TLS_LD)
14290                 && (h == NULL
14291                     || !h->elf.def_dynamic))
14292               ent = ppc64_tlsld_got (input_bfd);
14293             else
14294               {
14295
14296                 if (h != NULL)
14297                   {
14298                     bfd_boolean dyn = htab->elf.dynamic_sections_created;
14299                     if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info),
14300                                                           &h->elf)
14301                         || (bfd_link_pic (info)
14302                             && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
14303                       /* This is actually a static link, or it is a
14304                          -Bsymbolic link and the symbol is defined
14305                          locally, or the symbol was forced to be local
14306                          because of a version file.  */
14307                       ;
14308                     else
14309                       {
14310                         BFD_ASSERT (h->elf.dynindx != -1);
14311                         indx = h->elf.dynindx;
14312                         unresolved_reloc = FALSE;
14313                       }
14314                     ent = h->elf.got.glist;
14315                   }
14316                 else
14317                   {
14318                     if (local_got_ents == NULL)
14319                       abort ();
14320                     ent = local_got_ents[r_symndx];
14321                   }
14322
14323                 for (; ent != NULL; ent = ent->next)
14324                   if (ent->addend == orig_rel.r_addend
14325                       && ent->owner == input_bfd
14326                       && ent->tls_type == tls_type)
14327                     break;
14328               }
14329
14330             if (ent == NULL)
14331               abort ();
14332             if (ent->is_indirect)
14333               ent = ent->got.ent;
14334             offp = &ent->got.offset;
14335             got = ppc64_elf_tdata (ent->owner)->got;
14336             if (got == NULL)
14337               abort ();
14338
14339             /* The offset must always be a multiple of 8.  We use the
14340                least significant bit to record whether we have already
14341                processed this entry.  */
14342             off = *offp;
14343             if ((off & 1) != 0)
14344               off &= ~1;
14345             else
14346               {
14347                 /* Generate relocs for the dynamic linker, except in
14348                    the case of TLSLD where we'll use one entry per
14349                    module.  */
14350                 asection *relgot;
14351                 bfd_boolean ifunc;
14352
14353                 *offp = off | 1;
14354                 relgot = NULL;
14355                 ifunc = (h != NULL
14356                          ? h->elf.type == STT_GNU_IFUNC
14357                          : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
14358                 if (ifunc)
14359                   relgot = htab->elf.irelplt;
14360                 else if ((bfd_link_pic (info) || indx != 0)
14361                          && (h == NULL
14362                              || (tls_type == (TLS_TLS | TLS_LD)
14363                                  && !h->elf.def_dynamic)
14364                              || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14365                              || h->elf.root.type != bfd_link_hash_undefweak))
14366                   relgot = ppc64_elf_tdata (ent->owner)->relgot;
14367                 if (relgot != NULL)
14368                   {
14369                     outrel.r_offset = (got->output_section->vma
14370                                        + got->output_offset
14371                                        + off);
14372                     outrel.r_addend = addend;
14373                     if (tls_type & (TLS_LD | TLS_GD))
14374                       {
14375                         outrel.r_addend = 0;
14376                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
14377                         if (tls_type == (TLS_TLS | TLS_GD))
14378                           {
14379                             loc = relgot->contents;
14380                             loc += (relgot->reloc_count++
14381                                     * sizeof (Elf64_External_Rela));
14382                             bfd_elf64_swap_reloca_out (output_bfd,
14383                                                        &outrel, loc);
14384                             outrel.r_offset += 8;
14385                             outrel.r_addend = addend;
14386                             outrel.r_info
14387                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14388                           }
14389                       }
14390                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
14391                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14392                     else if (tls_type == (TLS_TLS | TLS_TPREL))
14393                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
14394                     else if (indx != 0)
14395                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
14396                     else
14397                       {
14398                         if (ifunc)
14399                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14400                         else
14401                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14402
14403                         /* Write the .got section contents for the sake
14404                            of prelink.  */
14405                         loc = got->contents + off;
14406                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
14407                                     loc);
14408                       }
14409
14410                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
14411                       {
14412                         outrel.r_addend += relocation;
14413                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
14414                           {
14415                             if (htab->elf.tls_sec == NULL)
14416                               outrel.r_addend = 0;
14417                             else
14418                               outrel.r_addend -= htab->elf.tls_sec->vma;
14419                           }
14420                       }
14421                     loc = relgot->contents;
14422                     loc += (relgot->reloc_count++
14423                             * sizeof (Elf64_External_Rela));
14424                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14425                   }
14426
14427                 /* Init the .got section contents here if we're not
14428                    emitting a reloc.  */
14429                 else
14430                   {
14431                     relocation += addend;
14432                     if (tls_type == (TLS_TLS | TLS_LD))
14433                       relocation = 1;
14434                     else if (tls_type != 0)
14435                       {
14436                         if (htab->elf.tls_sec == NULL)
14437                           relocation = 0;
14438                         else
14439                           {
14440                             relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
14441                             if (tls_type == (TLS_TLS | TLS_TPREL))
14442                               relocation += DTP_OFFSET - TP_OFFSET;
14443                           }
14444
14445                         if (tls_type == (TLS_TLS | TLS_GD))
14446                           {
14447                             bfd_put_64 (output_bfd, relocation,
14448                                         got->contents + off + 8);
14449                             relocation = 1;
14450                           }
14451                       }
14452
14453                     bfd_put_64 (output_bfd, relocation,
14454                                 got->contents + off);
14455                   }
14456               }
14457
14458             if (off >= (bfd_vma) -2)
14459               abort ();
14460
14461             relocation = got->output_section->vma + got->output_offset + off;
14462             addend = -(TOCstart + htab->sec_info[input_section->id].toc_off);
14463           }
14464           break;
14465
14466         case R_PPC64_PLT16_HA:
14467         case R_PPC64_PLT16_HI:
14468         case R_PPC64_PLT16_LO:
14469         case R_PPC64_PLT32:
14470         case R_PPC64_PLT64:
14471           /* Relocation is to the entry for this symbol in the
14472              procedure linkage table.  */
14473           {
14474             struct plt_entry **plt_list = NULL;
14475             if (h != NULL)
14476               plt_list = &h->elf.plt.plist;
14477             else if (local_got_ents != NULL)
14478               {
14479                 struct plt_entry **local_plt = (struct plt_entry **)
14480                   (local_got_ents + symtab_hdr->sh_info);
14481                 unsigned char *local_got_tls_masks = (unsigned char *)
14482                   (local_plt + symtab_hdr->sh_info);
14483                 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
14484                   plt_list = local_plt + r_symndx;
14485               }
14486             if (plt_list)
14487               {
14488                 struct plt_entry *ent;
14489
14490                 for (ent = *plt_list; ent != NULL; ent = ent->next)
14491                   if (ent->plt.offset != (bfd_vma) -1
14492                       && ent->addend == orig_rel.r_addend)
14493                     {
14494                       asection *plt;
14495
14496                       plt = htab->elf.splt;
14497                       if (!htab->elf.dynamic_sections_created
14498                           || h == NULL
14499                           || h->elf.dynindx == -1)
14500                         plt = htab->elf.iplt;
14501                       relocation = (plt->output_section->vma
14502                                     + plt->output_offset
14503                                     + ent->plt.offset);
14504                       addend = 0;
14505                       unresolved_reloc = FALSE;
14506                       break;
14507                     }
14508               }
14509           }
14510           break;
14511
14512         case R_PPC64_TOC:
14513           /* Relocation value is TOC base.  */
14514           relocation = TOCstart;
14515           if (r_symndx == STN_UNDEF)
14516             relocation += htab->sec_info[input_section->id].toc_off;
14517           else if (unresolved_reloc)
14518             ;
14519           else if (sec != NULL && sec->id < htab->sec_info_arr_size)
14520             relocation += htab->sec_info[sec->id].toc_off;
14521           else
14522             unresolved_reloc = TRUE;
14523           goto dodyn;
14524
14525           /* TOC16 relocs.  We want the offset relative to the TOC base,
14526              which is the address of the start of the TOC plus 0x8000.
14527              The TOC consists of sections .got, .toc, .tocbss, and .plt,
14528              in this order.  */
14529         case R_PPC64_TOC16:
14530         case R_PPC64_TOC16_LO:
14531         case R_PPC64_TOC16_HI:
14532         case R_PPC64_TOC16_DS:
14533         case R_PPC64_TOC16_LO_DS:
14534         case R_PPC64_TOC16_HA:
14535           addend -= TOCstart + htab->sec_info[input_section->id].toc_off;
14536           break;
14537
14538           /* Relocate against the beginning of the section.  */
14539         case R_PPC64_SECTOFF:
14540         case R_PPC64_SECTOFF_LO:
14541         case R_PPC64_SECTOFF_HI:
14542         case R_PPC64_SECTOFF_DS:
14543         case R_PPC64_SECTOFF_LO_DS:
14544         case R_PPC64_SECTOFF_HA:
14545           if (sec != NULL)
14546             addend -= sec->output_section->vma;
14547           break;
14548
14549         case R_PPC64_REL16:
14550         case R_PPC64_REL16_LO:
14551         case R_PPC64_REL16_HI:
14552         case R_PPC64_REL16_HA:
14553         case R_PPC64_REL16DX_HA:
14554           break;
14555
14556         case R_PPC64_REL14:
14557         case R_PPC64_REL14_BRNTAKEN:
14558         case R_PPC64_REL14_BRTAKEN:
14559         case R_PPC64_REL24:
14560           break;
14561
14562         case R_PPC64_TPREL16:
14563         case R_PPC64_TPREL16_LO:
14564         case R_PPC64_TPREL16_HI:
14565         case R_PPC64_TPREL16_HA:
14566         case R_PPC64_TPREL16_DS:
14567         case R_PPC64_TPREL16_LO_DS:
14568         case R_PPC64_TPREL16_HIGH:
14569         case R_PPC64_TPREL16_HIGHA:
14570         case R_PPC64_TPREL16_HIGHER:
14571         case R_PPC64_TPREL16_HIGHERA:
14572         case R_PPC64_TPREL16_HIGHEST:
14573         case R_PPC64_TPREL16_HIGHESTA:
14574           if (h != NULL
14575               && h->elf.root.type == bfd_link_hash_undefweak
14576               && h->elf.dynindx == -1)
14577             {
14578               /* Make this relocation against an undefined weak symbol
14579                  resolve to zero.  This is really just a tweak, since
14580                  code using weak externs ought to check that they are
14581                  defined before using them.  */
14582               bfd_byte *p = contents + rel->r_offset - d_offset;
14583
14584               insn = bfd_get_32 (output_bfd, p);
14585               insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14586               if (insn != 0)
14587                 bfd_put_32 (output_bfd, insn, p);
14588               break;
14589             }
14590           if (htab->elf.tls_sec != NULL)
14591             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14592           if (bfd_link_pic (info))
14593             /* The TPREL16 relocs shouldn't really be used in shared
14594                libs as they will result in DT_TEXTREL being set, but
14595                support them anyway.  */
14596             goto dodyn;
14597           break;
14598
14599         case R_PPC64_DTPREL16:
14600         case R_PPC64_DTPREL16_LO:
14601         case R_PPC64_DTPREL16_HI:
14602         case R_PPC64_DTPREL16_HA:
14603         case R_PPC64_DTPREL16_DS:
14604         case R_PPC64_DTPREL16_LO_DS:
14605         case R_PPC64_DTPREL16_HIGH:
14606         case R_PPC64_DTPREL16_HIGHA:
14607         case R_PPC64_DTPREL16_HIGHER:
14608         case R_PPC64_DTPREL16_HIGHERA:
14609         case R_PPC64_DTPREL16_HIGHEST:
14610         case R_PPC64_DTPREL16_HIGHESTA:
14611           if (htab->elf.tls_sec != NULL)
14612             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14613           break;
14614
14615         case R_PPC64_ADDR64_LOCAL:
14616           addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
14617                                               ? h->elf.other
14618                                               : sym->st_other);
14619           break;
14620
14621         case R_PPC64_DTPMOD64:
14622           relocation = 1;
14623           addend = 0;
14624           goto dodyn;
14625
14626         case R_PPC64_TPREL64:
14627           if (htab->elf.tls_sec != NULL)
14628             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14629           goto dodyn;
14630
14631         case R_PPC64_DTPREL64:
14632           if (htab->elf.tls_sec != NULL)
14633             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14634           /* Fall thru */
14635
14636           /* Relocations that may need to be propagated if this is a
14637              dynamic object.  */
14638         case R_PPC64_REL30:
14639         case R_PPC64_REL32:
14640         case R_PPC64_REL64:
14641         case R_PPC64_ADDR14:
14642         case R_PPC64_ADDR14_BRNTAKEN:
14643         case R_PPC64_ADDR14_BRTAKEN:
14644         case R_PPC64_ADDR16:
14645         case R_PPC64_ADDR16_DS:
14646         case R_PPC64_ADDR16_HA:
14647         case R_PPC64_ADDR16_HI:
14648         case R_PPC64_ADDR16_HIGH:
14649         case R_PPC64_ADDR16_HIGHA:
14650         case R_PPC64_ADDR16_HIGHER:
14651         case R_PPC64_ADDR16_HIGHERA:
14652         case R_PPC64_ADDR16_HIGHEST:
14653         case R_PPC64_ADDR16_HIGHESTA:
14654         case R_PPC64_ADDR16_LO:
14655         case R_PPC64_ADDR16_LO_DS:
14656         case R_PPC64_ADDR24:
14657         case R_PPC64_ADDR32:
14658         case R_PPC64_ADDR64:
14659         case R_PPC64_UADDR16:
14660         case R_PPC64_UADDR32:
14661         case R_PPC64_UADDR64:
14662         dodyn:
14663           if ((input_section->flags & SEC_ALLOC) == 0)
14664             break;
14665
14666           if (NO_OPD_RELOCS && is_opd)
14667             break;
14668
14669           if ((bfd_link_pic (info)
14670                && (h == NULL
14671                    || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14672                    || h->elf.root.type != bfd_link_hash_undefweak)
14673                && (must_be_dyn_reloc (info, r_type)
14674                    || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
14675               || (ELIMINATE_COPY_RELOCS
14676                   && !bfd_link_pic (info)
14677                   && h != NULL
14678                   && h->elf.dynindx != -1
14679                   && !h->elf.non_got_ref
14680                   && !h->elf.def_regular)
14681               || (!bfd_link_pic (info)
14682                   && (h != NULL
14683                       ? h->elf.type == STT_GNU_IFUNC
14684                       : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)))
14685             {
14686               bfd_boolean skip, relocate;
14687               asection *sreloc;
14688               bfd_vma out_off;
14689
14690               /* When generating a dynamic object, these relocations
14691                  are copied into the output file to be resolved at run
14692                  time.  */
14693
14694               skip = FALSE;
14695               relocate = FALSE;
14696
14697               out_off = _bfd_elf_section_offset (output_bfd, info,
14698                                                  input_section, rel->r_offset);
14699               if (out_off == (bfd_vma) -1)
14700                 skip = TRUE;
14701               else if (out_off == (bfd_vma) -2)
14702                 skip = TRUE, relocate = TRUE;
14703               out_off += (input_section->output_section->vma
14704                           + input_section->output_offset);
14705               outrel.r_offset = out_off;
14706               outrel.r_addend = rel->r_addend;
14707
14708               /* Optimize unaligned reloc use.  */
14709               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14710                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14711                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14712               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14713                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
14714                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
14715               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
14716                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
14717                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
14718
14719               if (skip)
14720                 memset (&outrel, 0, sizeof outrel);
14721               else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14722                        && !is_opd
14723                        && r_type != R_PPC64_TOC)
14724                 {
14725                   BFD_ASSERT (h->elf.dynindx != -1);
14726                   outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
14727                 }
14728               else
14729                 {
14730                   /* This symbol is local, or marked to become local,
14731                      or this is an opd section reloc which must point
14732                      at a local function.  */
14733                   outrel.r_addend += relocation;
14734                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
14735                     {
14736                       if (is_opd && h != NULL)
14737                         {
14738                           /* Lie about opd entries.  This case occurs
14739                              when building shared libraries and we
14740                              reference a function in another shared
14741                              lib.  The same thing happens for a weak
14742                              definition in an application that's
14743                              overridden by a strong definition in a
14744                              shared lib.  (I believe this is a generic
14745                              bug in binutils handling of weak syms.)
14746                              In these cases we won't use the opd
14747                              entry in this lib.  */
14748                           unresolved_reloc = FALSE;
14749                         }
14750                       if (!is_opd
14751                           && r_type == R_PPC64_ADDR64
14752                           && (h != NULL
14753                               ? h->elf.type == STT_GNU_IFUNC
14754                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14755                         outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14756                       else
14757                         {
14758                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14759
14760                           /* We need to relocate .opd contents for ld.so.
14761                              Prelink also wants simple and consistent rules
14762                              for relocs.  This make all RELATIVE relocs have
14763                              *r_offset equal to r_addend.  */
14764                           relocate = TRUE;
14765                         }
14766                     }
14767                   else
14768                     {
14769                       long indx = 0;
14770
14771                       if (h != NULL
14772                           ? h->elf.type == STT_GNU_IFUNC
14773                           : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14774                         {
14775                           info->callbacks->einfo
14776                             (_("%P: %H: %s for indirect "
14777                                "function `%T' unsupported\n"),
14778                              input_bfd, input_section, rel->r_offset,
14779                              ppc64_elf_howto_table[r_type]->name,
14780                              sym_name);
14781                           ret = FALSE;
14782                         }
14783                       else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
14784                         ;
14785                       else if (sec == NULL || sec->owner == NULL)
14786                         {
14787                           bfd_set_error (bfd_error_bad_value);
14788                           return FALSE;
14789                         }
14790                       else
14791                         {
14792                           asection *osec;
14793
14794                           osec = sec->output_section;
14795                           indx = elf_section_data (osec)->dynindx;
14796
14797                           if (indx == 0)
14798                             {
14799                               if ((osec->flags & SEC_READONLY) == 0
14800                                   && htab->elf.data_index_section != NULL)
14801                                 osec = htab->elf.data_index_section;
14802                               else
14803                                 osec = htab->elf.text_index_section;
14804                               indx = elf_section_data (osec)->dynindx;
14805                             }
14806                           BFD_ASSERT (indx != 0);
14807
14808                           /* We are turning this relocation into one
14809                              against a section symbol, so subtract out
14810                              the output section's address but not the
14811                              offset of the input section in the output
14812                              section.  */
14813                           outrel.r_addend -= osec->vma;
14814                         }
14815
14816                       outrel.r_info = ELF64_R_INFO (indx, r_type);
14817                     }
14818                 }
14819
14820               sreloc = elf_section_data (input_section)->sreloc;
14821               if (h != NULL
14822                   ? h->elf.type == STT_GNU_IFUNC
14823                   : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14824                 sreloc = htab->elf.irelplt;
14825               if (sreloc == NULL)
14826                 abort ();
14827
14828               if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
14829                   >= sreloc->size)
14830                 abort ();
14831               loc = sreloc->contents;
14832               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
14833               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14834
14835               /* If this reloc is against an external symbol, it will
14836                  be computed at runtime, so there's no need to do
14837                  anything now.  However, for the sake of prelink ensure
14838                  that the section contents are a known value.  */
14839               if (! relocate)
14840                 {
14841                   unresolved_reloc = FALSE;
14842                   /* The value chosen here is quite arbitrary as ld.so
14843                      ignores section contents except for the special
14844                      case of .opd where the contents might be accessed
14845                      before relocation.  Choose zero, as that won't
14846                      cause reloc overflow.  */
14847                   relocation = 0;
14848                   addend = 0;
14849                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
14850                      to improve backward compatibility with older
14851                      versions of ld.  */
14852                   if (r_type == R_PPC64_ADDR64)
14853                     addend = outrel.r_addend;
14854                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
14855                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
14856                     addend = (input_section->output_section->vma
14857                               + input_section->output_offset
14858                               + rel->r_offset);
14859                 }
14860             }
14861           break;
14862
14863         case R_PPC64_COPY:
14864         case R_PPC64_GLOB_DAT:
14865         case R_PPC64_JMP_SLOT:
14866         case R_PPC64_JMP_IREL:
14867         case R_PPC64_RELATIVE:
14868           /* We shouldn't ever see these dynamic relocs in relocatable
14869              files.  */
14870           /* Fall through.  */
14871
14872         case R_PPC64_PLTGOT16:
14873         case R_PPC64_PLTGOT16_DS:
14874         case R_PPC64_PLTGOT16_HA:
14875         case R_PPC64_PLTGOT16_HI:
14876         case R_PPC64_PLTGOT16_LO:
14877         case R_PPC64_PLTGOT16_LO_DS:
14878         case R_PPC64_PLTREL32:
14879         case R_PPC64_PLTREL64:
14880           /* These ones haven't been implemented yet.  */
14881
14882           info->callbacks->einfo
14883             (_("%P: %B: %s is not supported for `%T'\n"),
14884              input_bfd,
14885              ppc64_elf_howto_table[r_type]->name, sym_name);
14886
14887           bfd_set_error (bfd_error_invalid_operation);
14888           ret = FALSE;
14889           goto copy_reloc;
14890         }
14891
14892       /* Multi-instruction sequences that access the TOC can be
14893          optimized, eg. addis ra,r2,0; addi rb,ra,x;
14894          to             nop;           addi rb,r2,x;  */
14895       switch (r_type)
14896         {
14897         default:
14898           break;
14899
14900         case R_PPC64_GOT_TLSLD16_HI:
14901         case R_PPC64_GOT_TLSGD16_HI:
14902         case R_PPC64_GOT_TPREL16_HI:
14903         case R_PPC64_GOT_DTPREL16_HI:
14904         case R_PPC64_GOT16_HI:
14905         case R_PPC64_TOC16_HI:
14906           /* These relocs would only be useful if building up an
14907              offset to later add to r2, perhaps in an indexed
14908              addressing mode instruction.  Don't try to optimize.
14909              Unfortunately, the possibility of someone building up an
14910              offset like this or even with the HA relocs, means that
14911              we need to check the high insn when optimizing the low
14912              insn.  */
14913           break;
14914
14915         case R_PPC64_GOT_TLSLD16_HA:
14916         case R_PPC64_GOT_TLSGD16_HA:
14917         case R_PPC64_GOT_TPREL16_HA:
14918         case R_PPC64_GOT_DTPREL16_HA:
14919         case R_PPC64_GOT16_HA:
14920         case R_PPC64_TOC16_HA:
14921           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14922               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14923             {
14924               bfd_byte *p = contents + (rel->r_offset & ~3);
14925               bfd_put_32 (input_bfd, NOP, p);
14926             }
14927           break;
14928
14929         case R_PPC64_GOT_TLSLD16_LO:
14930         case R_PPC64_GOT_TLSGD16_LO:
14931         case R_PPC64_GOT_TPREL16_LO_DS:
14932         case R_PPC64_GOT_DTPREL16_LO_DS:
14933         case R_PPC64_GOT16_LO:
14934         case R_PPC64_GOT16_LO_DS:
14935         case R_PPC64_TOC16_LO:
14936         case R_PPC64_TOC16_LO_DS:
14937           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14938               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14939             {
14940               bfd_byte *p = contents + (rel->r_offset & ~3);
14941               insn = bfd_get_32 (input_bfd, p);
14942               if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
14943                 {
14944                   /* Transform addic to addi when we change reg.  */
14945                   insn &= ~((0x3f << 26) | (0x1f << 16));
14946                   insn |= (14u << 26) | (2 << 16);
14947                 }
14948               else
14949                 {
14950                   insn &= ~(0x1f << 16);
14951                   insn |= 2 << 16;
14952                 }
14953               bfd_put_32 (input_bfd, insn, p);
14954             }
14955           break;
14956         }
14957
14958       /* Do any further special processing.  */
14959       howto = ppc64_elf_howto_table[(int) r_type];
14960       switch (r_type)
14961         {
14962         default:
14963           break;
14964
14965         case R_PPC64_REL16_HA:
14966         case R_PPC64_REL16DX_HA:
14967         case R_PPC64_ADDR16_HA:
14968         case R_PPC64_ADDR16_HIGHA:
14969         case R_PPC64_ADDR16_HIGHERA:
14970         case R_PPC64_ADDR16_HIGHESTA:
14971         case R_PPC64_TOC16_HA:
14972         case R_PPC64_SECTOFF_HA:
14973         case R_PPC64_TPREL16_HA:
14974         case R_PPC64_TPREL16_HIGHA:
14975         case R_PPC64_TPREL16_HIGHERA:
14976         case R_PPC64_TPREL16_HIGHESTA:
14977         case R_PPC64_DTPREL16_HA:
14978         case R_PPC64_DTPREL16_HIGHA:
14979         case R_PPC64_DTPREL16_HIGHERA:
14980         case R_PPC64_DTPREL16_HIGHESTA:
14981           /* It's just possible that this symbol is a weak symbol
14982              that's not actually defined anywhere. In that case,
14983              'sec' would be NULL, and we should leave the symbol
14984              alone (it will be set to zero elsewhere in the link).  */
14985           if (sec == NULL)
14986             break;
14987           /* Fall thru */
14988
14989         case R_PPC64_GOT16_HA:
14990         case R_PPC64_PLTGOT16_HA:
14991         case R_PPC64_PLT16_HA:
14992         case R_PPC64_GOT_TLSGD16_HA:
14993         case R_PPC64_GOT_TLSLD16_HA:
14994         case R_PPC64_GOT_TPREL16_HA:
14995         case R_PPC64_GOT_DTPREL16_HA:
14996           /* Add 0x10000 if sign bit in 0:15 is set.
14997              Bits 0:15 are not used.  */
14998           addend += 0x8000;
14999           break;
15000
15001         case R_PPC64_ADDR16_DS:
15002         case R_PPC64_ADDR16_LO_DS:
15003         case R_PPC64_GOT16_DS:
15004         case R_PPC64_GOT16_LO_DS:
15005         case R_PPC64_PLT16_LO_DS:
15006         case R_PPC64_SECTOFF_DS:
15007         case R_PPC64_SECTOFF_LO_DS:
15008         case R_PPC64_TOC16_DS:
15009         case R_PPC64_TOC16_LO_DS:
15010         case R_PPC64_PLTGOT16_DS:
15011         case R_PPC64_PLTGOT16_LO_DS:
15012         case R_PPC64_GOT_TPREL16_DS:
15013         case R_PPC64_GOT_TPREL16_LO_DS:
15014         case R_PPC64_GOT_DTPREL16_DS:
15015         case R_PPC64_GOT_DTPREL16_LO_DS:
15016         case R_PPC64_TPREL16_DS:
15017         case R_PPC64_TPREL16_LO_DS:
15018         case R_PPC64_DTPREL16_DS:
15019         case R_PPC64_DTPREL16_LO_DS:
15020           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15021           mask = 3;
15022           /* If this reloc is against an lq, lxv, or stxv insn, then
15023              the value must be a multiple of 16.  This is somewhat of
15024              a hack, but the "correct" way to do this by defining _DQ
15025              forms of all the _DS relocs bloats all reloc switches in
15026              this file.  It doesn't make much sense to use these
15027              relocs in data, so testing the insn should be safe.  */
15028           if ((insn & (0x3f << 26)) == (56u << 26)
15029               || ((insn & (0x3f << 26)) == (61u << 26) && (insn & 3) == 1))
15030             mask = 15;
15031           relocation += addend;
15032           addend = insn & (mask ^ 3);
15033           if ((relocation & mask) != 0)
15034             {
15035               relocation ^= relocation & mask;
15036               info->callbacks->einfo
15037                 (_("%P: %H: error: %s not a multiple of %u\n"),
15038                  input_bfd, input_section, rel->r_offset,
15039                  howto->name,
15040                  mask + 1);
15041               bfd_set_error (bfd_error_bad_value);
15042               ret = FALSE;
15043               goto copy_reloc;
15044             }
15045           break;
15046         }
15047
15048       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
15049          because such sections are not SEC_ALLOC and thus ld.so will
15050          not process them.  */
15051       if (unresolved_reloc
15052           && !((input_section->flags & SEC_DEBUGGING) != 0
15053                && h->elf.def_dynamic)
15054           && _bfd_elf_section_offset (output_bfd, info, input_section,
15055                                       rel->r_offset) != (bfd_vma) -1)
15056         {
15057           info->callbacks->einfo
15058             (_("%P: %H: unresolvable %s against `%T'\n"),
15059              input_bfd, input_section, rel->r_offset,
15060              howto->name,
15061              h->elf.root.root.string);
15062           ret = FALSE;
15063         }
15064
15065       /* 16-bit fields in insns mostly have signed values, but a
15066          few insns have 16-bit unsigned values.  Really, we should
15067          have different reloc types.  */
15068       if (howto->complain_on_overflow != complain_overflow_dont
15069           && howto->dst_mask == 0xffff
15070           && (input_section->flags & SEC_CODE) != 0)
15071         {
15072           enum complain_overflow complain = complain_overflow_signed;
15073
15074           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15075           if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
15076             complain = complain_overflow_bitfield;
15077           else if (howto->rightshift == 0
15078                    ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
15079                       || (insn & (0x3f << 26)) == 24u << 26 /* ori */
15080                       || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
15081                    : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
15082                       || (insn & (0x3f << 26)) == 25u << 26 /* oris */
15083                       || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
15084             complain = complain_overflow_unsigned;
15085           if (howto->complain_on_overflow != complain)
15086             {
15087               alt_howto = *howto;
15088               alt_howto.complain_on_overflow = complain;
15089               howto = &alt_howto;
15090             }
15091         }
15092
15093       if (r_type == R_PPC64_REL16DX_HA)
15094         {
15095           /* Split field reloc isn't handled by _bfd_final_link_relocate.  */
15096           if (rel->r_offset + 4 > input_section->size)
15097             r = bfd_reloc_outofrange;
15098           else
15099             {
15100               relocation += addend;
15101               relocation -= (rel->r_offset
15102                              + input_section->output_offset
15103                              + input_section->output_section->vma);
15104               relocation = (bfd_signed_vma) relocation >> 16;
15105               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
15106               insn &= ~0x1fffc1;
15107               insn |= (relocation & 0xffc1) | ((relocation & 0x3e) << 15);
15108               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
15109               r = bfd_reloc_ok;
15110               if (relocation + 0x8000 > 0xffff)
15111                 r = bfd_reloc_overflow;
15112             }
15113         }
15114       else
15115         r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
15116                                       rel->r_offset, relocation, addend);
15117
15118       if (r != bfd_reloc_ok)
15119         {
15120           char *more_info = NULL;
15121           const char *reloc_name = howto->name;
15122
15123           if (reloc_dest != DEST_NORMAL)
15124             {
15125               more_info = bfd_malloc (strlen (reloc_name) + 8);
15126               if (more_info != NULL)
15127                 {
15128                   strcpy (more_info, reloc_name);
15129                   strcat (more_info, (reloc_dest == DEST_OPD
15130                                       ? " (OPD)" : " (stub)"));
15131                   reloc_name = more_info;
15132                 }
15133             }
15134
15135           if (r == bfd_reloc_overflow)
15136             {
15137               /* On code like "if (foo) foo();" don't report overflow
15138                  on a branch to zero when foo is undefined.  */
15139               if (!warned
15140                   && (reloc_dest == DEST_STUB
15141                       || !(h != NULL
15142                            && (h->elf.root.type == bfd_link_hash_undefweak
15143                                || h->elf.root.type == bfd_link_hash_undefined)
15144                            && is_branch_reloc (r_type))))
15145                 {
15146                   if (!((*info->callbacks->reloc_overflow)
15147                         (info, &h->elf.root, sym_name,
15148                          reloc_name, orig_rel.r_addend,
15149                          input_bfd, input_section, rel->r_offset)))
15150                     return FALSE;
15151                 }
15152             }
15153           else
15154             {
15155               info->callbacks->einfo
15156                 (_("%P: %H: %s against `%T': error %d\n"),
15157                  input_bfd, input_section, rel->r_offset,
15158                  reloc_name, sym_name, (int) r);
15159               ret = FALSE;
15160             }
15161           if (more_info != NULL)
15162             free (more_info);
15163         }
15164     copy_reloc:
15165       if (wrel != rel)
15166         *wrel = *rel;
15167     }
15168
15169   if (wrel != rel)
15170     {
15171       Elf_Internal_Shdr *rel_hdr;
15172       size_t deleted = rel - wrel;
15173
15174       rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
15175       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15176       if (rel_hdr->sh_size == 0)
15177         {
15178           /* It is too late to remove an empty reloc section.  Leave
15179              one NONE reloc.
15180              ??? What is wrong with an empty section???  */
15181           rel_hdr->sh_size = rel_hdr->sh_entsize;
15182           deleted -= 1;
15183         }
15184       rel_hdr = _bfd_elf_single_rel_hdr (input_section);
15185       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15186       input_section->reloc_count -= deleted;
15187     }
15188
15189   /* If we're emitting relocations, then shortly after this function
15190      returns, reloc offsets and addends for this section will be
15191      adjusted.  Worse, reloc symbol indices will be for the output
15192      file rather than the input.  Save a copy of the relocs for
15193      opd_entry_value.  */
15194   if (is_opd && (info->emitrelocations || bfd_link_relocatable (info)))
15195     {
15196       bfd_size_type amt;
15197       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
15198       rel = bfd_alloc (input_bfd, amt);
15199       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
15200       ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
15201       if (rel == NULL)
15202         return FALSE;
15203       memcpy (rel, relocs, amt);
15204     }
15205   return ret;
15206 }
15207
15208 /* Adjust the value of any local symbols in opd sections.  */
15209
15210 static int
15211 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
15212                               const char *name ATTRIBUTE_UNUSED,
15213                               Elf_Internal_Sym *elfsym,
15214                               asection *input_sec,
15215                               struct elf_link_hash_entry *h)
15216 {
15217   struct _opd_sec_data *opd;
15218   long adjust;
15219   bfd_vma value;
15220
15221   if (h != NULL)
15222     return 1;
15223
15224   opd = get_opd_info (input_sec);
15225   if (opd == NULL || opd->adjust == NULL)
15226     return 1;
15227
15228   value = elfsym->st_value - input_sec->output_offset;
15229   if (!bfd_link_relocatable (info))
15230     value -= input_sec->output_section->vma;
15231
15232   adjust = opd->adjust[OPD_NDX (value)];
15233   if (adjust == -1)
15234     return 2;
15235
15236   elfsym->st_value += adjust;
15237   return 1;
15238 }
15239
15240 /* Finish up dynamic symbol handling.  We set the contents of various
15241    dynamic sections here.  */
15242
15243 static bfd_boolean
15244 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
15245                                  struct bfd_link_info *info,
15246                                  struct elf_link_hash_entry *h,
15247                                  Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
15248 {
15249   struct ppc_link_hash_table *htab;
15250   struct plt_entry *ent;
15251   Elf_Internal_Rela rela;
15252   bfd_byte *loc;
15253
15254   htab = ppc_hash_table (info);
15255   if (htab == NULL)
15256     return FALSE;
15257
15258   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
15259     if (ent->plt.offset != (bfd_vma) -1)
15260       {
15261         /* This symbol has an entry in the procedure linkage
15262            table.  Set it up.  */
15263         if (!htab->elf.dynamic_sections_created
15264             || h->dynindx == -1)
15265           {
15266             BFD_ASSERT (h->type == STT_GNU_IFUNC
15267                         && h->def_regular
15268                         && (h->root.type == bfd_link_hash_defined
15269                             || h->root.type == bfd_link_hash_defweak));
15270             rela.r_offset = (htab->elf.iplt->output_section->vma
15271                              + htab->elf.iplt->output_offset
15272                              + ent->plt.offset);
15273             if (htab->opd_abi)
15274               rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
15275             else
15276               rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15277             rela.r_addend = (h->root.u.def.value
15278                              + h->root.u.def.section->output_offset
15279                              + h->root.u.def.section->output_section->vma
15280                              + ent->addend);
15281             loc = (htab->elf.irelplt->contents
15282                    + (htab->elf.irelplt->reloc_count++
15283                       * sizeof (Elf64_External_Rela)));
15284           }
15285         else
15286           {
15287             rela.r_offset = (htab->elf.splt->output_section->vma
15288                              + htab->elf.splt->output_offset
15289                              + ent->plt.offset);
15290             rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
15291             rela.r_addend = ent->addend;
15292             loc = (htab->elf.srelplt->contents
15293                    + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
15294                       / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
15295           }
15296         bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15297
15298         if (!htab->opd_abi)
15299           {
15300             if (!h->def_regular)
15301               {
15302                 /* Mark the symbol as undefined, rather than as
15303                    defined in glink.  Leave the value if there were
15304                    any relocations where pointer equality matters
15305                    (this is a clue for the dynamic linker, to make
15306                    function pointer comparisons work between an
15307                    application and shared library), otherwise set it
15308                    to zero.  */
15309                 sym->st_shndx = SHN_UNDEF;
15310                 if (!h->pointer_equality_needed)
15311                   sym->st_value = 0;
15312                 else if (!h->ref_regular_nonweak)
15313                   {
15314                     /* This breaks function pointer comparisons, but
15315                        that is better than breaking tests for a NULL
15316                        function pointer.  */
15317                     sym->st_value = 0;
15318                   }
15319               }
15320           }
15321       }
15322
15323   if (h->needs_copy)
15324     {
15325       /* This symbol needs a copy reloc.  Set it up.  */
15326
15327       if (h->dynindx == -1
15328           || (h->root.type != bfd_link_hash_defined
15329               && h->root.type != bfd_link_hash_defweak)
15330           || htab->relbss == NULL)
15331         abort ();
15332
15333       rela.r_offset = (h->root.u.def.value
15334                        + h->root.u.def.section->output_section->vma
15335                        + h->root.u.def.section->output_offset);
15336       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
15337       rela.r_addend = 0;
15338       loc = htab->relbss->contents;
15339       loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
15340       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15341     }
15342
15343   return TRUE;
15344 }
15345
15346 /* Used to decide how to sort relocs in an optimal manner for the
15347    dynamic linker, before writing them out.  */
15348
15349 static enum elf_reloc_type_class
15350 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
15351                             const asection *rel_sec,
15352                             const Elf_Internal_Rela *rela)
15353 {
15354   enum elf_ppc64_reloc_type r_type;
15355   struct ppc_link_hash_table *htab = ppc_hash_table (info);
15356
15357   if (rel_sec == htab->elf.irelplt)
15358     return reloc_class_ifunc;
15359
15360   r_type = ELF64_R_TYPE (rela->r_info);
15361   switch (r_type)
15362     {
15363     case R_PPC64_RELATIVE:
15364       return reloc_class_relative;
15365     case R_PPC64_JMP_SLOT:
15366       return reloc_class_plt;
15367     case R_PPC64_COPY:
15368       return reloc_class_copy;
15369     default:
15370       return reloc_class_normal;
15371     }
15372 }
15373
15374 /* Finish up the dynamic sections.  */
15375
15376 static bfd_boolean
15377 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
15378                                    struct bfd_link_info *info)
15379 {
15380   struct ppc_link_hash_table *htab;
15381   bfd *dynobj;
15382   asection *sdyn;
15383
15384   htab = ppc_hash_table (info);
15385   if (htab == NULL)
15386     return FALSE;
15387
15388   dynobj = htab->elf.dynobj;
15389   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
15390
15391   if (htab->elf.dynamic_sections_created)
15392     {
15393       Elf64_External_Dyn *dyncon, *dynconend;
15394
15395       if (sdyn == NULL || htab->elf.sgot == NULL)
15396         abort ();
15397
15398       dyncon = (Elf64_External_Dyn *) sdyn->contents;
15399       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
15400       for (; dyncon < dynconend; dyncon++)
15401         {
15402           Elf_Internal_Dyn dyn;
15403           asection *s;
15404
15405           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
15406
15407           switch (dyn.d_tag)
15408             {
15409             default:
15410               continue;
15411
15412             case DT_PPC64_GLINK:
15413               s = htab->glink;
15414               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15415               /* We stupidly defined DT_PPC64_GLINK to be the start
15416                  of glink rather than the first entry point, which is
15417                  what ld.so needs, and now have a bigger stub to
15418                  support automatic multiple TOCs.  */
15419               dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
15420               break;
15421
15422             case DT_PPC64_OPD:
15423               s = bfd_get_section_by_name (output_bfd, ".opd");
15424               if (s == NULL)
15425                 continue;
15426               dyn.d_un.d_ptr = s->vma;
15427               break;
15428
15429             case DT_PPC64_OPT:
15430               if (htab->do_multi_toc && htab->multi_toc_needed)
15431                 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
15432               break;
15433
15434             case DT_PPC64_OPDSZ:
15435               s = bfd_get_section_by_name (output_bfd, ".opd");
15436               if (s == NULL)
15437                 continue;
15438               dyn.d_un.d_val = s->size;
15439               break;
15440
15441             case DT_PLTGOT:
15442               s = htab->elf.splt;
15443               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15444               break;
15445
15446             case DT_JMPREL:
15447               s = htab->elf.srelplt;
15448               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15449               break;
15450
15451             case DT_PLTRELSZ:
15452               dyn.d_un.d_val = htab->elf.srelplt->size;
15453               break;
15454
15455             case DT_RELASZ:
15456               /* Don't count procedure linkage table relocs in the
15457                  overall reloc count.  */
15458               s = htab->elf.srelplt;
15459               if (s == NULL)
15460                 continue;
15461               dyn.d_un.d_val -= s->size;
15462               break;
15463
15464             case DT_RELA:
15465               /* We may not be using the standard ELF linker script.
15466                  If .rela.plt is the first .rela section, we adjust
15467                  DT_RELA to not include it.  */
15468               s = htab->elf.srelplt;
15469               if (s == NULL)
15470                 continue;
15471               if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
15472                 continue;
15473               dyn.d_un.d_ptr += s->size;
15474               break;
15475             }
15476
15477           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
15478         }
15479     }
15480
15481   if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0)
15482     {
15483       /* Fill in the first entry in the global offset table.
15484          We use it to hold the link-time TOCbase.  */
15485       bfd_put_64 (output_bfd,
15486                   elf_gp (output_bfd) + TOC_BASE_OFF,
15487                   htab->elf.sgot->contents);
15488
15489       /* Set .got entry size.  */
15490       elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
15491     }
15492
15493   if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
15494     {
15495       /* Set .plt entry size.  */
15496       elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
15497         = PLT_ENTRY_SIZE (htab);
15498     }
15499
15500   /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
15501      brlt ourselves if emitrelocations.  */
15502   if (htab->brlt != NULL
15503       && htab->brlt->reloc_count != 0
15504       && !_bfd_elf_link_output_relocs (output_bfd,
15505                                        htab->brlt,
15506                                        elf_section_data (htab->brlt)->rela.hdr,
15507                                        elf_section_data (htab->brlt)->relocs,
15508                                        NULL))
15509     return FALSE;
15510
15511   if (htab->glink != NULL
15512       && htab->glink->reloc_count != 0
15513       && !_bfd_elf_link_output_relocs (output_bfd,
15514                                        htab->glink,
15515                                        elf_section_data (htab->glink)->rela.hdr,
15516                                        elf_section_data (htab->glink)->relocs,
15517                                        NULL))
15518     return FALSE;
15519
15520   if (htab->glink_eh_frame != NULL
15521       && htab->glink_eh_frame->size != 0)
15522     {
15523       bfd_vma val;
15524       bfd_byte *p;
15525       asection *stub_sec;
15526
15527       p = htab->glink_eh_frame->contents + sizeof (glink_eh_frame_cie);
15528       for (stub_sec = htab->params->stub_bfd->sections;
15529            stub_sec != NULL;
15530            stub_sec = stub_sec->next)
15531         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
15532           {
15533             /* FDE length.  */
15534             p += 4;
15535             /* CIE pointer.  */
15536             p += 4;
15537             /* Offset to stub section.  */
15538             val = (stub_sec->output_section->vma
15539                    + stub_sec->output_offset);
15540             val -= (htab->glink_eh_frame->output_section->vma
15541                     + htab->glink_eh_frame->output_offset
15542                     + (p - htab->glink_eh_frame->contents));
15543             if (val + 0x80000000 > 0xffffffff)
15544               {
15545                 info->callbacks->einfo
15546                   (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15547                    stub_sec->name);
15548                 return FALSE;
15549               }
15550             bfd_put_32 (dynobj, val, p);
15551             p += 4;
15552             /* stub section size.  */
15553             p += 4;
15554             /* Augmentation.  */
15555             p += 1;
15556             /* Pad.  */
15557             p += 7;
15558           }
15559       if (htab->glink != NULL && htab->glink->size != 0)
15560         {
15561           /* FDE length.  */
15562           p += 4;
15563           /* CIE pointer.  */
15564           p += 4;
15565           /* Offset to .glink.  */
15566           val = (htab->glink->output_section->vma
15567                  + htab->glink->output_offset
15568                  + 8);
15569           val -= (htab->glink_eh_frame->output_section->vma
15570                   + htab->glink_eh_frame->output_offset
15571                   + (p - htab->glink_eh_frame->contents));
15572           if (val + 0x80000000 > 0xffffffff)
15573             {
15574               info->callbacks->einfo
15575                 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15576                  htab->glink->name);
15577               return FALSE;
15578             }
15579           bfd_put_32 (dynobj, val, p);
15580           p += 4;
15581           /* .glink size.  */
15582           p += 4;
15583           /* Augmentation.  */
15584           p += 1;
15585           /* Ops.  */
15586           p += 7;
15587         }
15588
15589       if (htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
15590           && !_bfd_elf_write_section_eh_frame (output_bfd, info,
15591                                                htab->glink_eh_frame,
15592                                                htab->glink_eh_frame->contents))
15593         return FALSE;
15594     }
15595
15596   /* We need to handle writing out multiple GOT sections ourselves,
15597      since we didn't add them to DYNOBJ.  We know dynobj is the first
15598      bfd.  */
15599   while ((dynobj = dynobj->link.next) != NULL)
15600     {
15601       asection *s;
15602
15603       if (!is_ppc64_elf (dynobj))
15604         continue;
15605
15606       s = ppc64_elf_tdata (dynobj)->got;
15607       if (s != NULL
15608           && s->size != 0
15609           && s->output_section != bfd_abs_section_ptr
15610           && !bfd_set_section_contents (output_bfd, s->output_section,
15611                                         s->contents, s->output_offset,
15612                                         s->size))
15613         return FALSE;
15614       s = ppc64_elf_tdata (dynobj)->relgot;
15615       if (s != NULL
15616           && s->size != 0
15617           && s->output_section != bfd_abs_section_ptr
15618           && !bfd_set_section_contents (output_bfd, s->output_section,
15619                                         s->contents, s->output_offset,
15620                                         s->size))
15621         return FALSE;
15622     }
15623
15624   return TRUE;
15625 }
15626
15627 #include "elf64-target.h"
15628
15629 /* FreeBSD support */
15630
15631 #undef  TARGET_LITTLE_SYM
15632 #undef  TARGET_LITTLE_NAME
15633
15634 #undef  TARGET_BIG_SYM
15635 #define TARGET_BIG_SYM  powerpc_elf64_fbsd_vec
15636 #undef  TARGET_BIG_NAME
15637 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15638
15639 #undef  ELF_OSABI
15640 #define ELF_OSABI       ELFOSABI_FREEBSD
15641
15642 #undef  elf64_bed
15643 #define elf64_bed       elf64_powerpc_fbsd_bed
15644
15645 #include "elf64-target.h"
15646