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