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