bfd/elf64-ppc.c

   1 /* PowerPC64-specific support for 64-bit ELF.
   2    Copyright (C) 1999-2016 Free Software Foundation, Inc.
   3    Written by Linus Nordberg, Swox AB <info@swox.com>,
   4    based on elf32-ppc.c by Ian Lance Taylor.
   5    Largely rewritten by Alan Modra.
   6
   7    This file is part of BFD, the Binary File Descriptor library.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License along
  20    with this program; if not, write to the Free Software Foundation, Inc.,
  21    51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
  22
  23
  24 /* The 64-bit PowerPC ELF ABI may be found at
  25    http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and
  26    http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html  */
  27
  28 #include "sysdep.h"
  29 #include <stdarg.h>
  30 #include "bfd.h"
  31 #include "bfdlink.h"
  32 #include "libbfd.h"
  33 #include "elf-bfd.h"
  34 #include "elf/ppc64.h"
  35 #include "elf64-ppc.h"
  36 #include "dwarf2.h"
  37
  38 static bfd_reloc_status_type ppc64_elf_ha_reloc
  39   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  40 static bfd_reloc_status_type ppc64_elf_branch_reloc
  41   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  42 static bfd_reloc_status_type ppc64_elf_brtaken_reloc
  43   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  44 static bfd_reloc_status_type ppc64_elf_sectoff_reloc
  45   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  46 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
  47   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  48 static bfd_reloc_status_type ppc64_elf_toc_reloc
  49   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  50 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
  51   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  52 static bfd_reloc_status_type ppc64_elf_toc64_reloc
  53   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  54 static bfd_reloc_status_type ppc64_elf_unhandled_reloc
  55   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  56 static bfd_vma opd_entry_value
  57   (asection *, bfd_vma, asection **, bfd_vma *, bfd_boolean);
  58
  59 #define TARGET_LITTLE_SYM       powerpc_elf64_le_vec
  60 #define TARGET_LITTLE_NAME      "elf64-powerpcle"
  61 #define TARGET_BIG_SYM          powerpc_elf64_vec
  62 #define TARGET_BIG_NAME         "elf64-powerpc"
  63 #define ELF_ARCH                bfd_arch_powerpc
  64 #define ELF_TARGET_ID           PPC64_ELF_DATA
  65 #define ELF_MACHINE_CODE        EM_PPC64
  66 #define ELF_MAXPAGESIZE         0x10000
  67 #define ELF_COMMONPAGESIZE      0x10000
  68 #define elf_info_to_howto       ppc64_elf_info_to_howto
  69
  70 #define elf_backend_want_got_sym 0
  71 #define elf_backend_want_plt_sym 0
  72 #define elf_backend_plt_alignment 3
  73 #define elf_backend_plt_not_loaded 1
  74 #define elf_backend_got_header_size 8
  75 #define elf_backend_can_gc_sections 1
  76 #define elf_backend_can_refcount 1
  77 #define elf_backend_rela_normal 1
  78 #define elf_backend_default_execstack 0
  79
  80 #define bfd_elf64_mkobject                    ppc64_elf_mkobject
  81 #define bfd_elf64_bfd_reloc_type_lookup       ppc64_elf_reloc_type_lookup
  82 #define bfd_elf64_bfd_reloc_name_lookup       ppc64_elf_reloc_name_lookup
  83 #define bfd_elf64_bfd_merge_private_bfd_data  ppc64_elf_merge_private_bfd_data
  84 #define bfd_elf64_bfd_print_private_bfd_data  ppc64_elf_print_private_bfd_data
  85 #define bfd_elf64_new_section_hook            ppc64_elf_new_section_hook
  86 #define bfd_elf64_bfd_link_hash_table_create  ppc64_elf_link_hash_table_create
  87 #define bfd_elf64_get_synthetic_symtab        ppc64_elf_get_synthetic_symtab
  88 #define bfd_elf64_bfd_link_just_syms          ppc64_elf_link_just_syms
  89
  90 #define elf_backend_object_p                  ppc64_elf_object_p
  91 #define elf_backend_grok_prstatus             ppc64_elf_grok_prstatus
  92 #define elf_backend_grok_psinfo               ppc64_elf_grok_psinfo
  93 #define elf_backend_write_core_note           ppc64_elf_write_core_note
  94 #define elf_backend_create_dynamic_sections   ppc64_elf_create_dynamic_sections
  95 #define elf_backend_copy_indirect_symbol      ppc64_elf_copy_indirect_symbol
  96 #define elf_backend_add_symbol_hook           ppc64_elf_add_symbol_hook
  97 #define elf_backend_check_directives          ppc64_elf_before_check_relocs
  98 #define elf_backend_notice_as_needed          ppc64_elf_notice_as_needed
  99 #define elf_backend_archive_symbol_lookup     ppc64_elf_archive_symbol_lookup
 100 #define elf_backend_check_relocs              ppc64_elf_check_relocs
 101 #define elf_backend_gc_keep                   ppc64_elf_gc_keep
 102 #define elf_backend_gc_mark_dynamic_ref       ppc64_elf_gc_mark_dynamic_ref
 103 #define elf_backend_gc_mark_hook              ppc64_elf_gc_mark_hook
 104 #define elf_backend_gc_sweep_hook             ppc64_elf_gc_sweep_hook
 105 #define elf_backend_adjust_dynamic_symbol     ppc64_elf_adjust_dynamic_symbol
 106 #define elf_backend_hide_symbol               ppc64_elf_hide_symbol
 107 #define elf_backend_maybe_function_sym        ppc64_elf_maybe_function_sym
 108 #define elf_backend_always_size_sections      ppc64_elf_func_desc_adjust
 109 #define elf_backend_size_dynamic_sections     ppc64_elf_size_dynamic_sections
 110 #define elf_backend_hash_symbol               ppc64_elf_hash_symbol
 111 #define elf_backend_init_index_section        _bfd_elf_init_2_index_sections
 112 #define elf_backend_action_discarded          ppc64_elf_action_discarded
 113 #define elf_backend_relocate_section          ppc64_elf_relocate_section
 114 #define elf_backend_finish_dynamic_symbol     ppc64_elf_finish_dynamic_symbol
 115 #define elf_backend_reloc_type_class          ppc64_elf_reloc_type_class
 116 #define elf_backend_finish_dynamic_sections   ppc64_elf_finish_dynamic_sections
 117 #define elf_backend_link_output_symbol_hook   ppc64_elf_output_symbol_hook
 118 #define elf_backend_special_sections          ppc64_elf_special_sections
 119 #define elf_backend_merge_symbol_attribute    ppc64_elf_merge_symbol_attribute
 120
 121 /* The name of the dynamic interpreter.  This is put in the .interp
 122    section.  */
 123 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
 124
 125 /* The size in bytes of an entry in the procedure linkage table.  */
 126 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
 127
 128 /* The initial size of the plt reserved for the dynamic linker.  */
 129 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
 130
 131 /* Offsets to some stack save slots.  */
 132 #define STK_LR 16
 133 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
 134 /* This one is dodgy.  ELFv2 does not have a linker word, so use the
 135    CR save slot.  Used only by optimised __tls_get_addr call stub,
 136    relying on __tls_get_addr_opt not saving CR..  */
 137 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
 138
 139 /* TOC base pointers offset from start of TOC.  */
 140 #define TOC_BASE_OFF    0x8000
 141 /* TOC base alignment.  */
 142 #define TOC_BASE_ALIGN  256
 143
 144 /* Offset of tp and dtp pointers from start of TLS block.  */
 145 #define TP_OFFSET       0x7000
 146 #define DTP_OFFSET      0x8000
 147
 148 /* .plt call stub instructions.  The normal stub is like this, but
 149    sometimes the .plt entry crosses a 64k boundary and we need to
 150    insert an addi to adjust r11.  */
 151 #define STD_R2_0R1      0xf8410000      /* std   %r2,0+40(%r1)       */
 152 #define ADDIS_R11_R2    0x3d620000      /* addis %r11,%r2,xxx@ha     */
 153 #define LD_R12_0R11     0xe98b0000      /* ld    %r12,xxx+0@l(%r11)  */
 154 #define MTCTR_R12       0x7d8903a6      /* mtctr %r12                */
 155 #define LD_R2_0R11      0xe84b0000      /* ld    %r2,xxx+8@l(%r11)   */
 156 #define LD_R11_0R11     0xe96b0000      /* ld    %r11,xxx+16@l(%r11) */
 157 #define BCTR            0x4e800420      /* bctr                      */
 158
 159 #define ADDI_R11_R11    0x396b0000      /* addi %r11,%r11,off@l  */
 160 #define ADDIS_R2_R2     0x3c420000      /* addis %r2,%r2,off@ha  */
 161 #define ADDI_R2_R2      0x38420000      /* addi  %r2,%r2,off@l   */
 162
 163 #define XOR_R2_R12_R12  0x7d826278      /* xor   %r2,%r12,%r12   */
 164 #define ADD_R11_R11_R2  0x7d6b1214      /* add   %r11,%r11,%r2   */
 165 #define XOR_R11_R12_R12 0x7d8b6278      /* xor   %r11,%r12,%r12  */
 166 #define ADD_R2_R2_R11   0x7c425a14      /* add   %r2,%r2,%r11    */
 167 #define CMPLDI_R2_0     0x28220000      /* cmpldi %r2,0          */
 168 #define BNECTR          0x4ca20420      /* bnectr+               */
 169 #define BNECTR_P4       0x4ce20420      /* bnectr+               */
 170
 171 #define LD_R12_0R2      0xe9820000      /* ld    %r12,xxx+0(%r2) */
 172 #define LD_R11_0R2      0xe9620000      /* ld    %r11,xxx+0(%r2) */
 173 #define LD_R2_0R2       0xe8420000      /* ld    %r2,xxx+0(%r2)  */
 174
 175 #define LD_R2_0R1       0xe8410000      /* ld    %r2,0(%r1)      */
 176 #define LD_R2_0R12      0xe84c0000      /* ld    %r2,0(%r12)     */
 177 #define ADD_R2_R2_R12   0x7c426214      /* add   %r2,%r2,%r12    */
 178
 179 #define LIS_R2          0x3c400000      /* lis %r2,xxx@ha         */
 180 #define ADDIS_R2_R12    0x3c4c0000      /* addis %r2,%r12,xxx@ha  */
 181 #define ADDIS_R12_R2    0x3d820000      /* addis %r12,%r2,xxx@ha  */
 182 #define ADDIS_R12_R12   0x3d8c0000      /* addis %r12,%r12,xxx@ha */
 183 #define LD_R12_0R12     0xe98c0000      /* ld    %r12,xxx@l(%r12) */
 184
 185 /* glink call stub instructions.  We enter with the index in R0.  */
 186 #define GLINK_CALL_STUB_SIZE (16*4)
 187                                         /* 0:                           */
 188                                         /*  .quad plt0-1f               */
 189                                         /* __glink:                     */
 190 #define MFLR_R12        0x7d8802a6      /*  mflr %12                    */
 191 #define BCL_20_31       0x429f0005      /*  bcl 20,31,1f                */
 192                                         /* 1:                           */
 193 #define MFLR_R11        0x7d6802a6      /*  mflr %11                    */
 194                                         /*  ld %2,(0b-1b)(%11)          */
 195 #define MTLR_R12        0x7d8803a6      /*  mtlr %12                    */
 196 #define ADD_R11_R2_R11  0x7d625a14      /*  add %11,%2,%11              */
 197                                         /*  ld %12,0(%11)               */
 198                                         /*  ld %2,8(%11)                */
 199                                         /*  mtctr %12                   */
 200                                         /*  ld %11,16(%11)              */
 201                                         /*  bctr                        */
 202 #define MFLR_R0         0x7c0802a6      /*  mflr %r0                    */
 203 #define MTLR_R0         0x7c0803a6      /*  mtlr %r0                    */
 204 #define SUB_R12_R12_R11 0x7d8b6050      /*  subf %r12,%r11,%r12         */
 205 #define ADDI_R0_R12     0x380c0000      /*  addi %r0,%r12,0             */
 206 #define SRDI_R0_R0_2    0x7800f082      /*  rldicl %r0,%r0,62,2         */
 207
 208 /* Pad with this.  */
 209 #define NOP             0x60000000
 210
 211 /* Some other nops.  */
 212 #define CROR_151515     0x4def7b82
 213 #define CROR_313131     0x4ffffb82
 214
 215 /* .glink entries for the first 32k functions are two instructions.  */
 216 #define LI_R0_0         0x38000000      /* li    %r0,0          */
 217 #define B_DOT           0x48000000      /* b     .              */
 218
 219 /* After that, we need two instructions to load the index, followed by
 220    a branch.  */
 221 #define LIS_R0_0        0x3c000000      /* lis   %r0,0          */
 222 #define ORI_R0_R0_0     0x60000000      /* ori   %r0,%r0,0      */
 223
 224 /* Instructions used by the save and restore reg functions.  */
 225 #define STD_R0_0R1      0xf8010000      /* std   %r0,0(%r1)     */
 226 #define STD_R0_0R12     0xf80c0000      /* std   %r0,0(%r12)    */
 227 #define LD_R0_0R1       0xe8010000      /* ld    %r0,0(%r1)     */
 228 #define LD_R0_0R12      0xe80c0000      /* ld    %r0,0(%r12)    */
 229 #define STFD_FR0_0R1    0xd8010000      /* stfd  %fr0,0(%r1)    */
 230 #define LFD_FR0_0R1     0xc8010000      /* lfd   %fr0,0(%r1)    */
 231 #define LI_R12_0        0x39800000      /* li    %r12,0         */
 232 #define STVX_VR0_R12_R0 0x7c0c01ce      /* stvx  %v0,%r12,%r0   */
 233 #define LVX_VR0_R12_R0  0x7c0c00ce      /* lvx   %v0,%r12,%r0   */
 234 #define MTLR_R0         0x7c0803a6      /* mtlr  %r0            */
 235 #define BLR             0x4e800020      /* blr                  */
 236
 237 /* Since .opd is an array of descriptors and each entry will end up
 238    with identical R_PPC64_RELATIVE relocs, there is really no need to
 239    propagate .opd relocs;  The dynamic linker should be taught to
 240    relocate .opd without reloc entries.  */
 241 #ifndef NO_OPD_RELOCS
 242 #define NO_OPD_RELOCS 0
 243 #endif
 244
 245 #ifndef ARRAY_SIZE
 246 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
 247 #endif
 248
 249 static inline int
 250 abiversion (bfd *abfd)
 251 {
 252   return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
 253 }
 254
 255 static inline void
 256 set_abiversion (bfd *abfd, int ver)
 257 {
 258   elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
 259   elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
 260 }
 261 \f
 262 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
 263
 264 /* Relocation HOWTO's.  */
 265 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
 266
 267 static reloc_howto_type ppc64_elf_howto_raw[] = {
 268   /* This reloc does nothing.  */
 269   HOWTO (R_PPC64_NONE,          /* type */
 270          0,                     /* rightshift */
 271          3,                     /* size (0 = byte, 1 = short, 2 = long) */
 272          0,                     /* bitsize */
 273          FALSE,                 /* pc_relative */
 274          0,                     /* bitpos */
 275          complain_overflow_dont, /* complain_on_overflow */
 276          bfd_elf_generic_reloc, /* special_function */
 277          "R_PPC64_NONE",        /* name */
 278          FALSE,                 /* partial_inplace */
 279          0,                     /* src_mask */
 280          0,                     /* dst_mask */
 281          FALSE),                /* pcrel_offset */
 282
 283   /* A standard 32 bit relocation.  */
 284   HOWTO (R_PPC64_ADDR32,        /* type */
 285          0,                     /* rightshift */
 286          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 287          32,                    /* bitsize */
 288          FALSE,                 /* pc_relative */
 289          0,                     /* bitpos */
 290          complain_overflow_bitfield, /* complain_on_overflow */
 291          bfd_elf_generic_reloc, /* special_function */
 292          "R_PPC64_ADDR32",      /* name */
 293          FALSE,                 /* partial_inplace */
 294          0,                     /* src_mask */
 295          0xffffffff,            /* dst_mask */
 296          FALSE),                /* pcrel_offset */
 297
 298   /* An absolute 26 bit branch; the lower two bits must be zero.
 299      FIXME: we don't check that, we just clear them.  */
 300   HOWTO (R_PPC64_ADDR24,        /* type */
 301          0,                     /* rightshift */
 302          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 303          26,                    /* bitsize */
 304          FALSE,                 /* pc_relative */
 305          0,                     /* bitpos */
 306          complain_overflow_bitfield, /* complain_on_overflow */
 307          bfd_elf_generic_reloc, /* special_function */
 308          "R_PPC64_ADDR24",      /* name */
 309          FALSE,                 /* partial_inplace */
 310          0,                     /* src_mask */
 311          0x03fffffc,            /* dst_mask */
 312          FALSE),                /* pcrel_offset */
 313
 314   /* A standard 16 bit relocation.  */
 315   HOWTO (R_PPC64_ADDR16,        /* type */
 316          0,                     /* rightshift */
 317          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 318          16,                    /* bitsize */
 319          FALSE,                 /* pc_relative */
 320          0,                     /* bitpos */
 321          complain_overflow_bitfield, /* complain_on_overflow */
 322          bfd_elf_generic_reloc, /* special_function */
 323          "R_PPC64_ADDR16",      /* name */
 324          FALSE,                 /* partial_inplace */
 325          0,                     /* src_mask */
 326          0xffff,                /* dst_mask */
 327          FALSE),                /* pcrel_offset */
 328
 329   /* A 16 bit relocation without overflow.  */
 330   HOWTO (R_PPC64_ADDR16_LO,     /* type */
 331          0,                     /* rightshift */
 332          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 333          16,                    /* bitsize */
 334          FALSE,                 /* pc_relative */
 335          0,                     /* bitpos */
 336          complain_overflow_dont,/* complain_on_overflow */
 337          bfd_elf_generic_reloc, /* special_function */
 338          "R_PPC64_ADDR16_LO",   /* name */
 339          FALSE,                 /* partial_inplace */
 340          0,                     /* src_mask */
 341          0xffff,                /* dst_mask */
 342          FALSE),                /* pcrel_offset */
 343
 344   /* Bits 16-31 of an address.  */
 345   HOWTO (R_PPC64_ADDR16_HI,     /* type */
 346          16,                    /* rightshift */
 347          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 348          16,                    /* bitsize */
 349          FALSE,                 /* pc_relative */
 350          0,                     /* bitpos */
 351          complain_overflow_signed, /* complain_on_overflow */
 352          bfd_elf_generic_reloc, /* special_function */
 353          "R_PPC64_ADDR16_HI",   /* name */
 354          FALSE,                 /* partial_inplace */
 355          0,                     /* src_mask */
 356          0xffff,                /* dst_mask */
 357          FALSE),                /* pcrel_offset */
 358
 359   /* Bits 16-31 of an address, plus 1 if the contents of the low 16
 360      bits, treated as a signed number, is negative.  */
 361   HOWTO (R_PPC64_ADDR16_HA,     /* type */
 362          16,                    /* rightshift */
 363          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 364          16,                    /* bitsize */
 365          FALSE,                 /* pc_relative */
 366          0,                     /* bitpos */
 367          complain_overflow_signed, /* complain_on_overflow */
 368          ppc64_elf_ha_reloc,    /* special_function */
 369          "R_PPC64_ADDR16_HA",   /* name */
 370          FALSE,                 /* partial_inplace */
 371          0,                     /* src_mask */
 372          0xffff,                /* dst_mask */
 373          FALSE),                /* pcrel_offset */
 374
 375   /* An absolute 16 bit branch; the lower two bits must be zero.
 376      FIXME: we don't check that, we just clear them.  */
 377   HOWTO (R_PPC64_ADDR14,        /* type */
 378          0,                     /* rightshift */
 379          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 380          16,                    /* bitsize */
 381          FALSE,                 /* pc_relative */
 382          0,                     /* bitpos */
 383          complain_overflow_signed, /* complain_on_overflow */
 384          ppc64_elf_branch_reloc, /* special_function */
 385          "R_PPC64_ADDR14",      /* name */
 386          FALSE,                 /* partial_inplace */
 387          0,                     /* src_mask */
 388          0x0000fffc,            /* dst_mask */
 389          FALSE),                /* pcrel_offset */
 390
 391   /* An absolute 16 bit branch, for which bit 10 should be set to
 392      indicate that the branch is expected to be taken.  The lower two
 393      bits must be zero.  */
 394   HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
 395          0,                     /* rightshift */
 396          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 397          16,                    /* bitsize */
 398          FALSE,                 /* pc_relative */
 399          0,                     /* bitpos */
 400          complain_overflow_signed, /* complain_on_overflow */
 401          ppc64_elf_brtaken_reloc, /* special_function */
 402          "R_PPC64_ADDR14_BRTAKEN",/* name */
 403          FALSE,                 /* partial_inplace */
 404          0,                     /* src_mask */
 405          0x0000fffc,            /* dst_mask */
 406          FALSE),                /* pcrel_offset */
 407
 408   /* An absolute 16 bit branch, for which bit 10 should be set to
 409      indicate that the branch is not expected to be taken.  The lower
 410      two bits must be zero.  */
 411   HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
 412          0,                     /* rightshift */
 413          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 414          16,                    /* bitsize */
 415          FALSE,                 /* pc_relative */
 416          0,                     /* bitpos */
 417          complain_overflow_signed, /* complain_on_overflow */
 418          ppc64_elf_brtaken_reloc, /* special_function */
 419          "R_PPC64_ADDR14_BRNTAKEN",/* name */
 420          FALSE,                 /* partial_inplace */
 421          0,                     /* src_mask */
 422          0x0000fffc,            /* dst_mask */
 423          FALSE),                /* pcrel_offset */
 424
 425   /* A relative 26 bit branch; the lower two bits must be zero.  */
 426   HOWTO (R_PPC64_REL24,         /* type */
 427          0,                     /* rightshift */
 428          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 429          26,                    /* bitsize */
 430          TRUE,                  /* pc_relative */
 431          0,                     /* bitpos */
 432          complain_overflow_signed, /* complain_on_overflow */
 433          ppc64_elf_branch_reloc, /* special_function */
 434          "R_PPC64_REL24",       /* name */
 435          FALSE,                 /* partial_inplace */
 436          0,                     /* src_mask */
 437          0x03fffffc,            /* dst_mask */
 438          TRUE),                 /* pcrel_offset */
 439
 440   /* A relative 16 bit branch; the lower two bits must be zero.  */
 441   HOWTO (R_PPC64_REL14,         /* type */
 442          0,                     /* rightshift */
 443          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 444          16,                    /* bitsize */
 445          TRUE,                  /* pc_relative */
 446          0,                     /* bitpos */
 447          complain_overflow_signed, /* complain_on_overflow */
 448          ppc64_elf_branch_reloc, /* special_function */
 449          "R_PPC64_REL14",       /* name */
 450          FALSE,                 /* partial_inplace */
 451          0,                     /* src_mask */
 452          0x0000fffc,            /* dst_mask */
 453          TRUE),                 /* pcrel_offset */
 454
 455   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 456      the branch is expected to be taken.  The lower two bits must be
 457      zero.  */
 458   HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
 459          0,                     /* rightshift */
 460          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 461          16,                    /* bitsize */
 462          TRUE,                  /* pc_relative */
 463          0,                     /* bitpos */
 464          complain_overflow_signed, /* complain_on_overflow */
 465          ppc64_elf_brtaken_reloc, /* special_function */
 466          "R_PPC64_REL14_BRTAKEN", /* name */
 467          FALSE,                 /* partial_inplace */
 468          0,                     /* src_mask */
 469          0x0000fffc,            /* dst_mask */
 470          TRUE),                 /* pcrel_offset */
 471
 472   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 473      the branch is not expected to be taken.  The lower two bits must
 474      be zero.  */
 475   HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
 476          0,                     /* rightshift */
 477          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 478          16,                    /* bitsize */
 479          TRUE,                  /* pc_relative */
 480          0,                     /* bitpos */
 481          complain_overflow_signed, /* complain_on_overflow */
 482          ppc64_elf_brtaken_reloc, /* special_function */
 483          "R_PPC64_REL14_BRNTAKEN",/* name */
 484          FALSE,                 /* partial_inplace */
 485          0,                     /* src_mask */
 486          0x0000fffc,            /* dst_mask */
 487          TRUE),                 /* pcrel_offset */
 488
 489   /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
 490      symbol.  */
 491   HOWTO (R_PPC64_GOT16,         /* type */
 492          0,                     /* rightshift */
 493          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 494          16,                    /* bitsize */
 495          FALSE,                 /* pc_relative */
 496          0,                     /* bitpos */
 497          complain_overflow_signed, /* complain_on_overflow */
 498          ppc64_elf_unhandled_reloc, /* special_function */
 499          "R_PPC64_GOT16",       /* name */
 500          FALSE,                 /* partial_inplace */
 501          0,                     /* src_mask */
 502          0xffff,                /* dst_mask */
 503          FALSE),                /* pcrel_offset */
 504
 505   /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
 506      the symbol.  */
 507   HOWTO (R_PPC64_GOT16_LO,      /* type */
 508          0,                     /* rightshift */
 509          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 510          16,                    /* bitsize */
 511          FALSE,                 /* pc_relative */
 512          0,                     /* bitpos */
 513          complain_overflow_dont, /* complain_on_overflow */
 514          ppc64_elf_unhandled_reloc, /* special_function */
 515          "R_PPC64_GOT16_LO",    /* name */
 516          FALSE,                 /* partial_inplace */
 517          0,                     /* src_mask */
 518          0xffff,                /* dst_mask */
 519          FALSE),                /* pcrel_offset */
 520
 521   /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
 522      the symbol.  */
 523   HOWTO (R_PPC64_GOT16_HI,      /* type */
 524          16,                    /* rightshift */
 525          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 526          16,                    /* bitsize */
 527          FALSE,                 /* pc_relative */
 528          0,                     /* bitpos */
 529          complain_overflow_signed,/* complain_on_overflow */
 530          ppc64_elf_unhandled_reloc, /* special_function */
 531          "R_PPC64_GOT16_HI",    /* name */
 532          FALSE,                 /* partial_inplace */
 533          0,                     /* src_mask */
 534          0xffff,                /* dst_mask */
 535          FALSE),                /* pcrel_offset */
 536
 537   /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
 538      the symbol.  */
 539   HOWTO (R_PPC64_GOT16_HA,      /* type */
 540          16,                    /* rightshift */
 541          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 542          16,                    /* bitsize */
 543          FALSE,                 /* pc_relative */
 544          0,                     /* bitpos */
 545          complain_overflow_signed,/* complain_on_overflow */
 546          ppc64_elf_unhandled_reloc, /* special_function */
 547          "R_PPC64_GOT16_HA",    /* name */
 548          FALSE,                 /* partial_inplace */
 549          0,                     /* src_mask */
 550          0xffff,                /* dst_mask */
 551          FALSE),                /* pcrel_offset */
 552
 553   /* This is used only by the dynamic linker.  The symbol should exist
 554      both in the object being run and in some shared library.  The
 555      dynamic linker copies the data addressed by the symbol from the
 556      shared library into the object, because the object being
 557      run has to have the data at some particular address.  */
 558   HOWTO (R_PPC64_COPY,          /* type */
 559          0,                     /* rightshift */
 560          0,                     /* this one is variable size */
 561          0,                     /* bitsize */
 562          FALSE,                 /* pc_relative */
 563          0,                     /* bitpos */
 564          complain_overflow_dont, /* complain_on_overflow */
 565          ppc64_elf_unhandled_reloc, /* special_function */
 566          "R_PPC64_COPY",        /* name */
 567          FALSE,                 /* partial_inplace */
 568          0,                     /* src_mask */
 569          0,                     /* dst_mask */
 570          FALSE),                /* pcrel_offset */
 571
 572   /* Like R_PPC64_ADDR64, but used when setting global offset table
 573      entries.  */
 574   HOWTO (R_PPC64_GLOB_DAT,      /* type */
 575          0,                     /* rightshift */
 576          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 577          64,                    /* bitsize */
 578          FALSE,                 /* pc_relative */
 579          0,                     /* bitpos */
 580          complain_overflow_dont, /* complain_on_overflow */
 581          ppc64_elf_unhandled_reloc,  /* special_function */
 582          "R_PPC64_GLOB_DAT",    /* name */
 583          FALSE,                 /* partial_inplace */
 584          0,                     /* src_mask */
 585          ONES (64),             /* dst_mask */
 586          FALSE),                /* pcrel_offset */
 587
 588   /* Created by the link editor.  Marks a procedure linkage table
 589      entry for a symbol.  */
 590   HOWTO (R_PPC64_JMP_SLOT,      /* type */
 591          0,                     /* rightshift */
 592          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 593          0,                     /* bitsize */
 594          FALSE,                 /* pc_relative */
 595          0,                     /* bitpos */
 596          complain_overflow_dont, /* complain_on_overflow */
 597          ppc64_elf_unhandled_reloc, /* special_function */
 598          "R_PPC64_JMP_SLOT",    /* name */
 599          FALSE,                 /* partial_inplace */
 600          0,                     /* src_mask */
 601          0,                     /* dst_mask */
 602          FALSE),                /* pcrel_offset */
 603
 604   /* Used only by the dynamic linker.  When the object is run, this
 605      doubleword64 is set to the load address of the object, plus the
 606      addend.  */
 607   HOWTO (R_PPC64_RELATIVE,      /* type */
 608          0,                     /* rightshift */
 609          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 610          64,                    /* bitsize */
 611          FALSE,                 /* pc_relative */
 612          0,                     /* bitpos */
 613          complain_overflow_dont, /* complain_on_overflow */
 614          bfd_elf_generic_reloc, /* special_function */
 615          "R_PPC64_RELATIVE",    /* name */
 616          FALSE,                 /* partial_inplace */
 617          0,                     /* src_mask */
 618          ONES (64),             /* dst_mask */
 619          FALSE),                /* pcrel_offset */
 620
 621   /* Like R_PPC64_ADDR32, but may be unaligned.  */
 622   HOWTO (R_PPC64_UADDR32,       /* type */
 623          0,                     /* rightshift */
 624          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 625          32,                    /* bitsize */
 626          FALSE,                 /* pc_relative */
 627          0,                     /* bitpos */
 628          complain_overflow_bitfield, /* complain_on_overflow */
 629          bfd_elf_generic_reloc, /* special_function */
 630          "R_PPC64_UADDR32",     /* name */
 631          FALSE,                 /* partial_inplace */
 632          0,                     /* src_mask */
 633          0xffffffff,            /* dst_mask */
 634          FALSE),                /* pcrel_offset */
 635
 636   /* Like R_PPC64_ADDR16, but may be unaligned.  */
 637   HOWTO (R_PPC64_UADDR16,       /* type */
 638          0,                     /* rightshift */
 639          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 640          16,                    /* bitsize */
 641          FALSE,                 /* pc_relative */
 642          0,                     /* bitpos */
 643          complain_overflow_bitfield, /* complain_on_overflow */
 644          bfd_elf_generic_reloc, /* special_function */
 645          "R_PPC64_UADDR16",     /* name */
 646          FALSE,                 /* partial_inplace */
 647          0,                     /* src_mask */
 648          0xffff,                /* dst_mask */
 649          FALSE),                /* pcrel_offset */
 650
 651   /* 32-bit PC relative.  */
 652   HOWTO (R_PPC64_REL32,         /* type */
 653          0,                     /* rightshift */
 654          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 655          32,                    /* bitsize */
 656          TRUE,                  /* pc_relative */
 657          0,                     /* bitpos */
 658          complain_overflow_signed, /* complain_on_overflow */
 659          bfd_elf_generic_reloc, /* special_function */
 660          "R_PPC64_REL32",       /* name */
 661          FALSE,                 /* partial_inplace */
 662          0,                     /* src_mask */
 663          0xffffffff,            /* dst_mask */
 664          TRUE),                 /* pcrel_offset */
 665
 666   /* 32-bit relocation to the symbol's procedure linkage table.  */
 667   HOWTO (R_PPC64_PLT32,         /* type */
 668          0,                     /* rightshift */
 669          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 670          32,                    /* bitsize */
 671          FALSE,                 /* pc_relative */
 672          0,                     /* bitpos */
 673          complain_overflow_bitfield, /* complain_on_overflow */
 674          ppc64_elf_unhandled_reloc, /* special_function */
 675          "R_PPC64_PLT32",       /* name */
 676          FALSE,                 /* partial_inplace */
 677          0,                     /* src_mask */
 678          0xffffffff,            /* dst_mask */
 679          FALSE),                /* pcrel_offset */
 680
 681   /* 32-bit PC relative relocation to the symbol's procedure linkage table.
 682      FIXME: R_PPC64_PLTREL32 not supported.  */
 683   HOWTO (R_PPC64_PLTREL32,      /* type */
 684          0,                     /* rightshift */
 685          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 686          32,                    /* bitsize */
 687          TRUE,                  /* pc_relative */
 688          0,                     /* bitpos */
 689          complain_overflow_signed, /* complain_on_overflow */
 690          bfd_elf_generic_reloc, /* special_function */
 691          "R_PPC64_PLTREL32",    /* name */
 692          FALSE,                 /* partial_inplace */
 693          0,                     /* src_mask */
 694          0xffffffff,            /* dst_mask */
 695          TRUE),                 /* pcrel_offset */
 696
 697   /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
 698      the symbol.  */
 699   HOWTO (R_PPC64_PLT16_LO,      /* type */
 700          0,                     /* rightshift */
 701          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 702          16,                    /* bitsize */
 703          FALSE,                 /* pc_relative */
 704          0,                     /* bitpos */
 705          complain_overflow_dont, /* complain_on_overflow */
 706          ppc64_elf_unhandled_reloc, /* special_function */
 707          "R_PPC64_PLT16_LO",    /* name */
 708          FALSE,                 /* partial_inplace */
 709          0,                     /* src_mask */
 710          0xffff,                /* dst_mask */
 711          FALSE),                /* pcrel_offset */
 712
 713   /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
 714      the symbol.  */
 715   HOWTO (R_PPC64_PLT16_HI,      /* type */
 716          16,                    /* rightshift */
 717          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 718          16,                    /* bitsize */
 719          FALSE,                 /* pc_relative */
 720          0,                     /* bitpos */
 721          complain_overflow_signed, /* complain_on_overflow */
 722          ppc64_elf_unhandled_reloc, /* special_function */
 723          "R_PPC64_PLT16_HI",    /* name */
 724          FALSE,                 /* partial_inplace */
 725          0,                     /* src_mask */
 726          0xffff,                /* dst_mask */
 727          FALSE),                /* pcrel_offset */
 728
 729   /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
 730      the symbol.  */
 731   HOWTO (R_PPC64_PLT16_HA,      /* type */
 732          16,                    /* rightshift */
 733          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 734          16,                    /* bitsize */
 735          FALSE,                 /* pc_relative */
 736          0,                     /* bitpos */
 737          complain_overflow_signed, /* complain_on_overflow */
 738          ppc64_elf_unhandled_reloc, /* special_function */
 739          "R_PPC64_PLT16_HA",    /* name */
 740          FALSE,                 /* partial_inplace */
 741          0,                     /* src_mask */
 742          0xffff,                /* dst_mask */
 743          FALSE),                /* pcrel_offset */
 744
 745   /* 16-bit section relative relocation.  */
 746   HOWTO (R_PPC64_SECTOFF,       /* type */
 747          0,                     /* rightshift */
 748          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 749          16,                    /* bitsize */
 750          FALSE,                 /* pc_relative */
 751          0,                     /* bitpos */
 752          complain_overflow_signed, /* complain_on_overflow */
 753          ppc64_elf_sectoff_reloc, /* special_function */
 754          "R_PPC64_SECTOFF",     /* name */
 755          FALSE,                 /* partial_inplace */
 756          0,                     /* src_mask */
 757          0xffff,                /* dst_mask */
 758          FALSE),                /* pcrel_offset */
 759
 760   /* Like R_PPC64_SECTOFF, but no overflow warning.  */
 761   HOWTO (R_PPC64_SECTOFF_LO,    /* type */
 762          0,                     /* rightshift */
 763          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 764          16,                    /* bitsize */
 765          FALSE,                 /* pc_relative */
 766          0,                     /* bitpos */
 767          complain_overflow_dont, /* complain_on_overflow */
 768          ppc64_elf_sectoff_reloc, /* special_function */
 769          "R_PPC64_SECTOFF_LO",  /* name */
 770          FALSE,                 /* partial_inplace */
 771          0,                     /* src_mask */
 772          0xffff,                /* dst_mask */
 773          FALSE),                /* pcrel_offset */
 774
 775   /* 16-bit upper half section relative relocation.  */
 776   HOWTO (R_PPC64_SECTOFF_HI,    /* type */
 777          16,                    /* rightshift */
 778          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 779          16,                    /* bitsize */
 780          FALSE,                 /* pc_relative */
 781          0,                     /* bitpos */
 782          complain_overflow_signed, /* complain_on_overflow */
 783          ppc64_elf_sectoff_reloc, /* special_function */
 784          "R_PPC64_SECTOFF_HI",  /* name */
 785          FALSE,                 /* partial_inplace */
 786          0,                     /* src_mask */
 787          0xffff,                /* dst_mask */
 788          FALSE),                /* pcrel_offset */
 789
 790   /* 16-bit upper half adjusted section relative relocation.  */
 791   HOWTO (R_PPC64_SECTOFF_HA,    /* type */
 792          16,                    /* rightshift */
 793          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 794          16,                    /* bitsize */
 795          FALSE,                 /* pc_relative */
 796          0,                     /* bitpos */
 797          complain_overflow_signed, /* complain_on_overflow */
 798          ppc64_elf_sectoff_ha_reloc, /* special_function */
 799          "R_PPC64_SECTOFF_HA",  /* name */
 800          FALSE,                 /* partial_inplace */
 801          0,                     /* src_mask */
 802          0xffff,                /* dst_mask */
 803          FALSE),                /* pcrel_offset */
 804
 805   /* Like R_PPC64_REL24 without touching the two least significant bits.  */
 806   HOWTO (R_PPC64_REL30,         /* type */
 807          2,                     /* rightshift */
 808          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 809          30,                    /* bitsize */
 810          TRUE,                  /* pc_relative */
 811          0,                     /* bitpos */
 812          complain_overflow_dont, /* complain_on_overflow */
 813          bfd_elf_generic_reloc, /* special_function */
 814          "R_PPC64_REL30",       /* name */
 815          FALSE,                 /* partial_inplace */
 816          0,                     /* src_mask */
 817          0xfffffffc,            /* dst_mask */
 818          TRUE),                 /* pcrel_offset */
 819
 820   /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI.  */
 821
 822   /* A standard 64-bit relocation.  */
 823   HOWTO (R_PPC64_ADDR64,        /* type */
 824          0,                     /* rightshift */
 825          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 826          64,                    /* bitsize */
 827          FALSE,                 /* pc_relative */
 828          0,                     /* bitpos */
 829          complain_overflow_dont, /* complain_on_overflow */
 830          bfd_elf_generic_reloc, /* special_function */
 831          "R_PPC64_ADDR64",      /* name */
 832          FALSE,                 /* partial_inplace */
 833          0,                     /* src_mask */
 834          ONES (64),             /* dst_mask */
 835          FALSE),                /* pcrel_offset */
 836
 837   /* The bits 32-47 of an address.  */
 838   HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
 839          32,                    /* rightshift */
 840          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 841          16,                    /* bitsize */
 842          FALSE,                 /* pc_relative */
 843          0,                     /* bitpos */
 844          complain_overflow_dont, /* complain_on_overflow */
 845          bfd_elf_generic_reloc, /* special_function */
 846          "R_PPC64_ADDR16_HIGHER", /* name */
 847          FALSE,                 /* partial_inplace */
 848          0,                     /* src_mask */
 849          0xffff,                /* dst_mask */
 850          FALSE),                /* pcrel_offset */
 851
 852   /* The bits 32-47 of an address, plus 1 if the contents of the low
 853      16 bits, treated as a signed number, is negative.  */
 854   HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
 855          32,                    /* rightshift */
 856          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 857          16,                    /* bitsize */
 858          FALSE,                 /* pc_relative */
 859          0,                     /* bitpos */
 860          complain_overflow_dont, /* complain_on_overflow */
 861          ppc64_elf_ha_reloc,    /* special_function */
 862          "R_PPC64_ADDR16_HIGHERA", /* name */
 863          FALSE,                 /* partial_inplace */
 864          0,                     /* src_mask */
 865          0xffff,                /* dst_mask */
 866          FALSE),                /* pcrel_offset */
 867
 868   /* The bits 48-63 of an address.  */
 869   HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
 870          48,                    /* rightshift */
 871          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 872          16,                    /* bitsize */
 873          FALSE,                 /* pc_relative */
 874          0,                     /* bitpos */
 875          complain_overflow_dont, /* complain_on_overflow */
 876          bfd_elf_generic_reloc, /* special_function */
 877          "R_PPC64_ADDR16_HIGHEST", /* name */
 878          FALSE,                 /* partial_inplace */
 879          0,                     /* src_mask */
 880          0xffff,                /* dst_mask */
 881          FALSE),                /* pcrel_offset */
 882
 883   /* The bits 48-63 of an address, plus 1 if the contents of the low
 884      16 bits, treated as a signed number, is negative.  */
 885   HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
 886          48,                    /* rightshift */
 887          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 888          16,                    /* bitsize */
 889          FALSE,                 /* pc_relative */
 890          0,                     /* bitpos */
 891          complain_overflow_dont, /* complain_on_overflow */
 892          ppc64_elf_ha_reloc,    /* special_function */
 893          "R_PPC64_ADDR16_HIGHESTA", /* name */
 894          FALSE,                 /* partial_inplace */
 895          0,                     /* src_mask */
 896          0xffff,                /* dst_mask */
 897          FALSE),                /* pcrel_offset */
 898
 899   /* Like ADDR64, but may be unaligned.  */
 900   HOWTO (R_PPC64_UADDR64,       /* type */
 901          0,                     /* rightshift */
 902          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 903          64,                    /* bitsize */
 904          FALSE,                 /* pc_relative */
 905          0,                     /* bitpos */
 906          complain_overflow_dont, /* complain_on_overflow */
 907          bfd_elf_generic_reloc, /* special_function */
 908          "R_PPC64_UADDR64",     /* name */
 909          FALSE,                 /* partial_inplace */
 910          0,                     /* src_mask */
 911          ONES (64),             /* dst_mask */
 912          FALSE),                /* pcrel_offset */
 913
 914   /* 64-bit relative relocation.  */
 915   HOWTO (R_PPC64_REL64,         /* type */
 916          0,                     /* rightshift */
 917          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 918          64,                    /* bitsize */
 919          TRUE,                  /* pc_relative */
 920          0,                     /* bitpos */
 921          complain_overflow_dont, /* complain_on_overflow */
 922          bfd_elf_generic_reloc, /* special_function */
 923          "R_PPC64_REL64",       /* name */
 924          FALSE,                 /* partial_inplace */
 925          0,                     /* src_mask */
 926          ONES (64),             /* dst_mask */
 927          TRUE),                 /* pcrel_offset */
 928
 929   /* 64-bit relocation to the symbol's procedure linkage table.  */
 930   HOWTO (R_PPC64_PLT64,         /* type */
 931          0,                     /* rightshift */
 932          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 933          64,                    /* bitsize */
 934          FALSE,                 /* pc_relative */
 935          0,                     /* bitpos */
 936          complain_overflow_dont, /* complain_on_overflow */
 937          ppc64_elf_unhandled_reloc, /* special_function */
 938          "R_PPC64_PLT64",       /* name */
 939          FALSE,                 /* partial_inplace */
 940          0,                     /* src_mask */
 941          ONES (64),             /* dst_mask */
 942          FALSE),                /* pcrel_offset */
 943
 944   /* 64-bit PC relative relocation to the symbol's procedure linkage
 945      table.  */
 946   /* FIXME: R_PPC64_PLTREL64 not supported.  */
 947   HOWTO (R_PPC64_PLTREL64,      /* type */
 948          0,                     /* rightshift */
 949          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 950          64,                    /* bitsize */
 951          TRUE,                  /* pc_relative */
 952          0,                     /* bitpos */
 953          complain_overflow_dont, /* complain_on_overflow */
 954          ppc64_elf_unhandled_reloc, /* special_function */
 955          "R_PPC64_PLTREL64",    /* name */
 956          FALSE,                 /* partial_inplace */
 957          0,                     /* src_mask */
 958          ONES (64),             /* dst_mask */
 959          TRUE),                 /* pcrel_offset */
 960
 961   /* 16 bit TOC-relative relocation.  */
 962
 963   /* R_PPC64_TOC16        47       half16*      S + A - .TOC.  */
 964   HOWTO (R_PPC64_TOC16,         /* type */
 965          0,                     /* rightshift */
 966          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 967          16,                    /* bitsize */
 968          FALSE,                 /* pc_relative */
 969          0,                     /* bitpos */
 970          complain_overflow_signed, /* complain_on_overflow */
 971          ppc64_elf_toc_reloc,   /* special_function */
 972          "R_PPC64_TOC16",       /* name */
 973          FALSE,                 /* partial_inplace */
 974          0,                     /* src_mask */
 975          0xffff,                /* dst_mask */
 976          FALSE),                /* pcrel_offset */
 977
 978   /* 16 bit TOC-relative relocation without overflow.  */
 979
 980   /* R_PPC64_TOC16_LO     48       half16        #lo (S + A - .TOC.)  */
 981   HOWTO (R_PPC64_TOC16_LO,      /* type */
 982          0,                     /* rightshift */
 983          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 984          16,                    /* bitsize */
 985          FALSE,                 /* pc_relative */
 986          0,                     /* bitpos */
 987          complain_overflow_dont, /* complain_on_overflow */
 988          ppc64_elf_toc_reloc,   /* special_function */
 989          "R_PPC64_TOC16_LO",    /* name */
 990          FALSE,                 /* partial_inplace */
 991          0,                     /* src_mask */
 992          0xffff,                /* dst_mask */
 993          FALSE),                /* pcrel_offset */
 994
 995   /* 16 bit TOC-relative relocation, high 16 bits.  */
 996
 997   /* R_PPC64_TOC16_HI     49       half16        #hi (S + A - .TOC.)  */
 998   HOWTO (R_PPC64_TOC16_HI,      /* type */
 999          16,                    /* rightshift */
1000          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1001          16,                    /* bitsize */
1002          FALSE,                 /* pc_relative */
1003          0,                     /* bitpos */
1004          complain_overflow_signed, /* complain_on_overflow */
1005          ppc64_elf_toc_reloc,   /* special_function */
1006          "R_PPC64_TOC16_HI",    /* name */
1007          FALSE,                 /* partial_inplace */
1008          0,                     /* src_mask */
1009          0xffff,                /* dst_mask */
1010          FALSE),                /* pcrel_offset */
1011
1012   /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
1013      contents of the low 16 bits, treated as a signed number, is
1014      negative.  */
1015
1016   /* R_PPC64_TOC16_HA     50       half16        #ha (S + A - .TOC.)  */
1017   HOWTO (R_PPC64_TOC16_HA,      /* type */
1018          16,                    /* rightshift */
1019          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1020          16,                    /* bitsize */
1021          FALSE,                 /* pc_relative */
1022          0,                     /* bitpos */
1023          complain_overflow_signed, /* complain_on_overflow */
1024          ppc64_elf_toc_ha_reloc, /* special_function */
1025          "R_PPC64_TOC16_HA",    /* name */
1026          FALSE,                 /* partial_inplace */
1027          0,                     /* src_mask */
1028          0xffff,                /* dst_mask */
1029          FALSE),                /* pcrel_offset */
1030
1031   /* 64-bit relocation; insert value of TOC base (.TOC.).  */
1032
1033   /* R_PPC64_TOC                  51       doubleword64  .TOC.  */
1034   HOWTO (R_PPC64_TOC,           /* type */
1035          0,                     /* rightshift */
1036          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1037          64,                    /* bitsize */
1038          FALSE,                 /* pc_relative */
1039          0,                     /* bitpos */
1040          complain_overflow_dont, /* complain_on_overflow */
1041          ppc64_elf_toc64_reloc, /* special_function */
1042          "R_PPC64_TOC",         /* name */
1043          FALSE,                 /* partial_inplace */
1044          0,                     /* src_mask */
1045          ONES (64),             /* dst_mask */
1046          FALSE),                /* pcrel_offset */
1047
1048   /* Like R_PPC64_GOT16, but also informs the link editor that the
1049      value to relocate may (!) refer to a PLT entry which the link
1050      editor (a) may replace with the symbol value.  If the link editor
1051      is unable to fully resolve the symbol, it may (b) create a PLT
1052      entry and store the address to the new PLT entry in the GOT.
1053      This permits lazy resolution of function symbols at run time.
1054      The link editor may also skip all of this and just (c) emit a
1055      R_PPC64_GLOB_DAT to tie the symbol to the GOT entry.  */
1056   /* FIXME: R_PPC64_PLTGOT16 not implemented.  */
1057     HOWTO (R_PPC64_PLTGOT16,    /* type */
1058          0,                     /* rightshift */
1059          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1060          16,                    /* bitsize */
1061          FALSE,                 /* pc_relative */
1062          0,                     /* bitpos */
1063          complain_overflow_signed, /* complain_on_overflow */
1064          ppc64_elf_unhandled_reloc, /* special_function */
1065          "R_PPC64_PLTGOT16",    /* name */
1066          FALSE,                 /* partial_inplace */
1067          0,                     /* src_mask */
1068          0xffff,                /* dst_mask */
1069          FALSE),                /* pcrel_offset */
1070
1071   /* Like R_PPC64_PLTGOT16, but without overflow.  */
1072   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1073   HOWTO (R_PPC64_PLTGOT16_LO,   /* type */
1074          0,                     /* rightshift */
1075          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1076          16,                    /* bitsize */
1077          FALSE,                 /* pc_relative */
1078          0,                     /* bitpos */
1079          complain_overflow_dont, /* complain_on_overflow */
1080          ppc64_elf_unhandled_reloc, /* special_function */
1081          "R_PPC64_PLTGOT16_LO", /* name */
1082          FALSE,                 /* partial_inplace */
1083          0,                     /* src_mask */
1084          0xffff,                /* dst_mask */
1085          FALSE),                /* pcrel_offset */
1086
1087   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address.  */
1088   /* FIXME: R_PPC64_PLTGOT16_HI not implemented.  */
1089   HOWTO (R_PPC64_PLTGOT16_HI,   /* type */
1090          16,                    /* rightshift */
1091          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1092          16,                    /* bitsize */
1093          FALSE,                 /* pc_relative */
1094          0,                     /* bitpos */
1095          complain_overflow_signed, /* complain_on_overflow */
1096          ppc64_elf_unhandled_reloc, /* special_function */
1097          "R_PPC64_PLTGOT16_HI", /* name */
1098          FALSE,                 /* partial_inplace */
1099          0,                     /* src_mask */
1100          0xffff,                /* dst_mask */
1101          FALSE),                /* pcrel_offset */
1102
1103   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1104      1 if the contents of the low 16 bits, treated as a signed number,
1105      is negative.  */
1106   /* FIXME: R_PPC64_PLTGOT16_HA not implemented.  */
1107   HOWTO (R_PPC64_PLTGOT16_HA,   /* type */
1108          16,                    /* rightshift */
1109          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1110          16,                    /* bitsize */
1111          FALSE,                 /* pc_relative */
1112          0,                     /* bitpos */
1113          complain_overflow_signed, /* complain_on_overflow */
1114          ppc64_elf_unhandled_reloc, /* special_function */
1115          "R_PPC64_PLTGOT16_HA", /* name */
1116          FALSE,                 /* partial_inplace */
1117          0,                     /* src_mask */
1118          0xffff,                /* dst_mask */
1119          FALSE),                /* pcrel_offset */
1120
1121   /* Like R_PPC64_ADDR16, but for instructions with a DS field.  */
1122   HOWTO (R_PPC64_ADDR16_DS,     /* type */
1123          0,                     /* rightshift */
1124          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1125          16,                    /* bitsize */
1126          FALSE,                 /* pc_relative */
1127          0,                     /* bitpos */
1128          complain_overflow_signed, /* complain_on_overflow */
1129          bfd_elf_generic_reloc, /* special_function */
1130          "R_PPC64_ADDR16_DS",   /* name */
1131          FALSE,                 /* partial_inplace */
1132          0,                     /* src_mask */
1133          0xfffc,                /* dst_mask */
1134          FALSE),                /* pcrel_offset */
1135
1136   /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field.  */
1137   HOWTO (R_PPC64_ADDR16_LO_DS,  /* type */
1138          0,                     /* rightshift */
1139          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1140          16,                    /* bitsize */
1141          FALSE,                 /* pc_relative */
1142          0,                     /* bitpos */
1143          complain_overflow_dont,/* complain_on_overflow */
1144          bfd_elf_generic_reloc, /* special_function */
1145          "R_PPC64_ADDR16_LO_DS",/* name */
1146          FALSE,                 /* partial_inplace */
1147          0,                     /* src_mask */
1148          0xfffc,                /* dst_mask */
1149          FALSE),                /* pcrel_offset */
1150
1151   /* Like R_PPC64_GOT16, but for instructions with a DS field.  */
1152   HOWTO (R_PPC64_GOT16_DS,      /* type */
1153          0,                     /* rightshift */
1154          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1155          16,                    /* bitsize */
1156          FALSE,                 /* pc_relative */
1157          0,                     /* bitpos */
1158          complain_overflow_signed, /* complain_on_overflow */
1159          ppc64_elf_unhandled_reloc, /* special_function */
1160          "R_PPC64_GOT16_DS",    /* name */
1161          FALSE,                 /* partial_inplace */
1162          0,                     /* src_mask */
1163          0xfffc,                /* dst_mask */
1164          FALSE),                /* pcrel_offset */
1165
1166   /* Like R_PPC64_GOT16_LO, but for instructions with a DS field.  */
1167   HOWTO (R_PPC64_GOT16_LO_DS,   /* type */
1168          0,                     /* rightshift */
1169          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1170          16,                    /* bitsize */
1171          FALSE,                 /* pc_relative */
1172          0,                     /* bitpos */
1173          complain_overflow_dont, /* complain_on_overflow */
1174          ppc64_elf_unhandled_reloc, /* special_function */
1175          "R_PPC64_GOT16_LO_DS", /* name */
1176          FALSE,                 /* partial_inplace */
1177          0,                     /* src_mask */
1178          0xfffc,                /* dst_mask */
1179          FALSE),                /* pcrel_offset */
1180
1181   /* Like R_PPC64_PLT16_LO, but for instructions with a DS field.  */
1182   HOWTO (R_PPC64_PLT16_LO_DS,   /* type */
1183          0,                     /* rightshift */
1184          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1185          16,                    /* bitsize */
1186          FALSE,                 /* pc_relative */
1187          0,                     /* bitpos */
1188          complain_overflow_dont, /* complain_on_overflow */
1189          ppc64_elf_unhandled_reloc, /* special_function */
1190          "R_PPC64_PLT16_LO_DS", /* name */
1191          FALSE,                 /* partial_inplace */
1192          0,                     /* src_mask */
1193          0xfffc,                /* dst_mask */
1194          FALSE),                /* pcrel_offset */
1195
1196   /* Like R_PPC64_SECTOFF, but for instructions with a DS field.  */
1197   HOWTO (R_PPC64_SECTOFF_DS,    /* type */
1198          0,                     /* rightshift */
1199          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1200          16,                    /* bitsize */
1201          FALSE,                 /* pc_relative */
1202          0,                     /* bitpos */
1203          complain_overflow_signed, /* complain_on_overflow */
1204          ppc64_elf_sectoff_reloc, /* special_function */
1205          "R_PPC64_SECTOFF_DS",  /* name */
1206          FALSE,                 /* partial_inplace */
1207          0,                     /* src_mask */
1208          0xfffc,                /* dst_mask */
1209          FALSE),                /* pcrel_offset */
1210
1211   /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field.  */
1212   HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1213          0,                     /* rightshift */
1214          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1215          16,                    /* bitsize */
1216          FALSE,                 /* pc_relative */
1217          0,                     /* bitpos */
1218          complain_overflow_dont, /* complain_on_overflow */
1219          ppc64_elf_sectoff_reloc, /* special_function */
1220          "R_PPC64_SECTOFF_LO_DS",/* name */
1221          FALSE,                 /* partial_inplace */
1222          0,                     /* src_mask */
1223          0xfffc,                /* dst_mask */
1224          FALSE),                /* pcrel_offset */
1225
1226   /* Like R_PPC64_TOC16, but for instructions with a DS field.  */
1227   HOWTO (R_PPC64_TOC16_DS,      /* type */
1228          0,                     /* rightshift */
1229          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1230          16,                    /* bitsize */
1231          FALSE,                 /* pc_relative */
1232          0,                     /* bitpos */
1233          complain_overflow_signed, /* complain_on_overflow */
1234          ppc64_elf_toc_reloc,   /* special_function */
1235          "R_PPC64_TOC16_DS",    /* name */
1236          FALSE,                 /* partial_inplace */
1237          0,                     /* src_mask */
1238          0xfffc,                /* dst_mask */
1239          FALSE),                /* pcrel_offset */
1240
1241   /* Like R_PPC64_TOC16_LO, but for instructions with a DS field.  */
1242   HOWTO (R_PPC64_TOC16_LO_DS,   /* type */
1243          0,                     /* rightshift */
1244          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1245          16,                    /* bitsize */
1246          FALSE,                 /* pc_relative */
1247          0,                     /* bitpos */
1248          complain_overflow_dont, /* complain_on_overflow */
1249          ppc64_elf_toc_reloc,   /* special_function */
1250          "R_PPC64_TOC16_LO_DS", /* name */
1251          FALSE,                 /* partial_inplace */
1252          0,                     /* src_mask */
1253          0xfffc,                /* dst_mask */
1254          FALSE),                /* pcrel_offset */
1255
1256   /* Like R_PPC64_PLTGOT16, but for instructions with a DS field.  */
1257   /* FIXME: R_PPC64_PLTGOT16_DS not implemented.  */
1258   HOWTO (R_PPC64_PLTGOT16_DS,   /* type */
1259          0,                     /* rightshift */
1260          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1261          16,                    /* bitsize */
1262          FALSE,                 /* pc_relative */
1263          0,                     /* bitpos */
1264          complain_overflow_signed, /* complain_on_overflow */
1265          ppc64_elf_unhandled_reloc, /* special_function */
1266          "R_PPC64_PLTGOT16_DS", /* name */
1267          FALSE,                 /* partial_inplace */
1268          0,                     /* src_mask */
1269          0xfffc,                /* dst_mask */
1270          FALSE),                /* pcrel_offset */
1271
1272   /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field.  */
1273   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1274   HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1275          0,                     /* rightshift */
1276          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1277          16,                    /* bitsize */
1278          FALSE,                 /* pc_relative */
1279          0,                     /* bitpos */
1280          complain_overflow_dont, /* complain_on_overflow */
1281          ppc64_elf_unhandled_reloc, /* special_function */
1282          "R_PPC64_PLTGOT16_LO_DS",/* name */
1283          FALSE,                 /* partial_inplace */
1284          0,                     /* src_mask */
1285          0xfffc,                /* dst_mask */
1286          FALSE),                /* pcrel_offset */
1287
1288   /* Marker relocs for TLS.  */
1289   HOWTO (R_PPC64_TLS,
1290          0,                     /* rightshift */
1291          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1292          32,                    /* bitsize */
1293          FALSE,                 /* pc_relative */
1294          0,                     /* bitpos */
1295          complain_overflow_dont, /* complain_on_overflow */
1296          bfd_elf_generic_reloc, /* special_function */
1297          "R_PPC64_TLS",         /* name */
1298          FALSE,                 /* partial_inplace */
1299          0,                     /* src_mask */
1300          0,                     /* dst_mask */
1301          FALSE),                /* pcrel_offset */
1302
1303   HOWTO (R_PPC64_TLSGD,
1304          0,                     /* rightshift */
1305          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1306          32,                    /* bitsize */
1307          FALSE,                 /* pc_relative */
1308          0,                     /* bitpos */
1309          complain_overflow_dont, /* complain_on_overflow */
1310          bfd_elf_generic_reloc, /* special_function */
1311          "R_PPC64_TLSGD",       /* name */
1312          FALSE,                 /* partial_inplace */
1313          0,                     /* src_mask */
1314          0,                     /* dst_mask */
1315          FALSE),                /* pcrel_offset */
1316
1317   HOWTO (R_PPC64_TLSLD,
1318          0,                     /* rightshift */
1319          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1320          32,                    /* bitsize */
1321          FALSE,                 /* pc_relative */
1322          0,                     /* bitpos */
1323          complain_overflow_dont, /* complain_on_overflow */
1324          bfd_elf_generic_reloc, /* special_function */
1325          "R_PPC64_TLSLD",       /* name */
1326          FALSE,                 /* partial_inplace */
1327          0,                     /* src_mask */
1328          0,                     /* dst_mask */
1329          FALSE),                /* pcrel_offset */
1330
1331   HOWTO (R_PPC64_TOCSAVE,
1332          0,                     /* rightshift */
1333          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1334          32,                    /* bitsize */
1335          FALSE,                 /* pc_relative */
1336          0,                     /* bitpos */
1337          complain_overflow_dont, /* complain_on_overflow */
1338          bfd_elf_generic_reloc, /* special_function */
1339          "R_PPC64_TOCSAVE",     /* name */
1340          FALSE,                 /* partial_inplace */
1341          0,                     /* src_mask */
1342          0,                     /* dst_mask */
1343          FALSE),                /* pcrel_offset */
1344
1345   /* Computes the load module index of the load module that contains the
1346      definition of its TLS sym.  */
1347   HOWTO (R_PPC64_DTPMOD64,
1348          0,                     /* rightshift */
1349          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1350          64,                    /* bitsize */
1351          FALSE,                 /* pc_relative */
1352          0,                     /* bitpos */
1353          complain_overflow_dont, /* complain_on_overflow */
1354          ppc64_elf_unhandled_reloc, /* special_function */
1355          "R_PPC64_DTPMOD64",    /* name */
1356          FALSE,                 /* partial_inplace */
1357          0,                     /* src_mask */
1358          ONES (64),             /* dst_mask */
1359          FALSE),                /* pcrel_offset */
1360
1361   /* Computes a dtv-relative displacement, the difference between the value
1362      of sym+add and the base address of the thread-local storage block that
1363      contains the definition of sym, minus 0x8000.  */
1364   HOWTO (R_PPC64_DTPREL64,
1365          0,                     /* rightshift */
1366          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1367          64,                    /* bitsize */
1368          FALSE,                 /* pc_relative */
1369          0,                     /* bitpos */
1370          complain_overflow_dont, /* complain_on_overflow */
1371          ppc64_elf_unhandled_reloc, /* special_function */
1372          "R_PPC64_DTPREL64",    /* name */
1373          FALSE,                 /* partial_inplace */
1374          0,                     /* src_mask */
1375          ONES (64),             /* dst_mask */
1376          FALSE),                /* pcrel_offset */
1377
1378   /* A 16 bit dtprel reloc.  */
1379   HOWTO (R_PPC64_DTPREL16,
1380          0,                     /* rightshift */
1381          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1382          16,                    /* bitsize */
1383          FALSE,                 /* pc_relative */
1384          0,                     /* bitpos */
1385          complain_overflow_signed, /* complain_on_overflow */
1386          ppc64_elf_unhandled_reloc, /* special_function */
1387          "R_PPC64_DTPREL16",    /* name */
1388          FALSE,                 /* partial_inplace */
1389          0,                     /* src_mask */
1390          0xffff,                /* dst_mask */
1391          FALSE),                /* pcrel_offset */
1392
1393   /* Like DTPREL16, but no overflow.  */
1394   HOWTO (R_PPC64_DTPREL16_LO,
1395          0,                     /* rightshift */
1396          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1397          16,                    /* bitsize */
1398          FALSE,                 /* pc_relative */
1399          0,                     /* bitpos */
1400          complain_overflow_dont, /* complain_on_overflow */
1401          ppc64_elf_unhandled_reloc, /* special_function */
1402          "R_PPC64_DTPREL16_LO", /* name */
1403          FALSE,                 /* partial_inplace */
1404          0,                     /* src_mask */
1405          0xffff,                /* dst_mask */
1406          FALSE),                /* pcrel_offset */
1407
1408   /* Like DTPREL16_LO, but next higher group of 16 bits.  */
1409   HOWTO (R_PPC64_DTPREL16_HI,
1410          16,                    /* rightshift */
1411          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1412          16,                    /* bitsize */
1413          FALSE,                 /* pc_relative */
1414          0,                     /* bitpos */
1415          complain_overflow_signed, /* complain_on_overflow */
1416          ppc64_elf_unhandled_reloc, /* special_function */
1417          "R_PPC64_DTPREL16_HI", /* name */
1418          FALSE,                 /* partial_inplace */
1419          0,                     /* src_mask */
1420          0xffff,                /* dst_mask */
1421          FALSE),                /* pcrel_offset */
1422
1423   /* Like DTPREL16_HI, but adjust for low 16 bits.  */
1424   HOWTO (R_PPC64_DTPREL16_HA,
1425          16,                    /* rightshift */
1426          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1427          16,                    /* bitsize */
1428          FALSE,                 /* pc_relative */
1429          0,                     /* bitpos */
1430          complain_overflow_signed, /* complain_on_overflow */
1431          ppc64_elf_unhandled_reloc, /* special_function */
1432          "R_PPC64_DTPREL16_HA", /* name */
1433          FALSE,                 /* partial_inplace */
1434          0,                     /* src_mask */
1435          0xffff,                /* dst_mask */
1436          FALSE),                /* pcrel_offset */
1437
1438   /* Like DTPREL16_HI, but next higher group of 16 bits.  */
1439   HOWTO (R_PPC64_DTPREL16_HIGHER,
1440          32,                    /* rightshift */
1441          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1442          16,                    /* bitsize */
1443          FALSE,                 /* pc_relative */
1444          0,                     /* bitpos */
1445          complain_overflow_dont, /* complain_on_overflow */
1446          ppc64_elf_unhandled_reloc, /* special_function */
1447          "R_PPC64_DTPREL16_HIGHER", /* name */
1448          FALSE,                 /* partial_inplace */
1449          0,                     /* src_mask */
1450          0xffff,                /* dst_mask */
1451          FALSE),                /* pcrel_offset */
1452
1453   /* Like DTPREL16_HIGHER, but adjust for low 16 bits.  */
1454   HOWTO (R_PPC64_DTPREL16_HIGHERA,
1455          32,                    /* rightshift */
1456          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1457          16,                    /* bitsize */
1458          FALSE,                 /* pc_relative */
1459          0,                     /* bitpos */
1460          complain_overflow_dont, /* complain_on_overflow */
1461          ppc64_elf_unhandled_reloc, /* special_function */
1462          "R_PPC64_DTPREL16_HIGHERA", /* name */
1463          FALSE,                 /* partial_inplace */
1464          0,                     /* src_mask */
1465          0xffff,                /* dst_mask */
1466          FALSE),                /* pcrel_offset */
1467
1468   /* Like DTPREL16_HIGHER, but next higher group of 16 bits.  */
1469   HOWTO (R_PPC64_DTPREL16_HIGHEST,
1470          48,                    /* rightshift */
1471          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1472          16,                    /* bitsize */
1473          FALSE,                 /* pc_relative */
1474          0,                     /* bitpos */
1475          complain_overflow_dont, /* complain_on_overflow */
1476          ppc64_elf_unhandled_reloc, /* special_function */
1477          "R_PPC64_DTPREL16_HIGHEST", /* name */
1478          FALSE,                 /* partial_inplace */
1479          0,                     /* src_mask */
1480          0xffff,                /* dst_mask */
1481          FALSE),                /* pcrel_offset */
1482
1483   /* Like DTPREL16_HIGHEST, but adjust for low 16 bits.  */
1484   HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1485          48,                    /* rightshift */
1486          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1487          16,                    /* bitsize */
1488          FALSE,                 /* pc_relative */
1489          0,                     /* bitpos */
1490          complain_overflow_dont, /* complain_on_overflow */
1491          ppc64_elf_unhandled_reloc, /* special_function */
1492          "R_PPC64_DTPREL16_HIGHESTA", /* name */
1493          FALSE,                 /* partial_inplace */
1494          0,                     /* src_mask */
1495          0xffff,                /* dst_mask */
1496          FALSE),                /* pcrel_offset */
1497
1498   /* Like DTPREL16, but for insns with a DS field.  */
1499   HOWTO (R_PPC64_DTPREL16_DS,
1500          0,                     /* rightshift */
1501          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1502          16,                    /* bitsize */
1503          FALSE,                 /* pc_relative */
1504          0,                     /* bitpos */
1505          complain_overflow_signed, /* complain_on_overflow */
1506          ppc64_elf_unhandled_reloc, /* special_function */
1507          "R_PPC64_DTPREL16_DS", /* name */
1508          FALSE,                 /* partial_inplace */
1509          0,                     /* src_mask */
1510          0xfffc,                /* dst_mask */
1511          FALSE),                /* pcrel_offset */
1512
1513   /* Like DTPREL16_DS, but no overflow.  */
1514   HOWTO (R_PPC64_DTPREL16_LO_DS,
1515          0,                     /* rightshift */
1516          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1517          16,                    /* bitsize */
1518          FALSE,                 /* pc_relative */
1519          0,                     /* bitpos */
1520          complain_overflow_dont, /* complain_on_overflow */
1521          ppc64_elf_unhandled_reloc, /* special_function */
1522          "R_PPC64_DTPREL16_LO_DS", /* name */
1523          FALSE,                 /* partial_inplace */
1524          0,                     /* src_mask */
1525          0xfffc,                /* dst_mask */
1526          FALSE),                /* pcrel_offset */
1527
1528   /* Computes a tp-relative displacement, the difference between the value of
1529      sym+add and the value of the thread pointer (r13).  */
1530   HOWTO (R_PPC64_TPREL64,
1531          0,                     /* rightshift */
1532          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1533          64,                    /* bitsize */
1534          FALSE,                 /* pc_relative */
1535          0,                     /* bitpos */
1536          complain_overflow_dont, /* complain_on_overflow */
1537          ppc64_elf_unhandled_reloc, /* special_function */
1538          "R_PPC64_TPREL64",     /* name */
1539          FALSE,                 /* partial_inplace */
1540          0,                     /* src_mask */
1541          ONES (64),             /* dst_mask */
1542          FALSE),                /* pcrel_offset */
1543
1544   /* A 16 bit tprel reloc.  */
1545   HOWTO (R_PPC64_TPREL16,
1546          0,                     /* rightshift */
1547          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1548          16,                    /* bitsize */
1549          FALSE,                 /* pc_relative */
1550          0,                     /* bitpos */
1551          complain_overflow_signed, /* complain_on_overflow */
1552          ppc64_elf_unhandled_reloc, /* special_function */
1553          "R_PPC64_TPREL16",     /* name */
1554          FALSE,                 /* partial_inplace */
1555          0,                     /* src_mask */
1556          0xffff,                /* dst_mask */
1557          FALSE),                /* pcrel_offset */
1558
1559   /* Like TPREL16, but no overflow.  */
1560   HOWTO (R_PPC64_TPREL16_LO,
1561          0,                     /* rightshift */
1562          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1563          16,                    /* bitsize */
1564          FALSE,                 /* pc_relative */
1565          0,                     /* bitpos */
1566          complain_overflow_dont, /* complain_on_overflow */
1567          ppc64_elf_unhandled_reloc, /* special_function */
1568          "R_PPC64_TPREL16_LO",  /* name */
1569          FALSE,                 /* partial_inplace */
1570          0,                     /* src_mask */
1571          0xffff,                /* dst_mask */
1572          FALSE),                /* pcrel_offset */
1573
1574   /* Like TPREL16_LO, but next higher group of 16 bits.  */
1575   HOWTO (R_PPC64_TPREL16_HI,
1576          16,                    /* rightshift */
1577          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1578          16,                    /* bitsize */
1579          FALSE,                 /* pc_relative */
1580          0,                     /* bitpos */
1581          complain_overflow_signed, /* complain_on_overflow */
1582          ppc64_elf_unhandled_reloc, /* special_function */
1583          "R_PPC64_TPREL16_HI",  /* name */
1584          FALSE,                 /* partial_inplace */
1585          0,                     /* src_mask */
1586          0xffff,                /* dst_mask */
1587          FALSE),                /* pcrel_offset */
1588
1589   /* Like TPREL16_HI, but adjust for low 16 bits.  */
1590   HOWTO (R_PPC64_TPREL16_HA,
1591          16,                    /* rightshift */
1592          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1593          16,                    /* bitsize */
1594          FALSE,                 /* pc_relative */
1595          0,                     /* bitpos */
1596          complain_overflow_signed, /* complain_on_overflow */
1597          ppc64_elf_unhandled_reloc, /* special_function */
1598          "R_PPC64_TPREL16_HA",  /* name */
1599          FALSE,                 /* partial_inplace */
1600          0,                     /* src_mask */
1601          0xffff,                /* dst_mask */
1602          FALSE),                /* pcrel_offset */
1603
1604   /* Like TPREL16_HI, but next higher group of 16 bits.  */
1605   HOWTO (R_PPC64_TPREL16_HIGHER,
1606          32,                    /* rightshift */
1607          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1608          16,                    /* bitsize */
1609          FALSE,                 /* pc_relative */
1610          0,                     /* bitpos */
1611          complain_overflow_dont, /* complain_on_overflow */
1612          ppc64_elf_unhandled_reloc, /* special_function */
1613          "R_PPC64_TPREL16_HIGHER",      /* name */
1614          FALSE,                 /* partial_inplace */
1615          0,                     /* src_mask */
1616          0xffff,                /* dst_mask */
1617          FALSE),                /* pcrel_offset */
1618
1619   /* Like TPREL16_HIGHER, but adjust for low 16 bits.  */
1620   HOWTO (R_PPC64_TPREL16_HIGHERA,
1621          32,                    /* rightshift */
1622          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1623          16,                    /* bitsize */
1624          FALSE,                 /* pc_relative */
1625          0,                     /* bitpos */
1626          complain_overflow_dont, /* complain_on_overflow */
1627          ppc64_elf_unhandled_reloc, /* special_function */
1628          "R_PPC64_TPREL16_HIGHERA", /* name */
1629          FALSE,                 /* partial_inplace */
1630          0,                     /* src_mask */
1631          0xffff,                /* dst_mask */
1632          FALSE),                /* pcrel_offset */
1633
1634   /* Like TPREL16_HIGHER, but next higher group of 16 bits.  */
1635   HOWTO (R_PPC64_TPREL16_HIGHEST,
1636          48,                    /* rightshift */
1637          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1638          16,                    /* bitsize */
1639          FALSE,                 /* pc_relative */
1640          0,                     /* bitpos */
1641          complain_overflow_dont, /* complain_on_overflow */
1642          ppc64_elf_unhandled_reloc, /* special_function */
1643          "R_PPC64_TPREL16_HIGHEST", /* name */
1644          FALSE,                 /* partial_inplace */
1645          0,                     /* src_mask */
1646          0xffff,                /* dst_mask */
1647          FALSE),                /* pcrel_offset */
1648
1649   /* Like TPREL16_HIGHEST, but adjust for low 16 bits.  */
1650   HOWTO (R_PPC64_TPREL16_HIGHESTA,
1651          48,                    /* rightshift */
1652          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1653          16,                    /* bitsize */
1654          FALSE,                 /* pc_relative */
1655          0,                     /* bitpos */
1656          complain_overflow_dont, /* complain_on_overflow */
1657          ppc64_elf_unhandled_reloc, /* special_function */
1658          "R_PPC64_TPREL16_HIGHESTA", /* name */
1659          FALSE,                 /* partial_inplace */
1660          0,                     /* src_mask */
1661          0xffff,                /* dst_mask */
1662          FALSE),                /* pcrel_offset */
1663
1664   /* Like TPREL16, but for insns with a DS field.  */
1665   HOWTO (R_PPC64_TPREL16_DS,
1666          0,                     /* rightshift */
1667          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1668          16,                    /* bitsize */
1669          FALSE,                 /* pc_relative */
1670          0,                     /* bitpos */
1671          complain_overflow_signed, /* complain_on_overflow */
1672          ppc64_elf_unhandled_reloc, /* special_function */
1673          "R_PPC64_TPREL16_DS",  /* name */
1674          FALSE,                 /* partial_inplace */
1675          0,                     /* src_mask */
1676          0xfffc,                /* dst_mask */
1677          FALSE),                /* pcrel_offset */
1678
1679   /* Like TPREL16_DS, but no overflow.  */
1680   HOWTO (R_PPC64_TPREL16_LO_DS,
1681          0,                     /* rightshift */
1682          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1683          16,                    /* bitsize */
1684          FALSE,                 /* pc_relative */
1685          0,                     /* bitpos */
1686          complain_overflow_dont, /* complain_on_overflow */
1687          ppc64_elf_unhandled_reloc, /* special_function */
1688          "R_PPC64_TPREL16_LO_DS", /* name */
1689          FALSE,                 /* partial_inplace */
1690          0,                     /* src_mask */
1691          0xfffc,                /* dst_mask */
1692          FALSE),                /* pcrel_offset */
1693
1694   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1695      with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1696      to the first entry relative to the TOC base (r2).  */
1697   HOWTO (R_PPC64_GOT_TLSGD16,
1698          0,                     /* rightshift */
1699          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1700          16,                    /* bitsize */
1701          FALSE,                 /* pc_relative */
1702          0,                     /* bitpos */
1703          complain_overflow_signed, /* complain_on_overflow */
1704          ppc64_elf_unhandled_reloc, /* special_function */
1705          "R_PPC64_GOT_TLSGD16", /* name */
1706          FALSE,                 /* partial_inplace */
1707          0,                     /* src_mask */
1708          0xffff,                /* dst_mask */
1709          FALSE),                /* pcrel_offset */
1710
1711   /* Like GOT_TLSGD16, but no overflow.  */
1712   HOWTO (R_PPC64_GOT_TLSGD16_LO,
1713          0,                     /* rightshift */
1714          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1715          16,                    /* bitsize */
1716          FALSE,                 /* pc_relative */
1717          0,                     /* bitpos */
1718          complain_overflow_dont, /* complain_on_overflow */
1719          ppc64_elf_unhandled_reloc, /* special_function */
1720          "R_PPC64_GOT_TLSGD16_LO", /* name */
1721          FALSE,                 /* partial_inplace */
1722          0,                     /* src_mask */
1723          0xffff,                /* dst_mask */
1724          FALSE),                /* pcrel_offset */
1725
1726   /* Like GOT_TLSGD16_LO, but next higher group of 16 bits.  */
1727   HOWTO (R_PPC64_GOT_TLSGD16_HI,
1728          16,                    /* rightshift */
1729          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1730          16,                    /* bitsize */
1731          FALSE,                 /* pc_relative */
1732          0,                     /* bitpos */
1733          complain_overflow_signed, /* complain_on_overflow */
1734          ppc64_elf_unhandled_reloc, /* special_function */
1735          "R_PPC64_GOT_TLSGD16_HI", /* name */
1736          FALSE,                 /* partial_inplace */
1737          0,                     /* src_mask */
1738          0xffff,                /* dst_mask */
1739          FALSE),                /* pcrel_offset */
1740
1741   /* Like GOT_TLSGD16_HI, but adjust for low 16 bits.  */
1742   HOWTO (R_PPC64_GOT_TLSGD16_HA,
1743          16,                    /* rightshift */
1744          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1745          16,                    /* bitsize */
1746          FALSE,                 /* pc_relative */
1747          0,                     /* bitpos */
1748          complain_overflow_signed, /* complain_on_overflow */
1749          ppc64_elf_unhandled_reloc, /* special_function */
1750          "R_PPC64_GOT_TLSGD16_HA", /* name */
1751          FALSE,                 /* partial_inplace */
1752          0,                     /* src_mask */
1753          0xffff,                /* dst_mask */
1754          FALSE),                /* pcrel_offset */
1755
1756   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1757      with values (sym+add)@dtpmod and zero, and computes the offset to the
1758      first entry relative to the TOC base (r2).  */
1759   HOWTO (R_PPC64_GOT_TLSLD16,
1760          0,                     /* rightshift */
1761          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1762          16,                    /* bitsize */
1763          FALSE,                 /* pc_relative */
1764          0,                     /* bitpos */
1765          complain_overflow_signed, /* complain_on_overflow */
1766          ppc64_elf_unhandled_reloc, /* special_function */
1767          "R_PPC64_GOT_TLSLD16", /* name */
1768          FALSE,                 /* partial_inplace */
1769          0,                     /* src_mask */
1770          0xffff,                /* dst_mask */
1771          FALSE),                /* pcrel_offset */
1772
1773   /* Like GOT_TLSLD16, but no overflow.  */
1774   HOWTO (R_PPC64_GOT_TLSLD16_LO,
1775          0,                     /* rightshift */
1776          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1777          16,                    /* bitsize */
1778          FALSE,                 /* pc_relative */
1779          0,                     /* bitpos */
1780          complain_overflow_dont, /* complain_on_overflow */
1781          ppc64_elf_unhandled_reloc, /* special_function */
1782          "R_PPC64_GOT_TLSLD16_LO", /* name */
1783          FALSE,                 /* partial_inplace */
1784          0,                     /* src_mask */
1785          0xffff,                /* dst_mask */
1786          FALSE),                /* pcrel_offset */
1787
1788   /* Like GOT_TLSLD16_LO, but next higher group of 16 bits.  */
1789   HOWTO (R_PPC64_GOT_TLSLD16_HI,
1790          16,                    /* rightshift */
1791          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1792          16,                    /* bitsize */
1793          FALSE,                 /* pc_relative */
1794          0,                     /* bitpos */
1795          complain_overflow_signed, /* complain_on_overflow */
1796          ppc64_elf_unhandled_reloc, /* special_function */
1797          "R_PPC64_GOT_TLSLD16_HI", /* name */
1798          FALSE,                 /* partial_inplace */
1799          0,                     /* src_mask */
1800          0xffff,                /* dst_mask */
1801          FALSE),                /* pcrel_offset */
1802
1803   /* Like GOT_TLSLD16_HI, but adjust for low 16 bits.  */
1804   HOWTO (R_PPC64_GOT_TLSLD16_HA,
1805          16,                    /* rightshift */
1806          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1807          16,                    /* bitsize */
1808          FALSE,                 /* pc_relative */
1809          0,                     /* bitpos */
1810          complain_overflow_signed, /* complain_on_overflow */
1811          ppc64_elf_unhandled_reloc, /* special_function */
1812          "R_PPC64_GOT_TLSLD16_HA", /* name */
1813          FALSE,                 /* partial_inplace */
1814          0,                     /* src_mask */
1815          0xffff,                /* dst_mask */
1816          FALSE),                /* pcrel_offset */
1817
1818   /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1819      the offset to the entry relative to the TOC base (r2).  */
1820   HOWTO (R_PPC64_GOT_DTPREL16_DS,
1821          0,                     /* rightshift */
1822          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1823          16,                    /* bitsize */
1824          FALSE,                 /* pc_relative */
1825          0,                     /* bitpos */
1826          complain_overflow_signed, /* complain_on_overflow */
1827          ppc64_elf_unhandled_reloc, /* special_function */
1828          "R_PPC64_GOT_DTPREL16_DS", /* name */
1829          FALSE,                 /* partial_inplace */
1830          0,                     /* src_mask */
1831          0xfffc,                /* dst_mask */
1832          FALSE),                /* pcrel_offset */
1833
1834   /* Like GOT_DTPREL16_DS, but no overflow.  */
1835   HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1836          0,                     /* rightshift */
1837          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1838          16,                    /* bitsize */
1839          FALSE,                 /* pc_relative */
1840          0,                     /* bitpos */
1841          complain_overflow_dont, /* complain_on_overflow */
1842          ppc64_elf_unhandled_reloc, /* special_function */
1843          "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1844          FALSE,                 /* partial_inplace */
1845          0,                     /* src_mask */
1846          0xfffc,                /* dst_mask */
1847          FALSE),                /* pcrel_offset */
1848
1849   /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits.  */
1850   HOWTO (R_PPC64_GOT_DTPREL16_HI,
1851          16,                    /* rightshift */
1852          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1853          16,                    /* bitsize */
1854          FALSE,                 /* pc_relative */
1855          0,                     /* bitpos */
1856          complain_overflow_signed, /* complain_on_overflow */
1857          ppc64_elf_unhandled_reloc, /* special_function */
1858          "R_PPC64_GOT_DTPREL16_HI", /* name */
1859          FALSE,                 /* partial_inplace */
1860          0,                     /* src_mask */
1861          0xffff,                /* dst_mask */
1862          FALSE),                /* pcrel_offset */
1863
1864   /* Like GOT_DTPREL16_HI, but adjust for low 16 bits.  */
1865   HOWTO (R_PPC64_GOT_DTPREL16_HA,
1866          16,                    /* rightshift */
1867          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1868          16,                    /* bitsize */
1869          FALSE,                 /* pc_relative */
1870          0,                     /* bitpos */
1871          complain_overflow_signed, /* complain_on_overflow */
1872          ppc64_elf_unhandled_reloc, /* special_function */
1873          "R_PPC64_GOT_DTPREL16_HA", /* name */
1874          FALSE,                 /* partial_inplace */
1875          0,                     /* src_mask */
1876          0xffff,                /* dst_mask */
1877          FALSE),                /* pcrel_offset */
1878
1879   /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1880      offset to the entry relative to the TOC base (r2).  */
1881   HOWTO (R_PPC64_GOT_TPREL16_DS,
1882          0,                     /* rightshift */
1883          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1884          16,                    /* bitsize */
1885          FALSE,                 /* pc_relative */
1886          0,                     /* bitpos */
1887          complain_overflow_signed, /* complain_on_overflow */
1888          ppc64_elf_unhandled_reloc, /* special_function */
1889          "R_PPC64_GOT_TPREL16_DS", /* name */
1890          FALSE,                 /* partial_inplace */
1891          0,                     /* src_mask */
1892          0xfffc,                /* dst_mask */
1893          FALSE),                /* pcrel_offset */
1894
1895   /* Like GOT_TPREL16_DS, but no overflow.  */
1896   HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1897          0,                     /* rightshift */
1898          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1899          16,                    /* bitsize */
1900          FALSE,                 /* pc_relative */
1901          0,                     /* bitpos */
1902          complain_overflow_dont, /* complain_on_overflow */
1903          ppc64_elf_unhandled_reloc, /* special_function */
1904          "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1905          FALSE,                 /* partial_inplace */
1906          0,                     /* src_mask */
1907          0xfffc,                /* dst_mask */
1908          FALSE),                /* pcrel_offset */
1909
1910   /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits.  */
1911   HOWTO (R_PPC64_GOT_TPREL16_HI,
1912          16,                    /* rightshift */
1913          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1914          16,                    /* bitsize */
1915          FALSE,                 /* pc_relative */
1916          0,                     /* bitpos */
1917          complain_overflow_signed, /* complain_on_overflow */
1918          ppc64_elf_unhandled_reloc, /* special_function */
1919          "R_PPC64_GOT_TPREL16_HI", /* name */
1920          FALSE,                 /* partial_inplace */
1921          0,                     /* src_mask */
1922          0xffff,                /* dst_mask */
1923          FALSE),                /* pcrel_offset */
1924
1925   /* Like GOT_TPREL16_HI, but adjust for low 16 bits.  */
1926   HOWTO (R_PPC64_GOT_TPREL16_HA,
1927          16,                    /* rightshift */
1928          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1929          16,                    /* bitsize */
1930          FALSE,                 /* pc_relative */
1931          0,                     /* bitpos */
1932          complain_overflow_signed, /* complain_on_overflow */
1933          ppc64_elf_unhandled_reloc, /* special_function */
1934          "R_PPC64_GOT_TPREL16_HA", /* name */
1935          FALSE,                 /* partial_inplace */
1936          0,                     /* src_mask */
1937          0xffff,                /* dst_mask */
1938          FALSE),                /* pcrel_offset */
1939
1940   HOWTO (R_PPC64_JMP_IREL,      /* type */
1941          0,                     /* rightshift */
1942          0,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1943          0,                     /* bitsize */
1944          FALSE,                 /* pc_relative */
1945          0,                     /* bitpos */
1946          complain_overflow_dont, /* complain_on_overflow */
1947          ppc64_elf_unhandled_reloc, /* special_function */
1948          "R_PPC64_JMP_IREL",    /* name */
1949          FALSE,                 /* partial_inplace */
1950          0,                     /* src_mask */
1951          0,                     /* dst_mask */
1952          FALSE),                /* pcrel_offset */
1953
1954   HOWTO (R_PPC64_IRELATIVE,     /* type */
1955          0,                     /* rightshift */
1956          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1957          64,                    /* bitsize */
1958          FALSE,                 /* pc_relative */
1959          0,                     /* bitpos */
1960          complain_overflow_dont, /* complain_on_overflow */
1961          bfd_elf_generic_reloc, /* special_function */
1962          "R_PPC64_IRELATIVE",   /* name */
1963          FALSE,                 /* partial_inplace */
1964          0,                     /* src_mask */
1965          ONES (64),             /* dst_mask */
1966          FALSE),                /* pcrel_offset */
1967
1968   /* A 16 bit relative relocation.  */
1969   HOWTO (R_PPC64_REL16,         /* type */
1970          0,                     /* rightshift */
1971          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1972          16,                    /* bitsize */
1973          TRUE,                  /* pc_relative */
1974          0,                     /* bitpos */
1975          complain_overflow_signed, /* complain_on_overflow */
1976          bfd_elf_generic_reloc, /* special_function */
1977          "R_PPC64_REL16",       /* name */
1978          FALSE,                 /* partial_inplace */
1979          0,                     /* src_mask */
1980          0xffff,                /* dst_mask */
1981          TRUE),                 /* pcrel_offset */
1982
1983   /* A 16 bit relative relocation without overflow.  */
1984   HOWTO (R_PPC64_REL16_LO,      /* type */
1985          0,                     /* rightshift */
1986          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1987          16,                    /* bitsize */
1988          TRUE,                  /* pc_relative */
1989          0,                     /* bitpos */
1990          complain_overflow_dont,/* complain_on_overflow */
1991          bfd_elf_generic_reloc, /* special_function */
1992          "R_PPC64_REL16_LO",    /* name */
1993          FALSE,                 /* partial_inplace */
1994          0,                     /* src_mask */
1995          0xffff,                /* dst_mask */
1996          TRUE),                 /* pcrel_offset */
1997
1998   /* The high order 16 bits of a relative address.  */
1999   HOWTO (R_PPC64_REL16_HI,      /* type */
2000          16,                    /* rightshift */
2001          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2002          16,                    /* bitsize */
2003          TRUE,                  /* pc_relative */
2004          0,                     /* bitpos */
2005          complain_overflow_signed, /* complain_on_overflow */
2006          bfd_elf_generic_reloc, /* special_function */
2007          "R_PPC64_REL16_HI",    /* name */
2008          FALSE,                 /* partial_inplace */
2009          0,                     /* src_mask */
2010          0xffff,                /* dst_mask */
2011          TRUE),                 /* pcrel_offset */
2012
2013   /* The high order 16 bits of a relative address, plus 1 if the contents of
2014      the low 16 bits, treated as a signed number, is negative.  */
2015   HOWTO (R_PPC64_REL16_HA,      /* type */
2016          16,                    /* rightshift */
2017          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2018          16,                    /* bitsize */
2019          TRUE,                  /* pc_relative */
2020          0,                     /* bitpos */
2021          complain_overflow_signed, /* complain_on_overflow */
2022          ppc64_elf_ha_reloc,    /* special_function */
2023          "R_PPC64_REL16_HA",    /* name */
2024          FALSE,                 /* partial_inplace */
2025          0,                     /* src_mask */
2026          0xffff,                /* dst_mask */
2027          TRUE),                 /* pcrel_offset */
2028
2029   /* Like R_PPC64_REL16_HA but for split field in addpcis.  */
2030   HOWTO (R_PPC64_REL16DX_HA,    /* type */
2031          16,                    /* rightshift */
2032          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2033          16,                    /* bitsize */
2034          TRUE,                  /* pc_relative */
2035          0,                     /* bitpos */
2036          complain_overflow_signed, /* complain_on_overflow */
2037          ppc64_elf_ha_reloc,    /* special_function */
2038          "R_PPC64_REL16DX_HA",  /* name */
2039          FALSE,                 /* partial_inplace */
2040          0,                     /* src_mask */
2041          0x1fffc1,              /* dst_mask */
2042          TRUE),                 /* pcrel_offset */
2043
2044   /* Like R_PPC64_ADDR16_HI, but no overflow.  */
2045   HOWTO (R_PPC64_ADDR16_HIGH,   /* type */
2046          16,                    /* rightshift */
2047          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2048          16,                    /* bitsize */
2049          FALSE,                 /* pc_relative */
2050          0,                     /* bitpos */
2051          complain_overflow_dont, /* complain_on_overflow */
2052          bfd_elf_generic_reloc, /* special_function */
2053          "R_PPC64_ADDR16_HIGH", /* name */
2054          FALSE,                 /* partial_inplace */
2055          0,                     /* src_mask */
2056          0xffff,                /* dst_mask */
2057          FALSE),                /* pcrel_offset */
2058
2059   /* Like R_PPC64_ADDR16_HA, but no overflow.  */
2060   HOWTO (R_PPC64_ADDR16_HIGHA,  /* type */
2061          16,                    /* rightshift */
2062          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2063          16,                    /* bitsize */
2064          FALSE,                 /* pc_relative */
2065          0,                     /* bitpos */
2066          complain_overflow_dont, /* complain_on_overflow */
2067          ppc64_elf_ha_reloc,    /* special_function */
2068          "R_PPC64_ADDR16_HIGHA",        /* name */
2069          FALSE,                 /* partial_inplace */
2070          0,                     /* src_mask */
2071          0xffff,                /* dst_mask */
2072          FALSE),                /* pcrel_offset */
2073
2074   /* Like R_PPC64_DTPREL16_HI, but no overflow.  */
2075   HOWTO (R_PPC64_DTPREL16_HIGH,
2076          16,                    /* rightshift */
2077          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2078          16,                    /* bitsize */
2079          FALSE,                 /* pc_relative */
2080          0,                     /* bitpos */
2081          complain_overflow_dont, /* complain_on_overflow */
2082          ppc64_elf_unhandled_reloc, /* special_function */
2083          "R_PPC64_DTPREL16_HIGH", /* name */
2084          FALSE,                 /* partial_inplace */
2085          0,                     /* src_mask */
2086          0xffff,                /* dst_mask */
2087          FALSE),                /* pcrel_offset */
2088
2089   /* Like R_PPC64_DTPREL16_HA, but no overflow.  */
2090   HOWTO (R_PPC64_DTPREL16_HIGHA,
2091          16,                    /* rightshift */
2092          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2093          16,                    /* bitsize */
2094          FALSE,                 /* pc_relative */
2095          0,                     /* bitpos */
2096          complain_overflow_dont, /* complain_on_overflow */
2097          ppc64_elf_unhandled_reloc, /* special_function */
2098          "R_PPC64_DTPREL16_HIGHA", /* name */
2099          FALSE,                 /* partial_inplace */
2100          0,                     /* src_mask */
2101          0xffff,                /* dst_mask */
2102          FALSE),                /* pcrel_offset */
2103
2104   /* Like R_PPC64_TPREL16_HI, but no overflow.  */
2105   HOWTO (R_PPC64_TPREL16_HIGH,
2106          16,                    /* rightshift */
2107          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2108          16,                    /* bitsize */
2109          FALSE,                 /* pc_relative */
2110          0,                     /* bitpos */
2111          complain_overflow_dont, /* complain_on_overflow */
2112          ppc64_elf_unhandled_reloc, /* special_function */
2113          "R_PPC64_TPREL16_HIGH",        /* name */
2114          FALSE,                 /* partial_inplace */
2115          0,                     /* src_mask */
2116          0xffff,                /* dst_mask */
2117          FALSE),                /* pcrel_offset */
2118
2119   /* Like R_PPC64_TPREL16_HA, but no overflow.  */
2120   HOWTO (R_PPC64_TPREL16_HIGHA,
2121          16,                    /* rightshift */
2122          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2123          16,                    /* bitsize */
2124          FALSE,                 /* pc_relative */
2125          0,                     /* bitpos */
2126          complain_overflow_dont, /* complain_on_overflow */
2127          ppc64_elf_unhandled_reloc, /* special_function */
2128          "R_PPC64_TPREL16_HIGHA",       /* name */
2129          FALSE,                 /* partial_inplace */
2130          0,                     /* src_mask */
2131          0xffff,                /* dst_mask */
2132          FALSE),                /* pcrel_offset */
2133
2134   /* Marker reloc on ELFv2 large-model function entry.  */
2135   HOWTO (R_PPC64_ENTRY,
2136          0,                     /* rightshift */
2137          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2138          32,                    /* bitsize */
2139          FALSE,                 /* pc_relative */
2140          0,                     /* bitpos */
2141          complain_overflow_dont, /* complain_on_overflow */
2142          bfd_elf_generic_reloc, /* special_function */
2143          "R_PPC64_ENTRY",       /* name */
2144          FALSE,                 /* partial_inplace */
2145          0,                     /* src_mask */
2146          0,                     /* dst_mask */
2147          FALSE),                /* pcrel_offset */
2148
2149   /* Like ADDR64, but use local entry point of function.  */
2150   HOWTO (R_PPC64_ADDR64_LOCAL,  /* type */
2151          0,                     /* rightshift */
2152          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2153          64,                    /* bitsize */
2154          FALSE,                 /* pc_relative */
2155          0,                     /* bitpos */
2156          complain_overflow_dont, /* complain_on_overflow */
2157          bfd_elf_generic_reloc, /* special_function */
2158          "R_PPC64_ADDR64_LOCAL", /* name */
2159          FALSE,                 /* partial_inplace */
2160          0,                     /* src_mask */
2161          ONES (64),             /* dst_mask */
2162          FALSE),                /* pcrel_offset */
2163
2164   /* GNU extension to record C++ vtable hierarchy.  */
2165   HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2166          0,                     /* rightshift */
2167          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2168          0,                     /* bitsize */
2169          FALSE,                 /* pc_relative */
2170          0,                     /* bitpos */
2171          complain_overflow_dont, /* complain_on_overflow */
2172          NULL,                  /* special_function */
2173          "R_PPC64_GNU_VTINHERIT", /* name */
2174          FALSE,                 /* partial_inplace */
2175          0,                     /* src_mask */
2176          0,                     /* dst_mask */
2177          FALSE),                /* pcrel_offset */
2178
2179   /* GNU extension to record C++ vtable member usage.  */
2180   HOWTO (R_PPC64_GNU_VTENTRY,   /* type */
2181          0,                     /* rightshift */
2182          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2183          0,                     /* bitsize */
2184          FALSE,                 /* pc_relative */
2185          0,                     /* bitpos */
2186          complain_overflow_dont, /* complain_on_overflow */
2187          NULL,                  /* special_function */
2188          "R_PPC64_GNU_VTENTRY", /* name */
2189          FALSE,                 /* partial_inplace */
2190          0,                     /* src_mask */
2191          0,                     /* dst_mask */
2192          FALSE),                /* pcrel_offset */
2193 };
2194
2195 \f
2196 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2197    be done.  */
2198
2199 static void
2200 ppc_howto_init (void)
2201 {
2202   unsigned int i, type;
2203
2204   for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2205     {
2206       type = ppc64_elf_howto_raw[i].type;
2207       BFD_ASSERT (type < ARRAY_SIZE (ppc64_elf_howto_table));
2208       ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2209     }
2210 }
2211
2212 static reloc_howto_type *
2213 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2214                              bfd_reloc_code_real_type code)
2215 {
2216   enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2217
2218   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2219     /* Initialize howto table if needed.  */
2220     ppc_howto_init ();
2221
2222   switch (code)
2223     {
2224     default:
2225       return NULL;
2226
2227     case BFD_RELOC_NONE:                        r = R_PPC64_NONE;
2228       break;
2229     case BFD_RELOC_32:                          r = R_PPC64_ADDR32;
2230       break;
2231     case BFD_RELOC_PPC_BA26:                    r = R_PPC64_ADDR24;
2232       break;
2233     case BFD_RELOC_16:                          r = R_PPC64_ADDR16;
2234       break;
2235     case BFD_RELOC_LO16:                        r = R_PPC64_ADDR16_LO;
2236       break;
2237     case BFD_RELOC_HI16:                        r = R_PPC64_ADDR16_HI;
2238       break;
2239     case BFD_RELOC_PPC64_ADDR16_HIGH:           r = R_PPC64_ADDR16_HIGH;
2240       break;
2241     case BFD_RELOC_HI16_S:                      r = R_PPC64_ADDR16_HA;
2242       break;
2243     case BFD_RELOC_PPC64_ADDR16_HIGHA:          r = R_PPC64_ADDR16_HIGHA;
2244       break;
2245     case BFD_RELOC_PPC_BA16:                    r = R_PPC64_ADDR14;
2246       break;
2247     case BFD_RELOC_PPC_BA16_BRTAKEN:            r = R_PPC64_ADDR14_BRTAKEN;
2248       break;
2249     case BFD_RELOC_PPC_BA16_BRNTAKEN:           r = R_PPC64_ADDR14_BRNTAKEN;
2250       break;
2251     case BFD_RELOC_PPC_B26:                     r = R_PPC64_REL24;
2252       break;
2253     case BFD_RELOC_PPC_B16:                     r = R_PPC64_REL14;
2254       break;
2255     case BFD_RELOC_PPC_B16_BRTAKEN:             r = R_PPC64_REL14_BRTAKEN;
2256       break;
2257     case BFD_RELOC_PPC_B16_BRNTAKEN:            r = R_PPC64_REL14_BRNTAKEN;
2258       break;
2259     case BFD_RELOC_16_GOTOFF:                   r = R_PPC64_GOT16;
2260       break;
2261     case BFD_RELOC_LO16_GOTOFF:                 r = R_PPC64_GOT16_LO;
2262       break;
2263     case BFD_RELOC_HI16_GOTOFF:                 r = R_PPC64_GOT16_HI;
2264       break;
2265     case BFD_RELOC_HI16_S_GOTOFF:               r = R_PPC64_GOT16_HA;
2266       break;
2267     case BFD_RELOC_PPC_COPY:                    r = R_PPC64_COPY;
2268       break;
2269     case BFD_RELOC_PPC_GLOB_DAT:                r = R_PPC64_GLOB_DAT;
2270       break;
2271     case BFD_RELOC_32_PCREL:                    r = R_PPC64_REL32;
2272       break;
2273     case BFD_RELOC_32_PLTOFF:                   r = R_PPC64_PLT32;
2274       break;
2275     case BFD_RELOC_32_PLT_PCREL:                r = R_PPC64_PLTREL32;
2276       break;
2277     case BFD_RELOC_LO16_PLTOFF:                 r = R_PPC64_PLT16_LO;
2278       break;
2279     case BFD_RELOC_HI16_PLTOFF:                 r = R_PPC64_PLT16_HI;
2280       break;
2281     case BFD_RELOC_HI16_S_PLTOFF:               r = R_PPC64_PLT16_HA;
2282       break;
2283     case BFD_RELOC_16_BASEREL:                  r = R_PPC64_SECTOFF;
2284       break;
2285     case BFD_RELOC_LO16_BASEREL:                r = R_PPC64_SECTOFF_LO;
2286       break;
2287     case BFD_RELOC_HI16_BASEREL:                r = R_PPC64_SECTOFF_HI;
2288       break;
2289     case BFD_RELOC_HI16_S_BASEREL:              r = R_PPC64_SECTOFF_HA;
2290       break;
2291     case BFD_RELOC_CTOR:                        r = R_PPC64_ADDR64;
2292       break;
2293     case BFD_RELOC_64:                          r = R_PPC64_ADDR64;
2294       break;
2295     case BFD_RELOC_PPC64_HIGHER:                r = R_PPC64_ADDR16_HIGHER;
2296       break;
2297     case BFD_RELOC_PPC64_HIGHER_S:              r = R_PPC64_ADDR16_HIGHERA;
2298       break;
2299     case BFD_RELOC_PPC64_HIGHEST:               r = R_PPC64_ADDR16_HIGHEST;
2300       break;
2301     case BFD_RELOC_PPC64_HIGHEST_S:             r = R_PPC64_ADDR16_HIGHESTA;
2302       break;
2303     case BFD_RELOC_64_PCREL:                    r = R_PPC64_REL64;
2304       break;
2305     case BFD_RELOC_64_PLTOFF:                   r = R_PPC64_PLT64;
2306       break;
2307     case BFD_RELOC_64_PLT_PCREL:                r = R_PPC64_PLTREL64;
2308       break;
2309     case BFD_RELOC_PPC_TOC16:                   r = R_PPC64_TOC16;
2310       break;
2311     case BFD_RELOC_PPC64_TOC16_LO:              r = R_PPC64_TOC16_LO;
2312       break;
2313     case BFD_RELOC_PPC64_TOC16_HI:              r = R_PPC64_TOC16_HI;
2314       break;
2315     case BFD_RELOC_PPC64_TOC16_HA:              r = R_PPC64_TOC16_HA;
2316       break;
2317     case BFD_RELOC_PPC64_TOC:                   r = R_PPC64_TOC;
2318       break;
2319     case BFD_RELOC_PPC64_PLTGOT16:              r = R_PPC64_PLTGOT16;
2320       break;
2321     case BFD_RELOC_PPC64_PLTGOT16_LO:           r = R_PPC64_PLTGOT16_LO;
2322       break;
2323     case BFD_RELOC_PPC64_PLTGOT16_HI:           r = R_PPC64_PLTGOT16_HI;
2324       break;
2325     case BFD_RELOC_PPC64_PLTGOT16_HA:           r = R_PPC64_PLTGOT16_HA;
2326       break;
2327     case BFD_RELOC_PPC64_ADDR16_DS:             r = R_PPC64_ADDR16_DS;
2328       break;
2329     case BFD_RELOC_PPC64_ADDR16_LO_DS:          r = R_PPC64_ADDR16_LO_DS;
2330       break;
2331     case BFD_RELOC_PPC64_GOT16_DS:              r = R_PPC64_GOT16_DS;
2332       break;
2333     case BFD_RELOC_PPC64_GOT16_LO_DS:           r = R_PPC64_GOT16_LO_DS;
2334       break;
2335     case BFD_RELOC_PPC64_PLT16_LO_DS:           r = R_PPC64_PLT16_LO_DS;
2336       break;
2337     case BFD_RELOC_PPC64_SECTOFF_DS:            r = R_PPC64_SECTOFF_DS;
2338       break;
2339     case BFD_RELOC_PPC64_SECTOFF_LO_DS:         r = R_PPC64_SECTOFF_LO_DS;
2340       break;
2341     case BFD_RELOC_PPC64_TOC16_DS:              r = R_PPC64_TOC16_DS;
2342       break;
2343     case BFD_RELOC_PPC64_TOC16_LO_DS:           r = R_PPC64_TOC16_LO_DS;
2344       break;
2345     case BFD_RELOC_PPC64_PLTGOT16_DS:           r = R_PPC64_PLTGOT16_DS;
2346       break;
2347     case BFD_RELOC_PPC64_PLTGOT16_LO_DS:        r = R_PPC64_PLTGOT16_LO_DS;
2348       break;
2349     case BFD_RELOC_PPC_TLS:                     r = R_PPC64_TLS;
2350       break;
2351     case BFD_RELOC_PPC_TLSGD:                   r = R_PPC64_TLSGD;
2352       break;
2353     case BFD_RELOC_PPC_TLSLD:                   r = R_PPC64_TLSLD;
2354       break;
2355     case BFD_RELOC_PPC_DTPMOD:                  r = R_PPC64_DTPMOD64;
2356       break;
2357     case BFD_RELOC_PPC_TPREL16:                 r = R_PPC64_TPREL16;
2358       break;
2359     case BFD_RELOC_PPC_TPREL16_LO:              r = R_PPC64_TPREL16_LO;
2360       break;
2361     case BFD_RELOC_PPC_TPREL16_HI:              r = R_PPC64_TPREL16_HI;
2362       break;
2363     case BFD_RELOC_PPC64_TPREL16_HIGH:          r = R_PPC64_TPREL16_HIGH;
2364       break;
2365     case BFD_RELOC_PPC_TPREL16_HA:              r = R_PPC64_TPREL16_HA;
2366       break;
2367     case BFD_RELOC_PPC64_TPREL16_HIGHA:         r = R_PPC64_TPREL16_HIGHA;
2368       break;
2369     case BFD_RELOC_PPC_TPREL:                   r = R_PPC64_TPREL64;
2370       break;
2371     case BFD_RELOC_PPC_DTPREL16:                r = R_PPC64_DTPREL16;
2372       break;
2373     case BFD_RELOC_PPC_DTPREL16_LO:             r = R_PPC64_DTPREL16_LO;
2374       break;
2375     case BFD_RELOC_PPC_DTPREL16_HI:             r = R_PPC64_DTPREL16_HI;
2376       break;
2377     case BFD_RELOC_PPC64_DTPREL16_HIGH:         r = R_PPC64_DTPREL16_HIGH;
2378       break;
2379     case BFD_RELOC_PPC_DTPREL16_HA:             r = R_PPC64_DTPREL16_HA;
2380       break;
2381     case BFD_RELOC_PPC64_DTPREL16_HIGHA:        r = R_PPC64_DTPREL16_HIGHA;
2382       break;
2383     case BFD_RELOC_PPC_DTPREL:                  r = R_PPC64_DTPREL64;
2384       break;
2385     case BFD_RELOC_PPC_GOT_TLSGD16:             r = R_PPC64_GOT_TLSGD16;
2386       break;
2387     case BFD_RELOC_PPC_GOT_TLSGD16_LO:          r = R_PPC64_GOT_TLSGD16_LO;
2388       break;
2389     case BFD_RELOC_PPC_GOT_TLSGD16_HI:          r = R_PPC64_GOT_TLSGD16_HI;
2390       break;
2391     case BFD_RELOC_PPC_GOT_TLSGD16_HA:          r = R_PPC64_GOT_TLSGD16_HA;
2392       break;
2393     case BFD_RELOC_PPC_GOT_TLSLD16:             r = R_PPC64_GOT_TLSLD16;
2394       break;
2395     case BFD_RELOC_PPC_GOT_TLSLD16_LO:          r = R_PPC64_GOT_TLSLD16_LO;
2396       break;
2397     case BFD_RELOC_PPC_GOT_TLSLD16_HI:          r = R_PPC64_GOT_TLSLD16_HI;
2398       break;
2399     case BFD_RELOC_PPC_GOT_TLSLD16_HA:          r = R_PPC64_GOT_TLSLD16_HA;
2400       break;
2401     case BFD_RELOC_PPC_GOT_TPREL16:             r = R_PPC64_GOT_TPREL16_DS;
2402       break;
2403     case BFD_RELOC_PPC_GOT_TPREL16_LO:          r = R_PPC64_GOT_TPREL16_LO_DS;
2404       break;
2405     case BFD_RELOC_PPC_GOT_TPREL16_HI:          r = R_PPC64_GOT_TPREL16_HI;
2406       break;
2407     case BFD_RELOC_PPC_GOT_TPREL16_HA:          r = R_PPC64_GOT_TPREL16_HA;
2408       break;
2409     case BFD_RELOC_PPC_GOT_DTPREL16:            r = R_PPC64_GOT_DTPREL16_DS;
2410       break;
2411     case BFD_RELOC_PPC_GOT_DTPREL16_LO:         r = R_PPC64_GOT_DTPREL16_LO_DS;
2412       break;
2413     case BFD_RELOC_PPC_GOT_DTPREL16_HI:         r = R_PPC64_GOT_DTPREL16_HI;
2414       break;
2415     case BFD_RELOC_PPC_GOT_DTPREL16_HA:         r = R_PPC64_GOT_DTPREL16_HA;
2416       break;
2417     case BFD_RELOC_PPC64_TPREL16_DS:            r = R_PPC64_TPREL16_DS;
2418       break;
2419     case BFD_RELOC_PPC64_TPREL16_LO_DS:         r = R_PPC64_TPREL16_LO_DS;
2420       break;
2421     case BFD_RELOC_PPC64_TPREL16_HIGHER:        r = R_PPC64_TPREL16_HIGHER;
2422       break;
2423     case BFD_RELOC_PPC64_TPREL16_HIGHERA:       r = R_PPC64_TPREL16_HIGHERA;
2424       break;
2425     case BFD_RELOC_PPC64_TPREL16_HIGHEST:       r = R_PPC64_TPREL16_HIGHEST;
2426       break;
2427     case BFD_RELOC_PPC64_TPREL16_HIGHESTA:      r = R_PPC64_TPREL16_HIGHESTA;
2428       break;
2429     case BFD_RELOC_PPC64_DTPREL16_DS:           r = R_PPC64_DTPREL16_DS;
2430       break;
2431     case BFD_RELOC_PPC64_DTPREL16_LO_DS:        r = R_PPC64_DTPREL16_LO_DS;
2432       break;
2433     case BFD_RELOC_PPC64_DTPREL16_HIGHER:       r = R_PPC64_DTPREL16_HIGHER;
2434       break;
2435     case BFD_RELOC_PPC64_DTPREL16_HIGHERA:      r = R_PPC64_DTPREL16_HIGHERA;
2436       break;
2437     case BFD_RELOC_PPC64_DTPREL16_HIGHEST:      r = R_PPC64_DTPREL16_HIGHEST;
2438       break;
2439     case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:     r = R_PPC64_DTPREL16_HIGHESTA;
2440       break;
2441     case BFD_RELOC_16_PCREL:                    r = R_PPC64_REL16;
2442       break;
2443     case BFD_RELOC_LO16_PCREL:                  r = R_PPC64_REL16_LO;
2444       break;
2445     case BFD_RELOC_HI16_PCREL:                  r = R_PPC64_REL16_HI;
2446       break;
2447     case BFD_RELOC_HI16_S_PCREL:                r = R_PPC64_REL16_HA;
2448       break;
2449     case BFD_RELOC_PPC_REL16DX_HA:              r = R_PPC64_REL16DX_HA;
2450       break;
2451     case BFD_RELOC_PPC64_ENTRY:                 r = R_PPC64_ENTRY;
2452       break;
2453     case BFD_RELOC_PPC64_ADDR64_LOCAL:          r = R_PPC64_ADDR64_LOCAL;
2454       break;
2455     case BFD_RELOC_VTABLE_INHERIT:              r = R_PPC64_GNU_VTINHERIT;
2456       break;
2457     case BFD_RELOC_VTABLE_ENTRY:                r = R_PPC64_GNU_VTENTRY;
2458       break;
2459     }
2460
2461   return ppc64_elf_howto_table[r];
2462 };
2463
2464 static reloc_howto_type *
2465 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2466                              const char *r_name)
2467 {
2468   unsigned int i;
2469
2470   for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2471     if (ppc64_elf_howto_raw[i].name != NULL
2472         && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2473       return &ppc64_elf_howto_raw[i];
2474
2475   return NULL;
2476 }
2477
2478 /* Set the howto pointer for a PowerPC ELF reloc.  */
2479
2480 static void
2481 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2482                          Elf_Internal_Rela *dst)
2483 {
2484   unsigned int type;
2485
2486   /* Initialize howto table if needed.  */
2487   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2488     ppc_howto_init ();
2489
2490   type = ELF64_R_TYPE (dst->r_info);
2491   if (type >= ARRAY_SIZE (ppc64_elf_howto_table))
2492     {
2493       (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
2494                              abfd, (int) type);
2495       type = R_PPC64_NONE;
2496     }
2497   cache_ptr->howto = ppc64_elf_howto_table[type];
2498 }
2499
2500 /* Handle the R_PPC64_ADDR16_HA and similar relocs.  */
2501
2502 static bfd_reloc_status_type
2503 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2504                     void *data, asection *input_section,
2505                     bfd *output_bfd, char **error_message)
2506 {
2507   enum elf_ppc64_reloc_type r_type;
2508   long insn;
2509   bfd_size_type octets;
2510   bfd_vma value;
2511
2512   /* If this is a relocatable link (output_bfd test tells us), just
2513      call the generic function.  Any adjustment will be done at final
2514      link time.  */
2515   if (output_bfd != NULL)
2516     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2517                                   input_section, output_bfd, error_message);
2518
2519   /* Adjust the addend for sign extension of the low 16 bits.
2520      We won't actually be using the low 16 bits, so trashing them
2521      doesn't matter.  */
2522   reloc_entry->addend += 0x8000;
2523   r_type = reloc_entry->howto->type;
2524   if (r_type != R_PPC64_REL16DX_HA)
2525     return bfd_reloc_continue;
2526
2527   value = 0;
2528   if (!bfd_is_com_section (symbol->section))
2529     value = symbol->value;
2530   value += (reloc_entry->addend
2531             + symbol->section->output_offset
2532             + symbol->section->output_section->vma);
2533   value -= (reloc_entry->address
2534             + input_section->output_offset
2535             + input_section->output_section->vma);
2536   value = (bfd_signed_vma) value >> 16;
2537
2538   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2539   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2540   insn &= ~0x1fffc1;
2541   insn |= (value & 0xffc1) | ((value & 0x3e) << 15);
2542   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2543   if (value + 0x8000 > 0xffff)
2544     return bfd_reloc_overflow;
2545   return bfd_reloc_ok;
2546 }
2547
2548 static bfd_reloc_status_type
2549 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2550                         void *data, asection *input_section,
2551                         bfd *output_bfd, char **error_message)
2552 {
2553   if (output_bfd != NULL)
2554     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2555                                   input_section, output_bfd, error_message);
2556
2557   if (strcmp (symbol->section->name, ".opd") == 0
2558       && (symbol->section->owner->flags & DYNAMIC) == 0)
2559     {
2560       bfd_vma dest = opd_entry_value (symbol->section,
2561                                       symbol->value + reloc_entry->addend,
2562                                       NULL, NULL, FALSE);
2563       if (dest != (bfd_vma) -1)
2564         reloc_entry->addend = dest - (symbol->value
2565                                       + symbol->section->output_section->vma
2566                                       + symbol->section->output_offset);
2567     }
2568   else
2569     {
2570       elf_symbol_type *elfsym = (elf_symbol_type *) symbol;
2571
2572       if (symbol->section->owner != abfd
2573           && abiversion (symbol->section->owner) >= 2)
2574         {
2575           unsigned int i;
2576
2577           for (i = 0; i < symbol->section->owner->symcount; ++i)
2578             {
2579               asymbol *symdef = symbol->section->owner->outsymbols[i];
2580
2581               if (strcmp (symdef->name, symbol->name) == 0)
2582                 {
2583                   elfsym = (elf_symbol_type *) symdef;
2584                   break;
2585                 }
2586             }
2587         }
2588       reloc_entry->addend
2589         += PPC64_LOCAL_ENTRY_OFFSET (elfsym->internal_elf_sym.st_other);
2590     }
2591   return bfd_reloc_continue;
2592 }
2593
2594 static bfd_reloc_status_type
2595 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2596                          void *data, asection *input_section,
2597                          bfd *output_bfd, char **error_message)
2598 {
2599   long insn;
2600   enum elf_ppc64_reloc_type r_type;
2601   bfd_size_type octets;
2602   /* Assume 'at' branch hints.  */
2603   bfd_boolean is_isa_v2 = TRUE;
2604
2605   /* If this is a relocatable link (output_bfd test tells us), just
2606      call the generic function.  Any adjustment will be done at final
2607      link time.  */
2608   if (output_bfd != NULL)
2609     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2610                                   input_section, output_bfd, error_message);
2611
2612   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2613   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2614   insn &= ~(0x01 << 21);
2615   r_type = reloc_entry->howto->type;
2616   if (r_type == R_PPC64_ADDR14_BRTAKEN
2617       || r_type == R_PPC64_REL14_BRTAKEN)
2618     insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
2619
2620   if (is_isa_v2)
2621     {
2622       /* Set 'a' bit.  This is 0b00010 in BO field for branch
2623          on CR(BI) insns (BO == 001at or 011at), and 0b01000
2624          for branch on CTR insns (BO == 1a00t or 1a01t).  */
2625       if ((insn & (0x14 << 21)) == (0x04 << 21))
2626         insn |= 0x02 << 21;
2627       else if ((insn & (0x14 << 21)) == (0x10 << 21))
2628         insn |= 0x08 << 21;
2629       else
2630         goto out;
2631     }
2632   else
2633     {
2634       bfd_vma target = 0;
2635       bfd_vma from;
2636
2637       if (!bfd_is_com_section (symbol->section))
2638         target = symbol->value;
2639       target += symbol->section->output_section->vma;
2640       target += symbol->section->output_offset;
2641       target += reloc_entry->addend;
2642
2643       from = (reloc_entry->address
2644               + input_section->output_offset
2645               + input_section->output_section->vma);
2646
2647       /* Invert 'y' bit if not the default.  */
2648       if ((bfd_signed_vma) (target - from) < 0)
2649         insn ^= 0x01 << 21;
2650     }
2651   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2652  out:
2653   return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2654                                  input_section, output_bfd, error_message);
2655 }
2656
2657 static bfd_reloc_status_type
2658 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2659                          void *data, asection *input_section,
2660                          bfd *output_bfd, char **error_message)
2661 {
2662   /* If this is a relocatable link (output_bfd test tells us), just
2663      call the generic function.  Any adjustment will be done at final
2664      link time.  */
2665   if (output_bfd != NULL)
2666     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2667                                   input_section, output_bfd, error_message);
2668
2669   /* Subtract the symbol section base address.  */
2670   reloc_entry->addend -= symbol->section->output_section->vma;
2671   return bfd_reloc_continue;
2672 }
2673
2674 static bfd_reloc_status_type
2675 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2676                             void *data, asection *input_section,
2677                             bfd *output_bfd, char **error_message)
2678 {
2679   /* If this is a relocatable link (output_bfd test tells us), just
2680      call the generic function.  Any adjustment will be done at final
2681      link time.  */
2682   if (output_bfd != NULL)
2683     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2684                                   input_section, output_bfd, error_message);
2685
2686   /* Subtract the symbol section base address.  */
2687   reloc_entry->addend -= symbol->section->output_section->vma;
2688
2689   /* Adjust the addend for sign extension of the low 16 bits.  */
2690   reloc_entry->addend += 0x8000;
2691   return bfd_reloc_continue;
2692 }
2693
2694 static bfd_reloc_status_type
2695 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2696                      void *data, asection *input_section,
2697                      bfd *output_bfd, char **error_message)
2698 {
2699   bfd_vma TOCstart;
2700
2701   /* If this is a relocatable link (output_bfd test tells us), just
2702      call the generic function.  Any adjustment will be done at final
2703      link time.  */
2704   if (output_bfd != NULL)
2705     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2706                                   input_section, output_bfd, error_message);
2707
2708   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2709   if (TOCstart == 0)
2710     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2711
2712   /* Subtract the TOC base address.  */
2713   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2714   return bfd_reloc_continue;
2715 }
2716
2717 static bfd_reloc_status_type
2718 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2719                         void *data, asection *input_section,
2720                         bfd *output_bfd, char **error_message)
2721 {
2722   bfd_vma TOCstart;
2723
2724   /* If this is a relocatable link (output_bfd test tells us), just
2725      call the generic function.  Any adjustment will be done at final
2726      link time.  */
2727   if (output_bfd != NULL)
2728     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2729                                   input_section, output_bfd, error_message);
2730
2731   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2732   if (TOCstart == 0)
2733     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2734
2735   /* Subtract the TOC base address.  */
2736   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2737
2738   /* Adjust the addend for sign extension of the low 16 bits.  */
2739   reloc_entry->addend += 0x8000;
2740   return bfd_reloc_continue;
2741 }
2742
2743 static bfd_reloc_status_type
2744 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2745                        void *data, asection *input_section,
2746                        bfd *output_bfd, char **error_message)
2747 {
2748   bfd_vma TOCstart;
2749   bfd_size_type octets;
2750
2751   /* If this is a relocatable link (output_bfd test tells us), just
2752      call the generic function.  Any adjustment will be done at final
2753      link time.  */
2754   if (output_bfd != NULL)
2755     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2756                                   input_section, output_bfd, error_message);
2757
2758   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2759   if (TOCstart == 0)
2760     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2761
2762   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2763   bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2764   return bfd_reloc_ok;
2765 }
2766
2767 static bfd_reloc_status_type
2768 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2769                            void *data, asection *input_section,
2770                            bfd *output_bfd, char **error_message)
2771 {
2772   /* If this is a relocatable link (output_bfd test tells us), just
2773      call the generic function.  Any adjustment will be done at final
2774      link time.  */
2775   if (output_bfd != NULL)
2776     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2777                                   input_section, output_bfd, error_message);
2778
2779   if (error_message != NULL)
2780     {
2781       static char buf[60];
2782       sprintf (buf, "generic linker can't handle %s",
2783                reloc_entry->howto->name);
2784       *error_message = buf;
2785     }
2786   return bfd_reloc_dangerous;
2787 }
2788
2789 /* Track GOT entries needed for a given symbol.  We might need more
2790    than one got entry per symbol.  */
2791 struct got_entry
2792 {
2793   struct got_entry *next;
2794
2795   /* The symbol addend that we'll be placing in the GOT.  */
2796   bfd_vma addend;
2797
2798   /* Unlike other ELF targets, we use separate GOT entries for the same
2799      symbol referenced from different input files.  This is to support
2800      automatic multiple TOC/GOT sections, where the TOC base can vary
2801      from one input file to another.  After partitioning into TOC groups
2802      we merge entries within the group.
2803
2804      Point to the BFD owning this GOT entry.  */
2805   bfd *owner;
2806
2807   /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2808      TLS_TPREL or TLS_DTPREL for tls entries.  */
2809   unsigned char tls_type;
2810
2811   /* Non-zero if got.ent points to real entry.  */
2812   unsigned char is_indirect;
2813
2814   /* Reference count until size_dynamic_sections, GOT offset thereafter.  */
2815   union
2816     {
2817       bfd_signed_vma refcount;
2818       bfd_vma offset;
2819       struct got_entry *ent;
2820     } got;
2821 };
2822
2823 /* The same for PLT.  */
2824 struct plt_entry
2825 {
2826   struct plt_entry *next;
2827
2828   bfd_vma addend;
2829
2830   union
2831     {
2832       bfd_signed_vma refcount;
2833       bfd_vma offset;
2834     } plt;
2835 };
2836
2837 struct ppc64_elf_obj_tdata
2838 {
2839   struct elf_obj_tdata elf;
2840
2841   /* Shortcuts to dynamic linker sections.  */
2842   asection *got;
2843   asection *relgot;
2844
2845   /* Used during garbage collection.  We attach global symbols defined
2846      on removed .opd entries to this section so that the sym is removed.  */
2847   asection *deleted_section;
2848
2849   /* TLS local dynamic got entry handling.  Support for multiple GOT
2850      sections means we potentially need one of these for each input bfd.  */
2851   struct got_entry tlsld_got;
2852
2853   union {
2854     /* A copy of relocs before they are modified for --emit-relocs.  */
2855     Elf_Internal_Rela *relocs;
2856
2857     /* Section contents.  */
2858     bfd_byte *contents;
2859   } opd;
2860
2861   /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2862      the reloc to be in the range -32768 to 32767.  */
2863   unsigned int has_small_toc_reloc : 1;
2864
2865   /* Set if toc/got ha relocs detected not using r2, or lo reloc
2866      instruction not one we handle.  */
2867   unsigned int unexpected_toc_insn : 1;
2868 };
2869
2870 #define ppc64_elf_tdata(bfd) \
2871   ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2872
2873 #define ppc64_tlsld_got(bfd) \
2874   (&ppc64_elf_tdata (bfd)->tlsld_got)
2875
2876 #define is_ppc64_elf(bfd) \
2877   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2878    && elf_object_id (bfd) == PPC64_ELF_DATA)
2879
2880 /* Override the generic function because we store some extras.  */
2881
2882 static bfd_boolean
2883 ppc64_elf_mkobject (bfd *abfd)
2884 {
2885   return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2886                                   PPC64_ELF_DATA);
2887 }
2888
2889 /* Fix bad default arch selected for a 64 bit input bfd when the
2890    default is 32 bit.  */
2891
2892 static bfd_boolean
2893 ppc64_elf_object_p (bfd *abfd)
2894 {
2895   if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32)
2896     {
2897       Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2898
2899       if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2900         {
2901           /* Relies on arch after 32 bit default being 64 bit default.  */
2902           abfd->arch_info = abfd->arch_info->next;
2903           BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2904         }
2905     }
2906   return TRUE;
2907 }
2908
2909 /* Support for core dump NOTE sections.  */
2910
2911 static bfd_boolean
2912 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2913 {
2914   size_t offset, size;
2915
2916   if (note->descsz != 504)
2917     return FALSE;
2918
2919   /* pr_cursig */
2920   elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2921
2922   /* pr_pid */
2923   elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2924
2925   /* pr_reg */
2926   offset = 112;
2927   size = 384;
2928
2929   /* Make a ".reg/999" section.  */
2930   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2931                                           size, note->descpos + offset);
2932 }
2933
2934 static bfd_boolean
2935 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2936 {
2937   if (note->descsz != 136)
2938     return FALSE;
2939
2940   elf_tdata (abfd)->core->pid
2941     = bfd_get_32 (abfd, note->descdata + 24);
2942   elf_tdata (abfd)->core->program
2943     = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2944   elf_tdata (abfd)->core->command
2945     = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2946
2947   return TRUE;
2948 }
2949
2950 static char *
2951 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2952                            ...)
2953 {
2954   switch (note_type)
2955     {
2956     default:
2957       return NULL;
2958
2959     case NT_PRPSINFO:
2960       {
2961         char data[136];
2962         va_list ap;
2963
2964         va_start (ap, note_type);
2965         memset (data, 0, sizeof (data));
2966         strncpy (data + 40, va_arg (ap, const char *), 16);
2967         strncpy (data + 56, va_arg (ap, const char *), 80);
2968         va_end (ap);
2969         return elfcore_write_note (abfd, buf, bufsiz,
2970                                    "CORE", note_type, data, sizeof (data));
2971       }
2972
2973     case NT_PRSTATUS:
2974       {
2975         char data[504];
2976         va_list ap;
2977         long pid;
2978         int cursig;
2979         const void *greg;
2980
2981         va_start (ap, note_type);
2982         memset (data, 0, 112);
2983         pid = va_arg (ap, long);
2984         bfd_put_32 (abfd, pid, data + 32);
2985         cursig = va_arg (ap, int);
2986         bfd_put_16 (abfd, cursig, data + 12);
2987         greg = va_arg (ap, const void *);
2988         memcpy (data + 112, greg, 384);
2989         memset (data + 496, 0, 8);
2990         va_end (ap);
2991         return elfcore_write_note (abfd, buf, bufsiz,
2992                                    "CORE", note_type, data, sizeof (data));
2993       }
2994     }
2995 }
2996
2997 /* Add extra PPC sections.  */
2998
2999 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
3000 {
3001   { STRING_COMMA_LEN (".plt"),    0, SHT_NOBITS,   0 },
3002   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
3003   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3004   { STRING_COMMA_LEN (".toc"),    0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3005   { STRING_COMMA_LEN (".toc1"),   0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3006   { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
3007   { NULL,                     0,  0, 0,            0 }
3008 };
3009
3010 enum _ppc64_sec_type {
3011   sec_normal = 0,
3012   sec_opd = 1,
3013   sec_toc = 2
3014 };
3015
3016 struct _ppc64_elf_section_data
3017 {
3018   struct bfd_elf_section_data elf;
3019
3020   union
3021   {
3022     /* An array with one entry for each opd function descriptor,
3023        and some spares since opd entries may be either 16 or 24 bytes.  */
3024 #define OPD_NDX(OFF) ((OFF) >> 4)
3025     struct _opd_sec_data
3026     {
3027       /* Points to the function code section for local opd entries.  */
3028       asection **func_sec;
3029
3030       /* After editing .opd, adjust references to opd local syms.  */
3031       long *adjust;
3032     } opd;
3033
3034     /* An array for toc sections, indexed by offset/8.  */
3035     struct _toc_sec_data
3036     {
3037       /* Specifies the relocation symbol index used at a given toc offset.  */
3038       unsigned *symndx;
3039
3040       /* And the relocation addend.  */
3041       bfd_vma *add;
3042     } toc;
3043   } u;
3044
3045   enum _ppc64_sec_type sec_type:2;
3046
3047   /* Flag set when small branches are detected.  Used to
3048      select suitable defaults for the stub group size.  */
3049   unsigned int has_14bit_branch:1;
3050 };
3051
3052 #define ppc64_elf_section_data(sec) \
3053   ((struct _ppc64_elf_section_data *) elf_section_data (sec))
3054
3055 static bfd_boolean
3056 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
3057 {
3058   if (!sec->used_by_bfd)
3059     {
3060       struct _ppc64_elf_section_data *sdata;
3061       bfd_size_type amt = sizeof (*sdata);
3062
3063       sdata = bfd_zalloc (abfd, amt);
3064       if (sdata == NULL)
3065         return FALSE;
3066       sec->used_by_bfd = sdata;
3067     }
3068
3069   return _bfd_elf_new_section_hook (abfd, sec);
3070 }
3071
3072 static struct _opd_sec_data *
3073 get_opd_info (asection * sec)
3074 {
3075   if (sec != NULL
3076       && ppc64_elf_section_data (sec) != NULL
3077       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
3078     return &ppc64_elf_section_data (sec)->u.opd;
3079   return NULL;
3080 }
3081 \f
3082 /* Parameters for the qsort hook.  */
3083 static bfd_boolean synthetic_relocatable;
3084
3085 /* qsort comparison function for ppc64_elf_get_synthetic_symtab.  */
3086
3087 static int
3088 compare_symbols (const void *ap, const void *bp)
3089 {
3090   const asymbol *a = * (const asymbol **) ap;
3091   const asymbol *b = * (const asymbol **) bp;
3092
3093   /* Section symbols first.  */
3094   if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
3095     return -1;
3096   if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
3097     return 1;
3098
3099   /* then .opd symbols.  */
3100   if (strcmp (a->section->name, ".opd") == 0
3101       && strcmp (b->section->name, ".opd") != 0)
3102     return -1;
3103   if (strcmp (a->section->name, ".opd") != 0
3104       && strcmp (b->section->name, ".opd") == 0)
3105     return 1;
3106
3107   /* then other code symbols.  */
3108   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3109       == (SEC_CODE | SEC_ALLOC)
3110       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3111          != (SEC_CODE | SEC_ALLOC))
3112     return -1;
3113
3114   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3115       != (SEC_CODE | SEC_ALLOC)
3116       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3117          == (SEC_CODE | SEC_ALLOC))
3118     return 1;
3119
3120   if (synthetic_relocatable)
3121     {
3122       if (a->section->id < b->section->id)
3123         return -1;
3124
3125       if (a->section->id > b->section->id)
3126         return 1;
3127     }
3128
3129   if (a->value + a->section->vma < b->value + b->section->vma)
3130     return -1;
3131
3132   if (a->value + a->section->vma > b->value + b->section->vma)
3133     return 1;
3134
3135   /* For syms with the same value, prefer strong dynamic global function
3136      syms over other syms.  */
3137   if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3138     return -1;
3139
3140   if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3141     return 1;
3142
3143   if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3144     return -1;
3145
3146   if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3147     return 1;
3148
3149   if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3150     return -1;
3151
3152   if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3153     return 1;
3154
3155   if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3156     return -1;
3157
3158   if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3159     return 1;
3160
3161   return 0;
3162 }
3163
3164 /* Search SYMS for a symbol of the given VALUE.  */
3165
3166 static asymbol *
3167 sym_exists_at (asymbol **syms, long lo, long hi, unsigned int id, bfd_vma value)
3168 {
3169   long mid;
3170
3171   if (id == (unsigned) -1)
3172     {
3173       while (lo < hi)
3174         {
3175           mid = (lo + hi) >> 1;
3176           if (syms[mid]->value + syms[mid]->section->vma < value)
3177             lo = mid + 1;
3178           else if (syms[mid]->value + syms[mid]->section->vma > value)
3179             hi = mid;
3180           else
3181             return syms[mid];
3182         }
3183     }
3184   else
3185     {
3186       while (lo < hi)
3187         {
3188           mid = (lo + hi) >> 1;
3189           if (syms[mid]->section->id < id)
3190             lo = mid + 1;
3191           else if (syms[mid]->section->id > id)
3192             hi = mid;
3193           else if (syms[mid]->value < value)
3194             lo = mid + 1;
3195           else if (syms[mid]->value > value)
3196             hi = mid;
3197           else
3198             return syms[mid];
3199         }
3200     }
3201   return NULL;
3202 }
3203
3204 static bfd_boolean
3205 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3206 {
3207   bfd_vma vma = *(bfd_vma *) ptr;
3208   return ((section->flags & SEC_ALLOC) != 0
3209           && section->vma <= vma
3210           && vma < section->vma + section->size);
3211 }
3212
3213 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3214    entry syms.  Also generate @plt symbols for the glink branch table.
3215    Returns count of synthetic symbols in RET or -1 on error.  */
3216
3217 static long
3218 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3219                                 long static_count, asymbol **static_syms,
3220                                 long dyn_count, asymbol **dyn_syms,
3221                                 asymbol **ret)
3222 {
3223   asymbol *s;
3224   long i;
3225   long count;
3226   char *names;
3227   long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3228   asection *opd = NULL;
3229   bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3230   asymbol **syms;
3231   int abi = abiversion (abfd);
3232
3233   *ret = NULL;
3234
3235   if (abi < 2)
3236     {
3237       opd = bfd_get_section_by_name (abfd, ".opd");
3238       if (opd == NULL && abi == 1)
3239         return 0;
3240     }
3241
3242   symcount = static_count;
3243   if (!relocatable)
3244     symcount += dyn_count;
3245   if (symcount == 0)
3246     return 0;
3247
3248   syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3249   if (syms == NULL)
3250     return -1;
3251
3252   if (!relocatable && static_count != 0 && dyn_count != 0)
3253     {
3254       /* Use both symbol tables.  */
3255       memcpy (syms, static_syms, static_count * sizeof (*syms));
3256       memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3257     }
3258   else if (!relocatable && static_count == 0)
3259     memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3260   else
3261     memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3262
3263   synthetic_relocatable = relocatable;
3264   qsort (syms, symcount, sizeof (*syms), compare_symbols);
3265
3266   if (!relocatable && symcount > 1)
3267     {
3268       long j;
3269       /* Trim duplicate syms, since we may have merged the normal and
3270          dynamic symbols.  Actually, we only care about syms that have
3271          different values, so trim any with the same value.  */
3272       for (i = 1, j = 1; i < symcount; ++i)
3273         if (syms[i - 1]->value + syms[i - 1]->section->vma
3274             != syms[i]->value + syms[i]->section->vma)
3275           syms[j++] = syms[i];
3276       symcount = j;
3277     }
3278
3279   i = 0;
3280   if (strcmp (syms[i]->section->name, ".opd") == 0)
3281     ++i;
3282   codesecsym = i;
3283
3284   for (; i < symcount; ++i)
3285     if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3286          != (SEC_CODE | SEC_ALLOC))
3287         || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3288       break;
3289   codesecsymend = i;
3290
3291   for (; i < symcount; ++i)
3292     if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3293       break;
3294   secsymend = i;
3295
3296   for (; i < symcount; ++i)
3297     if (strcmp (syms[i]->section->name, ".opd") != 0)
3298       break;
3299   opdsymend = i;
3300
3301   for (; i < symcount; ++i)
3302     if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3303         != (SEC_CODE | SEC_ALLOC))
3304       break;
3305   symcount = i;
3306
3307   count = 0;
3308
3309   if (relocatable)
3310     {
3311       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3312       arelent *r;
3313       size_t size;
3314       long relcount;
3315
3316       if (opdsymend == secsymend)
3317         goto done;
3318
3319       slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3320       relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3321       if (relcount == 0)
3322         goto done;
3323
3324       if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3325         {
3326           count = -1;
3327           goto done;
3328         }
3329
3330       size = 0;
3331       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3332         {
3333           asymbol *sym;
3334
3335           while (r < opd->relocation + relcount
3336                  && r->address < syms[i]->value + opd->vma)
3337             ++r;
3338
3339           if (r == opd->relocation + relcount)
3340             break;
3341
3342           if (r->address != syms[i]->value + opd->vma)
3343             continue;
3344
3345           if (r->howto->type != R_PPC64_ADDR64)
3346             continue;
3347
3348           sym = *r->sym_ptr_ptr;
3349           if (!sym_exists_at (syms, opdsymend, symcount,
3350                               sym->section->id, sym->value + r->addend))
3351             {
3352               ++count;
3353               size += sizeof (asymbol);
3354               size += strlen (syms[i]->name) + 2;
3355             }
3356         }
3357
3358       if (size == 0)
3359         goto done;
3360       s = *ret = bfd_malloc (size);
3361       if (s == NULL)
3362         {
3363           count = -1;
3364           goto done;
3365         }
3366
3367       names = (char *) (s + count);
3368
3369       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3370         {
3371           asymbol *sym;
3372
3373           while (r < opd->relocation + relcount
3374                  && r->address < syms[i]->value + opd->vma)
3375             ++r;
3376
3377           if (r == opd->relocation + relcount)
3378             break;
3379
3380           if (r->address != syms[i]->value + opd->vma)
3381             continue;
3382
3383           if (r->howto->type != R_PPC64_ADDR64)
3384             continue;
3385
3386           sym = *r->sym_ptr_ptr;
3387           if (!sym_exists_at (syms, opdsymend, symcount,
3388                               sym->section->id, sym->value + r->addend))
3389             {
3390               size_t len;
3391
3392               *s = *syms[i];
3393               s->flags |= BSF_SYNTHETIC;
3394               s->section = sym->section;
3395               s->value = sym->value + r->addend;
3396               s->name = names;
3397               *names++ = '.';
3398               len = strlen (syms[i]->name);
3399               memcpy (names, syms[i]->name, len + 1);
3400               names += len + 1;
3401               /* Have udata.p point back to the original symbol this
3402                  synthetic symbol was derived from.  */
3403               s->udata.p = syms[i];
3404               s++;
3405             }
3406         }
3407     }
3408   else
3409     {
3410       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3411       bfd_byte *contents = NULL;
3412       size_t size;
3413       long plt_count = 0;
3414       bfd_vma glink_vma = 0, resolv_vma = 0;
3415       asection *dynamic, *glink = NULL, *relplt = NULL;
3416       arelent *p;
3417
3418       if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3419         {
3420         free_contents_and_exit_err:
3421           count = -1;
3422         free_contents_and_exit:
3423           if (contents)
3424             free (contents);
3425           goto done;
3426         }
3427
3428       size = 0;
3429       for (i = secsymend; i < opdsymend; ++i)
3430         {
3431           bfd_vma ent;
3432
3433           /* Ignore bogus symbols.  */
3434           if (syms[i]->value > opd->size - 8)
3435             continue;
3436
3437           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3438           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3439             {
3440               ++count;
3441               size += sizeof (asymbol);
3442               size += strlen (syms[i]->name) + 2;
3443             }
3444         }
3445
3446       /* Get start of .glink stubs from DT_PPC64_GLINK.  */
3447       if (dyn_count != 0
3448           && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3449         {
3450           bfd_byte *dynbuf, *extdyn, *extdynend;
3451           size_t extdynsize;
3452           void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3453
3454           if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3455             goto free_contents_and_exit_err;
3456
3457           extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3458           swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3459
3460           extdyn = dynbuf;
3461           extdynend = extdyn + dynamic->size;
3462           for (; extdyn < extdynend; extdyn += extdynsize)
3463             {
3464               Elf_Internal_Dyn dyn;
3465               (*swap_dyn_in) (abfd, extdyn, &dyn);
3466
3467               if (dyn.d_tag == DT_NULL)
3468                 break;
3469
3470               if (dyn.d_tag == DT_PPC64_GLINK)
3471                 {
3472                   /* The first glink stub starts at offset 32; see
3473                      comment in ppc64_elf_finish_dynamic_sections. */
3474                   glink_vma = dyn.d_un.d_val + GLINK_CALL_STUB_SIZE - 8 * 4;
3475                   /* The .glink section usually does not survive the final
3476                      link; search for the section (usually .text) where the
3477                      glink stubs now reside.  */
3478                   glink = bfd_sections_find_if (abfd, section_covers_vma,
3479                                                 &glink_vma);
3480                   break;
3481                 }
3482             }
3483
3484           free (dynbuf);
3485         }
3486
3487       if (glink != NULL)
3488         {
3489           /* Determine __glink trampoline by reading the relative branch
3490              from the first glink stub.  */
3491           bfd_byte buf[4];
3492           unsigned int off = 0;
3493
3494           while (bfd_get_section_contents (abfd, glink, buf,
3495                                            glink_vma + off - glink->vma, 4))
3496             {
3497               unsigned int insn = bfd_get_32 (abfd, buf);
3498               insn ^= B_DOT;
3499               if ((insn & ~0x3fffffc) == 0)
3500                 {
3501                   resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3502                   break;
3503                 }
3504               off += 4;
3505               if (off > 4)
3506                 break;
3507             }
3508
3509           if (resolv_vma)
3510             size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3511
3512           relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3513           if (relplt != NULL)
3514             {
3515               slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3516               if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3517                 goto free_contents_and_exit_err;
3518
3519               plt_count = relplt->size / sizeof (Elf64_External_Rela);
3520               size += plt_count * sizeof (asymbol);
3521
3522               p = relplt->relocation;
3523               for (i = 0; i < plt_count; i++, p++)
3524                 {
3525                   size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3526                   if (p->addend != 0)
3527                     size += sizeof ("+0x") - 1 + 16;
3528                 }
3529             }
3530         }
3531
3532       if (size == 0)
3533         goto free_contents_and_exit;
3534       s = *ret = bfd_malloc (size);
3535       if (s == NULL)
3536         goto free_contents_and_exit_err;
3537
3538       names = (char *) (s + count + plt_count + (resolv_vma != 0));
3539
3540       for (i = secsymend; i < opdsymend; ++i)
3541         {
3542           bfd_vma ent;
3543
3544           if (syms[i]->value > opd->size - 8)
3545             continue;
3546
3547           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3548           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3549             {
3550               long lo, hi;
3551               size_t len;
3552               asection *sec = abfd->sections;
3553
3554               *s = *syms[i];
3555               lo = codesecsym;
3556               hi = codesecsymend;
3557               while (lo < hi)
3558                 {
3559                   long mid = (lo + hi) >> 1;
3560                   if (syms[mid]->section->vma < ent)
3561                     lo = mid + 1;
3562                   else if (syms[mid]->section->vma > ent)
3563                     hi = mid;
3564                   else
3565                     {
3566                       sec = syms[mid]->section;
3567                       break;
3568                     }
3569                 }
3570
3571               if (lo >= hi && lo > codesecsym)
3572                 sec = syms[lo - 1]->section;
3573
3574               for (; sec != NULL; sec = sec->next)
3575                 {
3576                   if (sec->vma > ent)
3577                     break;
3578                   /* SEC_LOAD may not be set if SEC is from a separate debug
3579                      info file.  */
3580                   if ((sec->flags & SEC_ALLOC) == 0)
3581                     break;
3582                   if ((sec->flags & SEC_CODE) != 0)
3583                     s->section = sec;
3584                 }
3585               s->flags |= BSF_SYNTHETIC;
3586               s->value = ent - s->section->vma;
3587               s->name = names;
3588               *names++ = '.';
3589               len = strlen (syms[i]->name);
3590               memcpy (names, syms[i]->name, len + 1);
3591               names += len + 1;
3592               /* Have udata.p point back to the original symbol this
3593                  synthetic symbol was derived from.  */
3594               s->udata.p = syms[i];
3595               s++;
3596             }
3597         }
3598       free (contents);
3599
3600       if (glink != NULL && relplt != NULL)
3601         {
3602           if (resolv_vma)
3603             {
3604               /* Add a symbol for the main glink trampoline.  */
3605               memset (s, 0, sizeof *s);
3606               s->the_bfd = abfd;
3607               s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3608               s->section = glink;
3609               s->value = resolv_vma - glink->vma;
3610               s->name = names;
3611               memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3612               names += sizeof ("__glink_PLTresolve");
3613               s++;
3614               count++;
3615             }
3616
3617           /* FIXME: It would be very much nicer to put sym@plt on the
3618              stub rather than on the glink branch table entry.  The
3619              objdump disassembler would then use a sensible symbol
3620              name on plt calls.  The difficulty in doing so is
3621              a) finding the stubs, and,
3622              b) matching stubs against plt entries, and,
3623              c) there can be multiple stubs for a given plt entry.
3624
3625              Solving (a) could be done by code scanning, but older
3626              ppc64 binaries used different stubs to current code.
3627              (b) is the tricky one since you need to known the toc
3628              pointer for at least one function that uses a pic stub to
3629              be able to calculate the plt address referenced.
3630              (c) means gdb would need to set multiple breakpoints (or
3631              find the glink branch itself) when setting breakpoints
3632              for pending shared library loads.  */
3633           p = relplt->relocation;
3634           for (i = 0; i < plt_count; i++, p++)
3635             {
3636               size_t len;
3637
3638               *s = **p->sym_ptr_ptr;
3639               /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
3640                  we are defining a symbol, ensure one of them is set.  */
3641               if ((s->flags & BSF_LOCAL) == 0)
3642                 s->flags |= BSF_GLOBAL;
3643               s->flags |= BSF_SYNTHETIC;
3644               s->section = glink;
3645               s->value = glink_vma - glink->vma;
3646               s->name = names;
3647               s->udata.p = NULL;
3648               len = strlen ((*p->sym_ptr_ptr)->name);
3649               memcpy (names, (*p->sym_ptr_ptr)->name, len);
3650               names += len;
3651               if (p->addend != 0)
3652                 {
3653                   memcpy (names, "+0x", sizeof ("+0x") - 1);
3654                   names += sizeof ("+0x") - 1;
3655                   bfd_sprintf_vma (abfd, names, p->addend);
3656                   names += strlen (names);
3657                 }
3658               memcpy (names, "@plt", sizeof ("@plt"));
3659               names += sizeof ("@plt");
3660               s++;
3661               if (abi < 2)
3662                 {
3663                   glink_vma += 8;
3664                   if (i >= 0x8000)
3665                     glink_vma += 4;
3666                 }
3667               else
3668                 glink_vma += 4;
3669             }
3670           count += plt_count;
3671         }
3672     }
3673
3674  done:
3675   free (syms);
3676   return count;
3677 }
3678 \f
3679 /* The following functions are specific to the ELF linker, while
3680    functions above are used generally.  Those named ppc64_elf_* are
3681    called by the main ELF linker code.  They appear in this file more
3682    or less in the order in which they are called.  eg.
3683    ppc64_elf_check_relocs is called early in the link process,
3684    ppc64_elf_finish_dynamic_sections is one of the last functions
3685    called.
3686
3687    PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3688    functions have both a function code symbol and a function descriptor
3689    symbol.  A call to foo in a relocatable object file looks like:
3690
3691    .            .text
3692    .    x:
3693    .            bl      .foo
3694    .            nop
3695
3696    The function definition in another object file might be:
3697
3698    .            .section .opd
3699    .    foo:    .quad   .foo
3700    .            .quad   .TOC.@tocbase
3701    .            .quad   0
3702    .
3703    .            .text
3704    .    .foo:   blr
3705
3706    When the linker resolves the call during a static link, the branch
3707    unsurprisingly just goes to .foo and the .opd information is unused.
3708    If the function definition is in a shared library, things are a little
3709    different:  The call goes via a plt call stub, the opd information gets
3710    copied to the plt, and the linker patches the nop.
3711
3712    .    x:
3713    .            bl      .foo_stub
3714    .            ld      2,40(1)
3715    .
3716    .
3717    .    .foo_stub:
3718    .            std     2,40(1)                 # in practice, the call stub
3719    .            addis   11,2,Lfoo@toc@ha        # is slightly optimized, but
3720    .            addi    11,11,Lfoo@toc@l        # this is the general idea
3721    .            ld      12,0(11)
3722    .            ld      2,8(11)
3723    .            mtctr   12
3724    .            ld      11,16(11)
3725    .            bctr
3726    .
3727    .            .section .plt
3728    .    Lfoo:   reloc (R_PPC64_JMP_SLOT, foo)
3729
3730    The "reloc ()" notation is supposed to indicate that the linker emits
3731    an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
3732    copying.
3733
3734    What are the difficulties here?  Well, firstly, the relocations
3735    examined by the linker in check_relocs are against the function code
3736    sym .foo, while the dynamic relocation in the plt is emitted against
3737    the function descriptor symbol, foo.  Somewhere along the line, we need
3738    to carefully copy dynamic link information from one symbol to the other.
3739    Secondly, the generic part of the elf linker will make .foo a dynamic
3740    symbol as is normal for most other backends.  We need foo dynamic
3741    instead, at least for an application final link.  However, when
3742    creating a shared library containing foo, we need to have both symbols
3743    dynamic so that references to .foo are satisfied during the early
3744    stages of linking.  Otherwise the linker might decide to pull in a
3745    definition from some other object, eg. a static library.
3746
3747    Update: As of August 2004, we support a new convention.  Function
3748    calls may use the function descriptor symbol, ie. "bl foo".  This
3749    behaves exactly as "bl .foo".  */
3750
3751 /* Of those relocs that might be copied as dynamic relocs, this function
3752    selects those that must be copied when linking a shared library,
3753    even when the symbol is local.  */
3754
3755 static int
3756 must_be_dyn_reloc (struct bfd_link_info *info,
3757                    enum elf_ppc64_reloc_type r_type)
3758 {
3759   switch (r_type)
3760     {
3761     default:
3762       return 1;
3763
3764     case R_PPC64_REL32:
3765     case R_PPC64_REL64:
3766     case R_PPC64_REL30:
3767       return 0;
3768
3769     case R_PPC64_TPREL16:
3770     case R_PPC64_TPREL16_LO:
3771     case R_PPC64_TPREL16_HI:
3772     case R_PPC64_TPREL16_HA:
3773     case R_PPC64_TPREL16_DS:
3774     case R_PPC64_TPREL16_LO_DS:
3775     case R_PPC64_TPREL16_HIGH:
3776     case R_PPC64_TPREL16_HIGHA:
3777     case R_PPC64_TPREL16_HIGHER:
3778     case R_PPC64_TPREL16_HIGHERA:
3779     case R_PPC64_TPREL16_HIGHEST:
3780     case R_PPC64_TPREL16_HIGHESTA:
3781     case R_PPC64_TPREL64:
3782       return !bfd_link_executable (info);
3783     }
3784 }
3785
3786 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3787    copying dynamic variables from a shared lib into an app's dynbss
3788    section, and instead use a dynamic relocation to point into the
3789    shared lib.  With code that gcc generates, it's vital that this be
3790    enabled;  In the PowerPC64 ABI, the address of a function is actually
3791    the address of a function descriptor, which resides in the .opd
3792    section.  gcc uses the descriptor directly rather than going via the
3793    GOT as some other ABI's do, which means that initialized function
3794    pointers must reference the descriptor.  Thus, a function pointer
3795    initialized to the address of a function in a shared library will
3796    either require a copy reloc, or a dynamic reloc.  Using a copy reloc
3797    redefines the function descriptor symbol to point to the copy.  This
3798    presents a problem as a plt entry for that function is also
3799    initialized from the function descriptor symbol and the copy reloc
3800    may not be initialized first.  */
3801 #define ELIMINATE_COPY_RELOCS 1
3802
3803 /* Section name for stubs is the associated section name plus this
3804    string.  */
3805 #define STUB_SUFFIX ".stub"
3806
3807 /* Linker stubs.
3808    ppc_stub_long_branch:
3809    Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3810    destination, but a 24 bit branch in a stub section will reach.
3811    .    b       dest
3812
3813    ppc_stub_plt_branch:
3814    Similar to the above, but a 24 bit branch in the stub section won't
3815    reach its destination.
3816    .    addis   %r11,%r2,xxx@toc@ha
3817    .    ld      %r12,xxx@toc@l(%r11)
3818    .    mtctr   %r12
3819    .    bctr
3820
3821    ppc_stub_plt_call:
3822    Used to call a function in a shared library.  If it so happens that
3823    the plt entry referenced crosses a 64k boundary, then an extra
3824    "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3825    .    std     %r2,40(%r1)
3826    .    addis   %r11,%r2,xxx@toc@ha
3827    .    ld      %r12,xxx+0@toc@l(%r11)
3828    .    mtctr   %r12
3829    .    ld      %r2,xxx+8@toc@l(%r11)
3830    .    ld      %r11,xxx+16@toc@l(%r11)
3831    .    bctr
3832
3833    ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3834    code to adjust the value and save r2 to support multiple toc sections.
3835    A ppc_stub_long_branch with an r2 offset looks like:
3836    .    std     %r2,40(%r1)
3837    .    addis   %r2,%r2,off@ha
3838    .    addi    %r2,%r2,off@l
3839    .    b       dest
3840
3841    A ppc_stub_plt_branch with an r2 offset looks like:
3842    .    std     %r2,40(%r1)
3843    .    addis   %r11,%r2,xxx@toc@ha
3844    .    ld      %r12,xxx@toc@l(%r11)
3845    .    addis   %r2,%r2,off@ha
3846    .    addi    %r2,%r2,off@l
3847    .    mtctr   %r12
3848    .    bctr
3849
3850    In cases where the "addis" instruction would add zero, the "addis" is
3851    omitted and following instructions modified slightly in some cases.
3852 */
3853
3854 enum ppc_stub_type {
3855   ppc_stub_none,
3856   ppc_stub_long_branch,
3857   ppc_stub_long_branch_r2off,
3858   ppc_stub_plt_branch,
3859   ppc_stub_plt_branch_r2off,
3860   ppc_stub_plt_call,
3861   ppc_stub_plt_call_r2save,
3862   ppc_stub_global_entry,
3863   ppc_stub_save_res
3864 };
3865
3866 /* Information on stub grouping.  */
3867 struct map_stub
3868 {
3869   /* The stub section.  */
3870   asection *stub_sec;
3871   /* This is the section to which stubs in the group will be attached.  */
3872   asection *link_sec;
3873   /* Next group.  */
3874   struct map_stub *next;
3875   /* Whether to emit a copy of register save/restore functions in this
3876      group.  */
3877   int needs_save_res;
3878 };
3879
3880 struct ppc_stub_hash_entry {
3881
3882   /* Base hash table entry structure.  */
3883   struct bfd_hash_entry root;
3884
3885   enum ppc_stub_type stub_type;
3886
3887   /* Group information.  */
3888   struct map_stub *group;
3889
3890   /* Offset within stub_sec of the beginning of this stub.  */
3891   bfd_vma stub_offset;
3892
3893   /* Given the symbol's value and its section we can determine its final
3894      value when building the stubs (so the stub knows where to jump.  */
3895   bfd_vma target_value;
3896   asection *target_section;
3897
3898   /* The symbol table entry, if any, that this was derived from.  */
3899   struct ppc_link_hash_entry *h;
3900   struct plt_entry *plt_ent;
3901
3902   /* Symbol st_other.  */
3903   unsigned char other;
3904 };
3905
3906 struct ppc_branch_hash_entry {
3907
3908   /* Base hash table entry structure.  */
3909   struct bfd_hash_entry root;
3910
3911   /* Offset within branch lookup table.  */
3912   unsigned int offset;
3913
3914   /* Generation marker.  */
3915   unsigned int iter;
3916 };
3917
3918 /* Used to track dynamic relocations for local symbols.  */
3919 struct ppc_dyn_relocs
3920 {
3921   struct ppc_dyn_relocs *next;
3922
3923   /* The input section of the reloc.  */
3924   asection *sec;
3925
3926   /* Total number of relocs copied for the input section.  */
3927   unsigned int count : 31;
3928
3929   /* Whether this entry is for STT_GNU_IFUNC symbols.  */
3930   unsigned int ifunc : 1;
3931 };
3932
3933 struct ppc_link_hash_entry
3934 {
3935   struct elf_link_hash_entry elf;
3936
3937   union {
3938     /* A pointer to the most recently used stub hash entry against this
3939        symbol.  */
3940     struct ppc_stub_hash_entry *stub_cache;
3941
3942     /* A pointer to the next symbol starting with a '.'  */
3943     struct ppc_link_hash_entry *next_dot_sym;
3944   } u;
3945
3946   /* Track dynamic relocs copied for this symbol.  */
3947   struct elf_dyn_relocs *dyn_relocs;
3948
3949   /* Link between function code and descriptor symbols.  */
3950   struct ppc_link_hash_entry *oh;
3951
3952   /* Flag function code and descriptor symbols.  */
3953   unsigned int is_func:1;
3954   unsigned int is_func_descriptor:1;
3955   unsigned int fake:1;
3956
3957   /* Whether global opd/toc sym has been adjusted or not.
3958      After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3959      should be set for all globals defined in any opd/toc section.  */
3960   unsigned int adjust_done:1;
3961
3962   /* Set if we twiddled this symbol to weak at some stage.  */
3963   unsigned int was_undefined:1;
3964
3965   /* Set if this is an out-of-line register save/restore function,
3966      with non-standard calling convention.  */
3967   unsigned int save_res:1;
3968
3969   /* Contexts in which symbol is used in the GOT (or TOC).
3970      TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3971      corresponding relocs are encountered during check_relocs.
3972      tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3973      indicate the corresponding GOT entry type is not needed.
3974      tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3975      a TPREL one.  We use a separate flag rather than setting TPREL
3976      just for convenience in distinguishing the two cases.  */
3977 #define TLS_GD           1      /* GD reloc. */
3978 #define TLS_LD           2      /* LD reloc. */
3979 #define TLS_TPREL        4      /* TPREL reloc, => IE. */
3980 #define TLS_DTPREL       8      /* DTPREL reloc, => LD. */
3981 #define TLS_TLS         16      /* Any TLS reloc.  */
3982 #define TLS_EXPLICIT    32      /* Marks TOC section TLS relocs. */
3983 #define TLS_TPRELGD     64      /* TPREL reloc resulting from GD->IE. */
3984 #define PLT_IFUNC      128      /* STT_GNU_IFUNC.  */
3985   unsigned char tls_mask;
3986 };
3987
3988 /* ppc64 ELF linker hash table.  */
3989
3990 struct ppc_link_hash_table
3991 {
3992   struct elf_link_hash_table elf;
3993
3994   /* The stub hash table.  */
3995   struct bfd_hash_table stub_hash_table;
3996
3997   /* Another hash table for plt_branch stubs.  */
3998   struct bfd_hash_table branch_hash_table;
3999
4000   /* Hash table for function prologue tocsave.  */
4001   htab_t tocsave_htab;
4002
4003   /* Various options and other info passed from the linker.  */
4004   struct ppc64_elf_params *params;
4005
4006   /* The size of sec_info below.  */
4007   unsigned int sec_info_arr_size;
4008
4009   /* Per-section array of extra section info.  Done this way rather
4010      than as part of ppc64_elf_section_data so we have the info for
4011      non-ppc64 sections.  */
4012   struct
4013   {
4014     /* Along with elf_gp, specifies the TOC pointer used by this section.  */
4015     bfd_vma toc_off;
4016
4017     union
4018     {
4019       /* The section group that this section belongs to.  */
4020       struct map_stub *group;
4021       /* A temp section list pointer.  */
4022       asection *list;
4023     } u;
4024   } *sec_info;
4025
4026   /* Linked list of groups.  */
4027   struct map_stub *group;
4028
4029   /* Temp used when calculating TOC pointers.  */
4030   bfd_vma toc_curr;
4031   bfd *toc_bfd;
4032   asection *toc_first_sec;
4033
4034   /* Used when adding symbols.  */
4035   struct ppc_link_hash_entry *dot_syms;
4036
4037   /* Shortcuts to get to dynamic linker sections.  */
4038   asection *dynbss;
4039   asection *relbss;
4040   asection *glink;
4041   asection *sfpr;
4042   asection *brlt;
4043   asection *relbrlt;
4044   asection *glink_eh_frame;
4045
4046   /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
4047   struct ppc_link_hash_entry *tls_get_addr;
4048   struct ppc_link_hash_entry *tls_get_addr_fd;
4049
4050   /* The size of reliplt used by got entry relocs.  */
4051   bfd_size_type got_reli_size;
4052
4053   /* Statistics.  */
4054   unsigned long stub_count[ppc_stub_global_entry];
4055
4056   /* Number of stubs against global syms.  */
4057   unsigned long stub_globals;
4058
4059   /* Set if we're linking code with function descriptors.  */
4060   unsigned int opd_abi:1;
4061
4062   /* Support for multiple toc sections.  */
4063   unsigned int do_multi_toc:1;
4064   unsigned int multi_toc_needed:1;
4065   unsigned int second_toc_pass:1;
4066   unsigned int do_toc_opt:1;
4067
4068   /* Set on error.  */
4069   unsigned int stub_error:1;
4070
4071   /* Temp used by ppc64_elf_before_check_relocs.  */
4072   unsigned int twiddled_syms:1;
4073
4074   /* Incremented every time we size stubs.  */
4075   unsigned int stub_iteration;
4076
4077   /* Small local sym cache.  */
4078   struct sym_cache sym_cache;
4079 };
4080
4081 /* Rename some of the generic section flags to better document how they
4082    are used here.  */
4083
4084 /* Nonzero if this section has TLS related relocations.  */
4085 #define has_tls_reloc sec_flg0
4086
4087 /* Nonzero if this section has a call to __tls_get_addr.  */
4088 #define has_tls_get_addr_call sec_flg1
4089
4090 /* Nonzero if this section has any toc or got relocs.  */
4091 #define has_toc_reloc sec_flg2
4092
4093 /* Nonzero if this section has a call to another section that uses
4094    the toc or got.  */
4095 #define makes_toc_func_call sec_flg3
4096
4097 /* Recursion protection when determining above flag.  */
4098 #define call_check_in_progress sec_flg4
4099 #define call_check_done sec_flg5
4100
4101 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
4102
4103 #define ppc_hash_table(p) \
4104   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
4105   == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
4106
4107 #define ppc_stub_hash_lookup(table, string, create, copy) \
4108   ((struct ppc_stub_hash_entry *) \
4109    bfd_hash_lookup ((table), (string), (create), (copy)))
4110
4111 #define ppc_branch_hash_lookup(table, string, create, copy) \
4112   ((struct ppc_branch_hash_entry *) \
4113    bfd_hash_lookup ((table), (string), (create), (copy)))
4114
4115 /* Create an entry in the stub hash table.  */
4116
4117 static struct bfd_hash_entry *
4118 stub_hash_newfunc (struct bfd_hash_entry *entry,
4119                    struct bfd_hash_table *table,
4120                    const char *string)
4121 {
4122   /* Allocate the structure if it has not already been allocated by a
4123      subclass.  */
4124   if (entry == NULL)
4125     {
4126       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4127       if (entry == NULL)
4128         return entry;
4129     }
4130
4131   /* Call the allocation method of the superclass.  */
4132   entry = bfd_hash_newfunc (entry, table, string);
4133   if (entry != NULL)
4134     {
4135       struct ppc_stub_hash_entry *eh;
4136
4137       /* Initialize the local fields.  */
4138       eh = (struct ppc_stub_hash_entry *) entry;
4139       eh->stub_type = ppc_stub_none;
4140       eh->group = NULL;
4141       eh->stub_offset = 0;
4142       eh->target_value = 0;
4143       eh->target_section = NULL;
4144       eh->h = NULL;
4145       eh->plt_ent = NULL;
4146       eh->other = 0;
4147     }
4148
4149   return entry;
4150 }
4151
4152 /* Create an entry in the branch hash table.  */
4153
4154 static struct bfd_hash_entry *
4155 branch_hash_newfunc (struct bfd_hash_entry *entry,
4156                      struct bfd_hash_table *table,
4157                      const char *string)
4158 {
4159   /* Allocate the structure if it has not already been allocated by a
4160      subclass.  */
4161   if (entry == NULL)
4162     {
4163       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4164       if (entry == NULL)
4165         return entry;
4166     }
4167
4168   /* Call the allocation method of the superclass.  */
4169   entry = bfd_hash_newfunc (entry, table, string);
4170   if (entry != NULL)
4171     {
4172       struct ppc_branch_hash_entry *eh;
4173
4174       /* Initialize the local fields.  */
4175       eh = (struct ppc_branch_hash_entry *) entry;
4176       eh->offset = 0;
4177       eh->iter = 0;
4178     }
4179
4180   return entry;
4181 }
4182
4183 /* Create an entry in a ppc64 ELF linker hash table.  */
4184
4185 static struct bfd_hash_entry *
4186 link_hash_newfunc (struct bfd_hash_entry *entry,
4187                    struct bfd_hash_table *table,
4188                    const char *string)
4189 {
4190   /* Allocate the structure if it has not already been allocated by a
4191      subclass.  */
4192   if (entry == NULL)
4193     {
4194       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4195       if (entry == NULL)
4196         return entry;
4197     }
4198
4199   /* Call the allocation method of the superclass.  */
4200   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4201   if (entry != NULL)
4202     {
4203       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4204
4205       memset (&eh->u.stub_cache, 0,
4206               (sizeof (struct ppc_link_hash_entry)
4207                - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4208
4209       /* When making function calls, old ABI code references function entry
4210          points (dot symbols), while new ABI code references the function
4211          descriptor symbol.  We need to make any combination of reference and
4212          definition work together, without breaking archive linking.
4213
4214          For a defined function "foo" and an undefined call to "bar":
4215          An old object defines "foo" and ".foo", references ".bar" (possibly
4216          "bar" too).
4217          A new object defines "foo" and references "bar".
4218
4219          A new object thus has no problem with its undefined symbols being
4220          satisfied by definitions in an old object.  On the other hand, the
4221          old object won't have ".bar" satisfied by a new object.
4222
4223          Keep a list of newly added dot-symbols.  */
4224
4225       if (string[0] == '.')
4226         {
4227           struct ppc_link_hash_table *htab;
4228
4229           htab = (struct ppc_link_hash_table *) table;
4230           eh->u.next_dot_sym = htab->dot_syms;
4231           htab->dot_syms = eh;
4232         }
4233     }
4234
4235   return entry;
4236 }
4237
4238 struct tocsave_entry {
4239   asection *sec;
4240   bfd_vma offset;
4241 };
4242
4243 static hashval_t
4244 tocsave_htab_hash (const void *p)
4245 {
4246   const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4247   return ((bfd_vma)(intptr_t) e->sec ^ e->offset) >> 3;
4248 }
4249
4250 static int
4251 tocsave_htab_eq (const void *p1, const void *p2)
4252 {
4253   const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4254   const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4255   return e1->sec == e2->sec && e1->offset == e2->offset;
4256 }
4257
4258 /* Destroy a ppc64 ELF linker hash table.  */
4259
4260 static void
4261 ppc64_elf_link_hash_table_free (bfd *obfd)
4262 {
4263   struct ppc_link_hash_table *htab;
4264
4265   htab = (struct ppc_link_hash_table *) obfd->link.hash;
4266   if (htab->tocsave_htab)
4267     htab_delete (htab->tocsave_htab);
4268   bfd_hash_table_free (&htab->branch_hash_table);
4269   bfd_hash_table_free (&htab->stub_hash_table);
4270   _bfd_elf_link_hash_table_free (obfd);
4271 }
4272
4273 /* Create a ppc64 ELF linker hash table.  */
4274
4275 static struct bfd_link_hash_table *
4276 ppc64_elf_link_hash_table_create (bfd *abfd)
4277 {
4278   struct ppc_link_hash_table *htab;
4279   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4280
4281   htab = bfd_zmalloc (amt);
4282   if (htab == NULL)
4283     return NULL;
4284
4285   if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4286                                       sizeof (struct ppc_link_hash_entry),
4287                                       PPC64_ELF_DATA))
4288     {
4289       free (htab);
4290       return NULL;
4291     }
4292
4293   /* Init the stub hash table too.  */
4294   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4295                             sizeof (struct ppc_stub_hash_entry)))
4296     {
4297       _bfd_elf_link_hash_table_free (abfd);
4298       return NULL;
4299     }
4300
4301   /* And the branch hash table.  */
4302   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4303                             sizeof (struct ppc_branch_hash_entry)))
4304     {
4305       bfd_hash_table_free (&htab->stub_hash_table);
4306       _bfd_elf_link_hash_table_free (abfd);
4307       return NULL;
4308     }
4309
4310   htab->tocsave_htab = htab_try_create (1024,
4311                                         tocsave_htab_hash,
4312                                         tocsave_htab_eq,
4313                                         NULL);
4314   if (htab->tocsave_htab == NULL)
4315     {
4316       ppc64_elf_link_hash_table_free (abfd);
4317       return NULL;
4318     }
4319   htab->elf.root.hash_table_free = ppc64_elf_link_hash_table_free;
4320
4321   /* Initializing two fields of the union is just cosmetic.  We really
4322      only care about glist, but when compiled on a 32-bit host the
4323      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
4324      debugger inspection of these fields look nicer.  */
4325   htab->elf.init_got_refcount.refcount = 0;
4326   htab->elf.init_got_refcount.glist = NULL;
4327   htab->elf.init_plt_refcount.refcount = 0;
4328   htab->elf.init_plt_refcount.glist = NULL;
4329   htab->elf.init_got_offset.offset = 0;
4330   htab->elf.init_got_offset.glist = NULL;
4331   htab->elf.init_plt_offset.offset = 0;
4332   htab->elf.init_plt_offset.glist = NULL;
4333
4334   return &htab->elf.root;
4335 }
4336
4337 /* Create sections for linker generated code.  */
4338
4339 static bfd_boolean
4340 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4341 {
4342   struct ppc_link_hash_table *htab;
4343   flagword flags;
4344
4345   htab = ppc_hash_table (info);
4346
4347   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4348            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4349   if (htab->params->save_restore_funcs)
4350     {
4351       /* Create .sfpr for code to save and restore fp regs.  */
4352       htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4353                                                        flags);
4354       if (htab->sfpr == NULL
4355           || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4356         return FALSE;
4357     }
4358
4359   if (bfd_link_relocatable (info))
4360     return TRUE;
4361
4362   /* Create .glink for lazy dynamic linking support.  */
4363   htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4364                                                     flags);
4365   if (htab->glink == NULL
4366       || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4367     return FALSE;
4368
4369   if (!info->no_ld_generated_unwind_info)
4370     {
4371       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4372                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4373       htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4374                                                                  ".eh_frame",
4375                                                                  flags);
4376       if (htab->glink_eh_frame == NULL
4377           || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4378         return FALSE;
4379     }
4380
4381   flags = SEC_ALLOC | SEC_LINKER_CREATED;
4382   htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4383   if (htab->elf.iplt == NULL
4384       || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4385     return FALSE;
4386
4387   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4388            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4389   htab->elf.irelplt
4390     = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4391   if (htab->elf.irelplt == NULL
4392       || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4393     return FALSE;
4394
4395   /* Create branch lookup table for plt_branch stubs.  */
4396   flags = (SEC_ALLOC | SEC_LOAD
4397            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4398   htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4399                                                    flags);
4400   if (htab->brlt == NULL
4401       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4402     return FALSE;
4403
4404   if (!bfd_link_pic (info))
4405     return TRUE;
4406
4407   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4408            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4409   htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4410                                                       ".rela.branch_lt",
4411                                                       flags);
4412   if (htab->relbrlt == NULL
4413       || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4414     return FALSE;
4415
4416   return TRUE;
4417 }
4418
4419 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
4420
4421 bfd_boolean
4422 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4423                          struct ppc64_elf_params *params)
4424 {
4425   struct ppc_link_hash_table *htab;
4426
4427   elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4428
4429 /* Always hook our dynamic sections into the first bfd, which is the
4430    linker created stub bfd.  This ensures that the GOT header is at
4431    the start of the output TOC section.  */
4432   htab = ppc_hash_table (info);
4433   if (htab == NULL)
4434     return FALSE;
4435   htab->elf.dynobj = params->stub_bfd;
4436   htab->params = params;
4437
4438   return create_linkage_sections (htab->elf.dynobj, info);
4439 }
4440
4441 /* Build a name for an entry in the stub hash table.  */
4442
4443 static char *
4444 ppc_stub_name (const asection *input_section,
4445                const asection *sym_sec,
4446                const struct ppc_link_hash_entry *h,
4447                const Elf_Internal_Rela *rel)
4448 {
4449   char *stub_name;
4450   ssize_t len;
4451
4452   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4453      offsets from a sym as a branch target?  In fact, we could
4454      probably assume the addend is always zero.  */
4455   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4456
4457   if (h)
4458     {
4459       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4460       stub_name = bfd_malloc (len);
4461       if (stub_name == NULL)
4462         return stub_name;
4463
4464       len = sprintf (stub_name, "%08x.%s+%x",
4465                      input_section->id & 0xffffffff,
4466                      h->elf.root.root.string,
4467                      (int) rel->r_addend & 0xffffffff);
4468     }
4469   else
4470     {
4471       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4472       stub_name = bfd_malloc (len);
4473       if (stub_name == NULL)
4474         return stub_name;
4475
4476       len = sprintf (stub_name, "%08x.%x:%x+%x",
4477                      input_section->id & 0xffffffff,
4478                      sym_sec->id & 0xffffffff,
4479                      (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4480                      (int) rel->r_addend & 0xffffffff);
4481     }
4482   if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4483     stub_name[len - 2] = 0;
4484   return stub_name;
4485 }
4486
4487 /* Look up an entry in the stub hash.  Stub entries are cached because
4488    creating the stub name takes a bit of time.  */
4489
4490 static struct ppc_stub_hash_entry *
4491 ppc_get_stub_entry (const asection *input_section,
4492                     const asection *sym_sec,
4493                     struct ppc_link_hash_entry *h,
4494                     const Elf_Internal_Rela *rel,
4495                     struct ppc_link_hash_table *htab)
4496 {
4497   struct ppc_stub_hash_entry *stub_entry;
4498   struct map_stub *group;
4499
4500   /* If this input section is part of a group of sections sharing one
4501      stub section, then use the id of the first section in the group.
4502      Stub names need to include a section id, as there may well be
4503      more than one stub used to reach say, printf, and we need to
4504      distinguish between them.  */
4505   group = htab->sec_info[input_section->id].u.group;
4506
4507   if (h != NULL && h->u.stub_cache != NULL
4508       && h->u.stub_cache->h == h
4509       && h->u.stub_cache->group == group)
4510     {
4511       stub_entry = h->u.stub_cache;
4512     }
4513   else
4514     {
4515       char *stub_name;
4516
4517       stub_name = ppc_stub_name (group->link_sec, sym_sec, h, rel);
4518       if (stub_name == NULL)
4519         return NULL;
4520
4521       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4522                                          stub_name, FALSE, FALSE);
4523       if (h != NULL)
4524         h->u.stub_cache = stub_entry;
4525
4526       free (stub_name);
4527     }
4528
4529   return stub_entry;
4530 }
4531
4532 /* Add a new stub entry to the stub hash.  Not all fields of the new
4533    stub entry are initialised.  */
4534
4535 static struct ppc_stub_hash_entry *
4536 ppc_add_stub (const char *stub_name,
4537               asection *section,
4538               struct bfd_link_info *info)
4539 {
4540   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4541   struct map_stub *group;
4542   asection *link_sec;
4543   asection *stub_sec;
4544   struct ppc_stub_hash_entry *stub_entry;
4545
4546   group = htab->sec_info[section->id].u.group;
4547   link_sec = group->link_sec;
4548   stub_sec = group->stub_sec;
4549   if (stub_sec == NULL)
4550     {
4551       size_t namelen;
4552       bfd_size_type len;
4553       char *s_name;
4554
4555       namelen = strlen (link_sec->name);
4556       len = namelen + sizeof (STUB_SUFFIX);
4557       s_name = bfd_alloc (htab->params->stub_bfd, len);
4558       if (s_name == NULL)
4559         return NULL;
4560
4561       memcpy (s_name, link_sec->name, namelen);
4562       memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4563       stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4564       if (stub_sec == NULL)
4565         return NULL;
4566       group->stub_sec = stub_sec;
4567     }
4568
4569   /* Enter this entry into the linker stub hash table.  */
4570   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4571                                      TRUE, FALSE);
4572   if (stub_entry == NULL)
4573     {
4574       info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4575                               section->owner, stub_name);
4576       return NULL;
4577     }
4578
4579   stub_entry->group = group;
4580   stub_entry->stub_offset = 0;
4581   return stub_entry;
4582 }
4583
4584 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4585    not already done.  */
4586
4587 static bfd_boolean
4588 create_got_section (bfd *abfd, struct bfd_link_info *info)
4589 {
4590   asection *got, *relgot;
4591   flagword flags;
4592   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4593
4594   if (!is_ppc64_elf (abfd))
4595     return FALSE;
4596   if (htab == NULL)
4597     return FALSE;
4598
4599   if (!htab->elf.sgot
4600       && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4601     return FALSE;
4602
4603   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4604            | SEC_LINKER_CREATED);
4605
4606   got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4607   if (!got
4608       || !bfd_set_section_alignment (abfd, got, 3))
4609     return FALSE;
4610
4611   relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4612                                                flags | SEC_READONLY);
4613   if (!relgot
4614       || ! bfd_set_section_alignment (abfd, relgot, 3))
4615     return FALSE;
4616
4617   ppc64_elf_tdata (abfd)->got = got;
4618   ppc64_elf_tdata (abfd)->relgot = relgot;
4619   return TRUE;
4620 }
4621
4622 /* Create the dynamic sections, and set up shortcuts.  */
4623
4624 static bfd_boolean
4625 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4626 {
4627   struct ppc_link_hash_table *htab;
4628
4629   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4630     return FALSE;
4631
4632   htab = ppc_hash_table (info);
4633   if (htab == NULL)
4634     return FALSE;
4635
4636   htab->dynbss = bfd_get_linker_section (dynobj, ".dynbss");
4637   if (!bfd_link_pic (info))
4638     htab->relbss = bfd_get_linker_section (dynobj, ".rela.bss");
4639
4640   if (!htab->elf.sgot || !htab->elf.splt || !htab->elf.srelplt || !htab->dynbss
4641       || (!bfd_link_pic (info) && !htab->relbss))
4642     abort ();
4643
4644   return TRUE;
4645 }
4646
4647 /* Follow indirect and warning symbol links.  */
4648
4649 static inline struct bfd_link_hash_entry *
4650 follow_link (struct bfd_link_hash_entry *h)
4651 {
4652   while (h->type == bfd_link_hash_indirect
4653          || h->type == bfd_link_hash_warning)
4654     h = h->u.i.link;
4655   return h;
4656 }
4657
4658 static inline struct elf_link_hash_entry *
4659 elf_follow_link (struct elf_link_hash_entry *h)
4660 {
4661   return (struct elf_link_hash_entry *) follow_link (&h->root);
4662 }
4663
4664 static inline struct ppc_link_hash_entry *
4665 ppc_follow_link (struct ppc_link_hash_entry *h)
4666 {
4667   return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4668 }
4669
4670 /* Merge PLT info on FROM with that on TO.  */
4671
4672 static void
4673 move_plt_plist (struct ppc_link_hash_entry *from,
4674                 struct ppc_link_hash_entry *to)
4675 {
4676   if (from->elf.plt.plist != NULL)
4677     {
4678       if (to->elf.plt.plist != NULL)
4679         {
4680           struct plt_entry **entp;
4681           struct plt_entry *ent;
4682
4683           for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4684             {
4685               struct plt_entry *dent;
4686
4687               for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4688                 if (dent->addend == ent->addend)
4689                   {
4690                     dent->plt.refcount += ent->plt.refcount;
4691                     *entp = ent->next;
4692                     break;
4693                   }
4694               if (dent == NULL)
4695                 entp = &ent->next;
4696             }
4697           *entp = to->elf.plt.plist;
4698         }
4699
4700       to->elf.plt.plist = from->elf.plt.plist;
4701       from->elf.plt.plist = NULL;
4702     }
4703 }
4704
4705 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
4706
4707 static void
4708 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4709                                 struct elf_link_hash_entry *dir,
4710                                 struct elf_link_hash_entry *ind)
4711 {
4712   struct ppc_link_hash_entry *edir, *eind;
4713
4714   edir = (struct ppc_link_hash_entry *) dir;
4715   eind = (struct ppc_link_hash_entry *) ind;
4716
4717   edir->is_func |= eind->is_func;
4718   edir->is_func_descriptor |= eind->is_func_descriptor;
4719   edir->tls_mask |= eind->tls_mask;
4720   if (eind->oh != NULL)
4721     edir->oh = ppc_follow_link (eind->oh);
4722
4723   /* If called to transfer flags for a weakdef during processing
4724      of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4725      We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
4726   if (!(ELIMINATE_COPY_RELOCS
4727         && eind->elf.root.type != bfd_link_hash_indirect
4728         && edir->elf.dynamic_adjusted))
4729     edir->elf.non_got_ref |= eind->elf.non_got_ref;
4730
4731   edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4732   edir->elf.ref_regular |= eind->elf.ref_regular;
4733   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4734   edir->elf.needs_plt |= eind->elf.needs_plt;
4735   edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4736
4737   /* Copy over any dynamic relocs we may have on the indirect sym.  */
4738   if (eind->dyn_relocs != NULL)
4739     {
4740       if (edir->dyn_relocs != NULL)
4741         {
4742           struct elf_dyn_relocs **pp;
4743           struct elf_dyn_relocs *p;
4744
4745           /* Add reloc counts against the indirect sym to the direct sym
4746              list.  Merge any entries against the same section.  */
4747           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4748             {
4749               struct elf_dyn_relocs *q;
4750
4751               for (q = edir->dyn_relocs; q != NULL; q = q->next)
4752                 if (q->sec == p->sec)
4753                   {
4754                     q->pc_count += p->pc_count;
4755                     q->count += p->count;
4756                     *pp = p->next;
4757                     break;
4758                   }
4759               if (q == NULL)
4760                 pp = &p->next;
4761             }
4762           *pp = edir->dyn_relocs;
4763         }
4764
4765       edir->dyn_relocs = eind->dyn_relocs;
4766       eind->dyn_relocs = NULL;
4767     }
4768
4769   /* If we were called to copy over info for a weak sym, that's all.
4770      You might think dyn_relocs need not be copied over;  After all,
4771      both syms will be dynamic or both non-dynamic so we're just
4772      moving reloc accounting around.  However, ELIMINATE_COPY_RELOCS
4773      code in ppc64_elf_adjust_dynamic_symbol needs to check for
4774      dyn_relocs in read-only sections, and it does so on what is the
4775      DIR sym here.  */
4776   if (eind->elf.root.type != bfd_link_hash_indirect)
4777     return;
4778
4779   /* Copy over got entries that we may have already seen to the
4780      symbol which just became indirect.  */
4781   if (eind->elf.got.glist != NULL)
4782     {
4783       if (edir->elf.got.glist != NULL)
4784         {
4785           struct got_entry **entp;
4786           struct got_entry *ent;
4787
4788           for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4789             {
4790               struct got_entry *dent;
4791
4792               for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4793                 if (dent->addend == ent->addend
4794                     && dent->owner == ent->owner
4795                     && dent->tls_type == ent->tls_type)
4796                   {
4797                     dent->got.refcount += ent->got.refcount;
4798                     *entp = ent->next;
4799                     break;
4800                   }
4801               if (dent == NULL)
4802                 entp = &ent->next;
4803             }
4804           *entp = edir->elf.got.glist;
4805         }
4806
4807       edir->elf.got.glist = eind->elf.got.glist;
4808       eind->elf.got.glist = NULL;
4809     }
4810
4811   /* And plt entries.  */
4812   move_plt_plist (eind, edir);
4813
4814   if (eind->elf.dynindx != -1)
4815     {
4816       if (edir->elf.dynindx != -1)
4817         _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4818                                 edir->elf.dynstr_index);
4819       edir->elf.dynindx = eind->elf.dynindx;
4820       edir->elf.dynstr_index = eind->elf.dynstr_index;
4821       eind->elf.dynindx = -1;
4822       eind->elf.dynstr_index = 0;
4823     }
4824 }
4825
4826 /* Find the function descriptor hash entry from the given function code
4827    hash entry FH.  Link the entries via their OH fields.  */
4828
4829 static struct ppc_link_hash_entry *
4830 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4831 {
4832   struct ppc_link_hash_entry *fdh = fh->oh;
4833
4834   if (fdh == NULL)
4835     {
4836       const char *fd_name = fh->elf.root.root.string + 1;
4837
4838       fdh = (struct ppc_link_hash_entry *)
4839         elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4840       if (fdh == NULL)
4841         return fdh;
4842
4843       fdh->is_func_descriptor = 1;
4844       fdh->oh = fh;
4845       fh->is_func = 1;
4846       fh->oh = fdh;
4847     }
4848
4849   return ppc_follow_link (fdh);
4850 }
4851
4852 /* Make a fake function descriptor sym for the code sym FH.  */
4853
4854 static struct ppc_link_hash_entry *
4855 make_fdh (struct bfd_link_info *info,
4856           struct ppc_link_hash_entry *fh)
4857 {
4858   bfd *abfd;
4859   asymbol *newsym;
4860   struct bfd_link_hash_entry *bh;
4861   struct ppc_link_hash_entry *fdh;
4862
4863   abfd = fh->elf.root.u.undef.abfd;
4864   newsym = bfd_make_empty_symbol (abfd);
4865   newsym->name = fh->elf.root.root.string + 1;
4866   newsym->section = bfd_und_section_ptr;
4867   newsym->value = 0;
4868   newsym->flags = BSF_WEAK;
4869
4870   bh = NULL;
4871   if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4872                                          newsym->flags, newsym->section,
4873                                          newsym->value, NULL, FALSE, FALSE,
4874                                          &bh))
4875     return NULL;
4876
4877   fdh = (struct ppc_link_hash_entry *) bh;
4878   fdh->elf.non_elf = 0;
4879   fdh->fake = 1;
4880   fdh->is_func_descriptor = 1;
4881   fdh->oh = fh;
4882   fh->is_func = 1;
4883   fh->oh = fdh;
4884   return fdh;
4885 }
4886
4887 /* Fix function descriptor symbols defined in .opd sections to be
4888    function type.  */
4889
4890 static bfd_boolean
4891 ppc64_elf_add_symbol_hook (bfd *ibfd,
4892                            struct bfd_link_info *info,
4893                            Elf_Internal_Sym *isym,
4894                            const char **name,
4895                            flagword *flags ATTRIBUTE_UNUSED,
4896                            asection **sec,
4897                            bfd_vma *value)
4898 {
4899   if ((ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4900        || ELF_ST_BIND (isym->st_info) == STB_GNU_UNIQUE)
4901       && (ibfd->flags & DYNAMIC) == 0
4902       && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
4903     elf_tdata (info->output_bfd)->has_gnu_symbols = elf_gnu_symbol_any;
4904
4905   if (*sec != NULL
4906       && strcmp ((*sec)->name, ".opd") == 0)
4907     {
4908       asection *code_sec;
4909
4910       if (!(ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4911             || ELF_ST_TYPE (isym->st_info) == STT_FUNC))
4912         isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4913
4914       /* If the symbol is a function defined in .opd, and the function
4915          code is in a discarded group, let it appear to be undefined.  */
4916       if (!bfd_link_relocatable (info)
4917           && (*sec)->reloc_count != 0
4918           && opd_entry_value (*sec, *value, &code_sec, NULL,
4919                               FALSE) != (bfd_vma) -1
4920           && discarded_section (code_sec))
4921         {
4922           *sec = bfd_und_section_ptr;
4923           isym->st_shndx = SHN_UNDEF;
4924         }
4925     }
4926   else if (*sec != NULL
4927            && strcmp ((*sec)->name, ".toc") == 0
4928            && ELF_ST_TYPE (isym->st_info) == STT_OBJECT)
4929     {
4930       struct ppc_link_hash_table *htab = ppc_hash_table (info);
4931       if (htab != NULL)
4932         htab->params->object_in_toc = 1;
4933     }
4934
4935   if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4936     {
4937       if (abiversion (ibfd) == 0)
4938         set_abiversion (ibfd, 2);
4939       else if (abiversion (ibfd) == 1)
4940         {
4941           info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other"
4942                                     " for ABI version 1\n"), name);
4943           bfd_set_error (bfd_error_bad_value);
4944           return FALSE;
4945         }
4946     }
4947
4948   return TRUE;
4949 }
4950
4951 /* Merge non-visibility st_other attributes: local entry point.  */
4952
4953 static void
4954 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
4955                                   const Elf_Internal_Sym *isym,
4956                                   bfd_boolean definition,
4957                                   bfd_boolean dynamic)
4958 {
4959   if (definition && !dynamic)
4960     h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
4961                 | ELF_ST_VISIBILITY (h->other));
4962 }
4963
4964 /* This function makes an old ABI object reference to ".bar" cause the
4965    inclusion of a new ABI object archive that defines "bar".
4966    NAME is a symbol defined in an archive.  Return a symbol in the hash
4967    table that might be satisfied by the archive symbols.  */
4968
4969 static struct elf_link_hash_entry *
4970 ppc64_elf_archive_symbol_lookup (bfd *abfd,
4971                                  struct bfd_link_info *info,
4972                                  const char *name)
4973 {
4974   struct elf_link_hash_entry *h;
4975   char *dot_name;
4976   size_t len;
4977
4978   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4979   if (h != NULL
4980       /* Don't return this sym if it is a fake function descriptor
4981          created by add_symbol_adjust.  */
4982       && !(h->root.type == bfd_link_hash_undefweak
4983            && ((struct ppc_link_hash_entry *) h)->fake))
4984     return h;
4985
4986   if (name[0] == '.')
4987     return h;
4988
4989   len = strlen (name);
4990   dot_name = bfd_alloc (abfd, len + 2);
4991   if (dot_name == NULL)
4992     return (struct elf_link_hash_entry *) 0 - 1;
4993   dot_name[0] = '.';
4994   memcpy (dot_name + 1, name, len + 1);
4995   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4996   bfd_release (abfd, dot_name);
4997   return h;
4998 }
4999
5000 /* This function satisfies all old ABI object references to ".bar" if a
5001    new ABI object defines "bar".  Well, at least, undefined dot symbols
5002    are made weak.  This stops later archive searches from including an
5003    object if we already have a function descriptor definition.  It also
5004    prevents the linker complaining about undefined symbols.
5005    We also check and correct mismatched symbol visibility here.  The
5006    most restrictive visibility of the function descriptor and the
5007    function entry symbol is used.  */
5008
5009 static bfd_boolean
5010 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
5011 {
5012   struct ppc_link_hash_table *htab;
5013   struct ppc_link_hash_entry *fdh;
5014
5015   if (eh->elf.root.type == bfd_link_hash_indirect)
5016     return TRUE;
5017
5018   if (eh->elf.root.type == bfd_link_hash_warning)
5019     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
5020
5021   if (eh->elf.root.root.string[0] != '.')
5022     abort ();
5023
5024   htab = ppc_hash_table (info);
5025   if (htab == NULL)
5026     return FALSE;
5027
5028   fdh = lookup_fdh (eh, htab);
5029   if (fdh == NULL)
5030     {
5031       if (!bfd_link_relocatable (info)
5032           && (eh->elf.root.type == bfd_link_hash_undefined
5033               || eh->elf.root.type == bfd_link_hash_undefweak)
5034           && eh->elf.ref_regular)
5035         {
5036           /* Make an undefweak function descriptor sym, which is enough to
5037              pull in an --as-needed shared lib, but won't cause link
5038              errors.  Archives are handled elsewhere.  */
5039           fdh = make_fdh (info, eh);
5040           if (fdh == NULL)
5041             return FALSE;
5042           fdh->elf.ref_regular = 1;
5043         }
5044     }
5045   else
5046     {
5047       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
5048       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
5049       if (entry_vis < descr_vis)
5050         fdh->elf.other += entry_vis - descr_vis;
5051       else if (entry_vis > descr_vis)
5052         eh->elf.other += descr_vis - entry_vis;
5053
5054       if ((fdh->elf.root.type == bfd_link_hash_defined
5055            || fdh->elf.root.type == bfd_link_hash_defweak)
5056           && eh->elf.root.type == bfd_link_hash_undefined)
5057         {
5058           eh->elf.root.type = bfd_link_hash_undefweak;
5059           eh->was_undefined = 1;
5060           htab->twiddled_syms = 1;
5061         }
5062     }
5063
5064   return TRUE;
5065 }
5066
5067 /* Set up opd section info and abiversion for IBFD, and process list
5068    of dot-symbols we made in link_hash_newfunc.  */
5069
5070 static bfd_boolean
5071 ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
5072 {
5073   struct ppc_link_hash_table *htab;
5074   struct ppc_link_hash_entry **p, *eh;
5075   asection *opd = bfd_get_section_by_name (ibfd, ".opd");
5076
5077   if (opd != NULL && opd->size != 0)
5078     {
5079       if (abiversion (ibfd) == 0)
5080         set_abiversion (ibfd, 1);
5081       else if (abiversion (ibfd) == 2)
5082         {
5083           info->callbacks->einfo (_("%P: %B .opd not allowed in ABI"
5084                                     " version %d\n"),
5085                                   ibfd, abiversion (ibfd));
5086           bfd_set_error (bfd_error_bad_value);
5087           return FALSE;
5088         }
5089
5090       if ((ibfd->flags & DYNAMIC) == 0
5091           && (opd->flags & SEC_RELOC) != 0
5092           && opd->reloc_count != 0
5093           && !bfd_is_abs_section (opd->output_section))
5094         {
5095           /* Garbage collection needs some extra help with .opd sections.
5096              We don't want to necessarily keep everything referenced by
5097              relocs in .opd, as that would keep all functions.  Instead,
5098              if we reference an .opd symbol (a function descriptor), we
5099              want to keep the function code symbol's section.  This is
5100              easy for global symbols, but for local syms we need to keep
5101              information about the associated function section.  */
5102           bfd_size_type amt;
5103           asection **opd_sym_map;
5104
5105           amt = OPD_NDX (opd->size) * sizeof (*opd_sym_map);
5106           opd_sym_map = bfd_zalloc (ibfd, amt);
5107           if (opd_sym_map == NULL)
5108             return FALSE;
5109           ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
5110           BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
5111           ppc64_elf_section_data (opd)->sec_type = sec_opd;
5112         }
5113     }
5114
5115   if (!is_ppc64_elf (info->output_bfd))
5116     return TRUE;
5117   htab = ppc_hash_table (info);
5118   if (htab == NULL)
5119     return FALSE;
5120
5121   /* For input files without an explicit abiversion in e_flags
5122      we should have flagged any with symbol st_other bits set
5123      as ELFv1 and above flagged those with .opd as ELFv2.
5124      Set the output abiversion if not yet set, and for any input
5125      still ambiguous, take its abiversion from the output.
5126      Differences in ABI are reported later.  */
5127   if (abiversion (info->output_bfd) == 0)
5128     set_abiversion (info->output_bfd, abiversion (ibfd));
5129   else if (abiversion (ibfd) == 0)
5130     set_abiversion (ibfd, abiversion (info->output_bfd));
5131
5132   p = &htab->dot_syms;
5133   while ((eh = *p) != NULL)
5134     {
5135       *p = NULL;
5136       if (&eh->elf == htab->elf.hgot)
5137         ;
5138       else if (htab->elf.hgot == NULL
5139                && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
5140         htab->elf.hgot = &eh->elf;
5141       else if (!add_symbol_adjust (eh, info))
5142         return FALSE;
5143       p = &eh->u.next_dot_sym;
5144     }
5145
5146   /* Clear the list for non-ppc64 input files.  */
5147   p = &htab->dot_syms;
5148   while ((eh = *p) != NULL)
5149     {
5150       *p = NULL;
5151       p = &eh->u.next_dot_sym;
5152     }
5153
5154   /* We need to fix the undefs list for any syms we have twiddled to
5155      undef_weak.  */
5156   if (htab->twiddled_syms)
5157     {
5158       bfd_link_repair_undef_list (&htab->elf.root);
5159       htab->twiddled_syms = 0;
5160     }
5161   return TRUE;
5162 }
5163
5164 /* Undo hash table changes when an --as-needed input file is determined
5165    not to be needed.  */
5166
5167 static bfd_boolean
5168 ppc64_elf_notice_as_needed (bfd *ibfd,
5169                             struct bfd_link_info *info,
5170                             enum notice_asneeded_action act)
5171 {
5172   if (act == notice_not_needed)
5173     {
5174       struct ppc_link_hash_table *htab = ppc_hash_table (info);
5175
5176       if (htab == NULL)
5177         return FALSE;
5178
5179       htab->dot_syms = NULL;
5180     }
5181   return _bfd_elf_notice_as_needed (ibfd, info, act);
5182 }
5183
5184 /* If --just-symbols against a final linked binary, then assume we need
5185    toc adjusting stubs when calling functions defined there.  */
5186
5187 static void
5188 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5189 {
5190   if ((sec->flags & SEC_CODE) != 0
5191       && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5192       && is_ppc64_elf (sec->owner))
5193     {
5194       if (abiversion (sec->owner) >= 2
5195           || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5196         sec->has_toc_reloc = 1;
5197     }
5198   _bfd_elf_link_just_syms (sec, info);
5199 }
5200
5201 static struct plt_entry **
5202 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5203                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5204 {
5205   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5206   struct plt_entry **local_plt;
5207   unsigned char *local_got_tls_masks;
5208
5209   if (local_got_ents == NULL)
5210     {
5211       bfd_size_type size = symtab_hdr->sh_info;
5212
5213       size *= (sizeof (*local_got_ents)
5214                + sizeof (*local_plt)
5215                + sizeof (*local_got_tls_masks));
5216       local_got_ents = bfd_zalloc (abfd, size);
5217       if (local_got_ents == NULL)
5218         return NULL;
5219       elf_local_got_ents (abfd) = local_got_ents;
5220     }
5221
5222   if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
5223     {
5224       struct got_entry *ent;
5225
5226       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5227         if (ent->addend == r_addend
5228             && ent->owner == abfd
5229             && ent->tls_type == tls_type)
5230           break;
5231       if (ent == NULL)
5232         {
5233           bfd_size_type amt = sizeof (*ent);
5234           ent = bfd_alloc (abfd, amt);
5235           if (ent == NULL)
5236             return FALSE;
5237           ent->next = local_got_ents[r_symndx];
5238           ent->addend = r_addend;
5239           ent->owner = abfd;
5240           ent->tls_type = tls_type;
5241           ent->is_indirect = FALSE;
5242           ent->got.refcount = 0;
5243           local_got_ents[r_symndx] = ent;
5244         }
5245       ent->got.refcount += 1;
5246     }
5247
5248   local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5249   local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5250   local_got_tls_masks[r_symndx] |= tls_type;
5251
5252   return local_plt + r_symndx;
5253 }
5254
5255 static bfd_boolean
5256 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5257 {
5258   struct plt_entry *ent;
5259
5260   for (ent = *plist; ent != NULL; ent = ent->next)
5261     if (ent->addend == addend)
5262       break;
5263   if (ent == NULL)
5264     {
5265       bfd_size_type amt = sizeof (*ent);
5266       ent = bfd_alloc (abfd, amt);
5267       if (ent == NULL)
5268         return FALSE;
5269       ent->next = *plist;
5270       ent->addend = addend;
5271       ent->plt.refcount = 0;
5272       *plist = ent;
5273     }
5274   ent->plt.refcount += 1;
5275   return TRUE;
5276 }
5277
5278 static bfd_boolean
5279 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5280 {
5281   return (r_type == R_PPC64_REL24
5282           || r_type == R_PPC64_REL14
5283           || r_type == R_PPC64_REL14_BRTAKEN
5284           || r_type == R_PPC64_REL14_BRNTAKEN
5285           || r_type == R_PPC64_ADDR24
5286           || r_type == R_PPC64_ADDR14
5287           || r_type == R_PPC64_ADDR14_BRTAKEN
5288           || r_type == R_PPC64_ADDR14_BRNTAKEN);
5289 }
5290
5291 /* Look through the relocs for a section during the first phase, and
5292    calculate needed space in the global offset table, procedure
5293    linkage table, and dynamic reloc sections.  */
5294
5295 static bfd_boolean
5296 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5297                         asection *sec, const Elf_Internal_Rela *relocs)
5298 {
5299   struct ppc_link_hash_table *htab;
5300   Elf_Internal_Shdr *symtab_hdr;
5301   struct elf_link_hash_entry **sym_hashes;
5302   const Elf_Internal_Rela *rel;
5303   const Elf_Internal_Rela *rel_end;
5304   asection *sreloc;
5305   asection **opd_sym_map;
5306   struct elf_link_hash_entry *tga, *dottga;
5307
5308   if (bfd_link_relocatable (info))
5309     return TRUE;
5310
5311   /* Don't do anything special with non-loaded, non-alloced sections.
5312      In particular, any relocs in such sections should not affect GOT
5313      and PLT reference counting (ie. we don't allow them to create GOT
5314      or PLT entries), there's no possibility or desire to optimize TLS
5315      relocs, and there's not much point in propagating relocs to shared
5316      libs that the dynamic linker won't relocate.  */
5317   if ((sec->flags & SEC_ALLOC) == 0)
5318     return TRUE;
5319
5320   BFD_ASSERT (is_ppc64_elf (abfd));
5321
5322   htab = ppc_hash_table (info);
5323   if (htab == NULL)
5324     return FALSE;
5325
5326   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5327                               FALSE, FALSE, TRUE);
5328   dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5329                                  FALSE, FALSE, TRUE);
5330   symtab_hdr = &elf_symtab_hdr (abfd);
5331   sym_hashes = elf_sym_hashes (abfd);
5332   sreloc = NULL;
5333   opd_sym_map = NULL;
5334   if (ppc64_elf_section_data (sec) != NULL
5335       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
5336     opd_sym_map = ppc64_elf_section_data (sec)->u.opd.func_sec;
5337
5338   rel_end = relocs + sec->reloc_count;
5339   for (rel = relocs; rel < rel_end; rel++)
5340     {
5341       unsigned long r_symndx;
5342       struct elf_link_hash_entry *h;
5343       enum elf_ppc64_reloc_type r_type;
5344       int tls_type;
5345       struct _ppc64_elf_section_data *ppc64_sec;
5346       struct plt_entry **ifunc, **plt_list;
5347
5348       r_symndx = ELF64_R_SYM (rel->r_info);
5349       if (r_symndx < symtab_hdr->sh_info)
5350         h = NULL;
5351       else
5352         {
5353           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5354           h = elf_follow_link (h);
5355
5356           /* PR15323, ref flags aren't set for references in the same
5357              object.  */
5358           h->root.non_ir_ref = 1;
5359
5360           if (h == htab->elf.hgot)
5361             sec->has_toc_reloc = 1;
5362         }
5363
5364       tls_type = 0;
5365       ifunc = NULL;
5366       if (h != NULL)
5367         {
5368           if (h->type == STT_GNU_IFUNC)
5369             {
5370               h->needs_plt = 1;
5371               ifunc = &h->plt.plist;
5372             }
5373         }
5374       else
5375         {
5376           Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5377                                                           abfd, r_symndx);
5378           if (isym == NULL)
5379             return FALSE;
5380
5381           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5382             {
5383               ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5384                                              rel->r_addend, PLT_IFUNC);
5385               if (ifunc == NULL)
5386                 return FALSE;
5387             }
5388         }
5389
5390       r_type = ELF64_R_TYPE (rel->r_info);
5391       switch (r_type)
5392         {
5393         case R_PPC64_TLSGD:
5394         case R_PPC64_TLSLD:
5395           /* These special tls relocs tie a call to __tls_get_addr with
5396              its parameter symbol.  */
5397           break;
5398
5399         case R_PPC64_GOT_TLSLD16:
5400         case R_PPC64_GOT_TLSLD16_LO:
5401         case R_PPC64_GOT_TLSLD16_HI:
5402         case R_PPC64_GOT_TLSLD16_HA:
5403           tls_type = TLS_TLS | TLS_LD;
5404           goto dogottls;
5405
5406         case R_PPC64_GOT_TLSGD16:
5407         case R_PPC64_GOT_TLSGD16_LO:
5408         case R_PPC64_GOT_TLSGD16_HI:
5409         case R_PPC64_GOT_TLSGD16_HA:
5410           tls_type = TLS_TLS | TLS_GD;
5411           goto dogottls;
5412
5413         case R_PPC64_GOT_TPREL16_DS:
5414         case R_PPC64_GOT_TPREL16_LO_DS:
5415         case R_PPC64_GOT_TPREL16_HI:
5416         case R_PPC64_GOT_TPREL16_HA:
5417           if (bfd_link_pic (info))
5418             info->flags |= DF_STATIC_TLS;
5419           tls_type = TLS_TLS | TLS_TPREL;
5420           goto dogottls;
5421
5422         case R_PPC64_GOT_DTPREL16_DS:
5423         case R_PPC64_GOT_DTPREL16_LO_DS:
5424         case R_PPC64_GOT_DTPREL16_HI:
5425         case R_PPC64_GOT_DTPREL16_HA:
5426           tls_type = TLS_TLS | TLS_DTPREL;
5427         dogottls:
5428           sec->has_tls_reloc = 1;
5429           /* Fall thru */
5430
5431         case R_PPC64_GOT16:
5432         case R_PPC64_GOT16_DS:
5433         case R_PPC64_GOT16_HA:
5434         case R_PPC64_GOT16_HI:
5435         case R_PPC64_GOT16_LO:
5436         case R_PPC64_GOT16_LO_DS:
5437           /* This symbol requires a global offset table entry.  */
5438           sec->has_toc_reloc = 1;
5439           if (r_type == R_PPC64_GOT_TLSLD16
5440               || r_type == R_PPC64_GOT_TLSGD16
5441               || r_type == R_PPC64_GOT_TPREL16_DS
5442               || r_type == R_PPC64_GOT_DTPREL16_DS
5443               || r_type == R_PPC64_GOT16
5444               || r_type == R_PPC64_GOT16_DS)
5445             {
5446               htab->do_multi_toc = 1;
5447               ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5448             }
5449
5450           if (ppc64_elf_tdata (abfd)->got == NULL
5451               && !create_got_section (abfd, info))
5452             return FALSE;
5453
5454           if (h != NULL)
5455             {
5456               struct ppc_link_hash_entry *eh;
5457               struct got_entry *ent;
5458
5459               eh = (struct ppc_link_hash_entry *) h;
5460               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5461                 if (ent->addend == rel->r_addend
5462                     && ent->owner == abfd
5463                     && ent->tls_type == tls_type)
5464                   break;
5465               if (ent == NULL)
5466                 {
5467                   bfd_size_type amt = sizeof (*ent);
5468                   ent = bfd_alloc (abfd, amt);
5469                   if (ent == NULL)
5470                     return FALSE;
5471                   ent->next = eh->elf.got.glist;
5472                   ent->addend = rel->r_addend;
5473                   ent->owner = abfd;
5474                   ent->tls_type = tls_type;
5475                   ent->is_indirect = FALSE;
5476                   ent->got.refcount = 0;
5477                   eh->elf.got.glist = ent;
5478                 }
5479               ent->got.refcount += 1;
5480               eh->tls_mask |= tls_type;
5481             }
5482           else
5483             /* This is a global offset table entry for a local symbol.  */
5484             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5485                                         rel->r_addend, tls_type))
5486               return FALSE;
5487
5488           /* We may also need a plt entry if the symbol turns out to be
5489              an ifunc.  */
5490           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1)
5491             {
5492               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5493                 return FALSE;
5494             }
5495           break;
5496
5497         case R_PPC64_PLT16_HA:
5498         case R_PPC64_PLT16_HI:
5499         case R_PPC64_PLT16_LO:
5500         case R_PPC64_PLT32:
5501         case R_PPC64_PLT64:
5502           /* This symbol requires a procedure linkage table entry.  */
5503           plt_list = ifunc;
5504           if (h != NULL)
5505             {
5506               h->needs_plt = 1;
5507               if (h->root.root.string[0] == '.'
5508                   && h->root.root.string[1] != '\0')
5509                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5510               plt_list = &h->plt.plist;
5511             }
5512           if (plt_list == NULL)
5513             {
5514               /* It does not make sense to have a procedure linkage
5515                  table entry for a non-ifunc local symbol.  */
5516               info->callbacks->einfo
5517                 (_("%P: %H: %s reloc against local symbol\n"),
5518                  abfd, sec, rel->r_offset,
5519                  ppc64_elf_howto_table[r_type]->name);
5520               bfd_set_error (bfd_error_bad_value);
5521               return FALSE;
5522             }
5523           if (!update_plt_info (abfd, plt_list, rel->r_addend))
5524             return FALSE;
5525           break;
5526
5527           /* The following relocations don't need to propagate the
5528              relocation if linking a shared object since they are
5529              section relative.  */
5530         case R_PPC64_SECTOFF:
5531         case R_PPC64_SECTOFF_LO:
5532         case R_PPC64_SECTOFF_HI:
5533         case R_PPC64_SECTOFF_HA:
5534         case R_PPC64_SECTOFF_DS:
5535         case R_PPC64_SECTOFF_LO_DS:
5536         case R_PPC64_DTPREL16:
5537         case R_PPC64_DTPREL16_LO:
5538         case R_PPC64_DTPREL16_HI:
5539         case R_PPC64_DTPREL16_HA:
5540         case R_PPC64_DTPREL16_DS:
5541         case R_PPC64_DTPREL16_LO_DS:
5542         case R_PPC64_DTPREL16_HIGH:
5543         case R_PPC64_DTPREL16_HIGHA:
5544         case R_PPC64_DTPREL16_HIGHER:
5545         case R_PPC64_DTPREL16_HIGHERA:
5546         case R_PPC64_DTPREL16_HIGHEST:
5547         case R_PPC64_DTPREL16_HIGHESTA:
5548           break;
5549
5550           /* Nor do these.  */
5551         case R_PPC64_REL16:
5552         case R_PPC64_REL16_LO:
5553         case R_PPC64_REL16_HI:
5554         case R_PPC64_REL16_HA:
5555         case R_PPC64_REL16DX_HA:
5556           break;
5557
5558           /* Not supported as a dynamic relocation.  */
5559         case R_PPC64_ADDR64_LOCAL:
5560           if (bfd_link_pic (info))
5561             {
5562               if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5563                 ppc_howto_init ();
5564               info->callbacks->einfo (_("%P: %H: %s reloc unsupported "
5565                                         "in shared libraries and PIEs.\n"),
5566                                       abfd, sec, rel->r_offset,
5567                                       ppc64_elf_howto_table[r_type]->name);
5568               bfd_set_error (bfd_error_bad_value);
5569               return FALSE;
5570             }
5571           break;
5572
5573         case R_PPC64_TOC16:
5574         case R_PPC64_TOC16_DS:
5575           htab->do_multi_toc = 1;
5576           ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5577         case R_PPC64_TOC16_LO:
5578         case R_PPC64_TOC16_HI:
5579         case R_PPC64_TOC16_HA:
5580         case R_PPC64_TOC16_LO_DS:
5581           sec->has_toc_reloc = 1;
5582           break;
5583
5584           /* Marker reloc.  */
5585         case R_PPC64_ENTRY:
5586           break;
5587
5588           /* This relocation describes the C++ object vtable hierarchy.
5589              Reconstruct it for later use during GC.  */
5590         case R_PPC64_GNU_VTINHERIT:
5591           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5592             return FALSE;
5593           break;
5594
5595           /* This relocation describes which C++ vtable entries are actually
5596              used.  Record for later use during GC.  */
5597         case R_PPC64_GNU_VTENTRY:
5598           BFD_ASSERT (h != NULL);
5599           if (h != NULL
5600               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5601             return FALSE;
5602           break;
5603
5604         case R_PPC64_REL14:
5605         case R_PPC64_REL14_BRTAKEN:
5606         case R_PPC64_REL14_BRNTAKEN:
5607           {
5608             asection *dest = NULL;
5609
5610             /* Heuristic: If jumping outside our section, chances are
5611                we are going to need a stub.  */
5612             if (h != NULL)
5613               {
5614                 /* If the sym is weak it may be overridden later, so
5615                    don't assume we know where a weak sym lives.  */
5616                 if (h->root.type == bfd_link_hash_defined)
5617                   dest = h->root.u.def.section;
5618               }
5619             else
5620               {
5621                 Elf_Internal_Sym *isym;
5622
5623                 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5624                                               abfd, r_symndx);
5625                 if (isym == NULL)
5626                   return FALSE;
5627
5628                 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5629               }
5630
5631             if (dest != sec)
5632               ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5633           }
5634           /* Fall through.  */
5635
5636         case R_PPC64_REL24:
5637           plt_list = ifunc;
5638           if (h != NULL)
5639             {
5640               h->needs_plt = 1;
5641               if (h->root.root.string[0] == '.'
5642                   && h->root.root.string[1] != '\0')
5643                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5644
5645               if (h == tga || h == dottga)
5646                 {
5647                   sec->has_tls_reloc = 1;
5648                   if (rel != relocs
5649                       && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5650                           || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5651                     /* We have a new-style __tls_get_addr call with
5652                        a marker reloc.  */
5653                     ;
5654                   else
5655                     /* Mark this section as having an old-style call.  */
5656                     sec->has_tls_get_addr_call = 1;
5657                 }
5658               plt_list = &h->plt.plist;
5659             }
5660
5661           /* We may need a .plt entry if the function this reloc
5662              refers to is in a shared lib.  */
5663           if (plt_list
5664               && !update_plt_info (abfd, plt_list, rel->r_addend))
5665             return FALSE;
5666           break;
5667
5668         case R_PPC64_ADDR14:
5669         case R_PPC64_ADDR14_BRNTAKEN:
5670         case R_PPC64_ADDR14_BRTAKEN:
5671         case R_PPC64_ADDR24:
5672           goto dodyn;
5673
5674         case R_PPC64_TPREL64:
5675           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5676           if (bfd_link_pic (info))
5677             info->flags |= DF_STATIC_TLS;
5678           goto dotlstoc;
5679
5680         case R_PPC64_DTPMOD64:
5681           if (rel + 1 < rel_end
5682               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5683               && rel[1].r_offset == rel->r_offset + 8)
5684             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5685           else
5686             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5687           goto dotlstoc;
5688
5689         case R_PPC64_DTPREL64:
5690           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5691           if (rel != relocs
5692               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5693               && rel[-1].r_offset == rel->r_offset - 8)
5694             /* This is the second reloc of a dtpmod, dtprel pair.
5695                Don't mark with TLS_DTPREL.  */
5696             goto dodyn;
5697
5698         dotlstoc:
5699           sec->has_tls_reloc = 1;
5700           if (h != NULL)
5701             {
5702               struct ppc_link_hash_entry *eh;
5703               eh = (struct ppc_link_hash_entry *) h;
5704               eh->tls_mask |= tls_type;
5705             }
5706           else
5707             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5708                                         rel->r_addend, tls_type))
5709               return FALSE;
5710
5711           ppc64_sec = ppc64_elf_section_data (sec);
5712           if (ppc64_sec->sec_type != sec_toc)
5713             {
5714               bfd_size_type amt;
5715
5716               /* One extra to simplify get_tls_mask.  */
5717               amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5718               ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5719               if (ppc64_sec->u.toc.symndx == NULL)
5720                 return FALSE;
5721               amt = sec->size * sizeof (bfd_vma) / 8;
5722               ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5723               if (ppc64_sec->u.toc.add == NULL)
5724                 return FALSE;
5725               BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5726               ppc64_sec->sec_type = sec_toc;
5727             }
5728           BFD_ASSERT (rel->r_offset % 8 == 0);
5729           ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5730           ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5731
5732           /* Mark the second slot of a GD or LD entry.
5733              -1 to indicate GD and -2 to indicate LD.  */
5734           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5735             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5736           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5737             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5738           goto dodyn;
5739
5740         case R_PPC64_TPREL16:
5741         case R_PPC64_TPREL16_LO:
5742         case R_PPC64_TPREL16_HI:
5743         case R_PPC64_TPREL16_HA:
5744         case R_PPC64_TPREL16_DS:
5745         case R_PPC64_TPREL16_LO_DS:
5746         case R_PPC64_TPREL16_HIGH:
5747         case R_PPC64_TPREL16_HIGHA:
5748         case R_PPC64_TPREL16_HIGHER:
5749         case R_PPC64_TPREL16_HIGHERA:
5750         case R_PPC64_TPREL16_HIGHEST:
5751         case R_PPC64_TPREL16_HIGHESTA:
5752           if (bfd_link_pic (info))
5753             {
5754               info->flags |= DF_STATIC_TLS;
5755               goto dodyn;
5756             }
5757           break;
5758
5759         case R_PPC64_ADDR64:
5760           if (opd_sym_map != NULL
5761               && rel + 1 < rel_end
5762               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5763             {
5764               if (h != NULL)
5765                 {
5766                   if (h->root.root.string[0] == '.'
5767                       && h->root.root.string[1] != 0
5768                       && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
5769                     ;
5770                   else
5771                     ((struct ppc_link_hash_entry *) h)->is_func = 1;
5772                 }
5773               else
5774                 {
5775                   asection *s;
5776                   Elf_Internal_Sym *isym;
5777
5778                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5779                                                 abfd, r_symndx);
5780                   if (isym == NULL)
5781                     return FALSE;
5782
5783                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5784                   if (s != NULL && s != sec)
5785                     opd_sym_map[OPD_NDX (rel->r_offset)] = s;
5786                 }
5787             }
5788           /* Fall through.  */
5789
5790         case R_PPC64_ADDR16:
5791         case R_PPC64_ADDR16_DS:
5792         case R_PPC64_ADDR16_HA:
5793         case R_PPC64_ADDR16_HI:
5794         case R_PPC64_ADDR16_HIGH:
5795         case R_PPC64_ADDR16_HIGHA:
5796         case R_PPC64_ADDR16_HIGHER:
5797         case R_PPC64_ADDR16_HIGHERA:
5798         case R_PPC64_ADDR16_HIGHEST:
5799         case R_PPC64_ADDR16_HIGHESTA:
5800         case R_PPC64_ADDR16_LO:
5801         case R_PPC64_ADDR16_LO_DS:
5802           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1
5803               && rel->r_addend == 0)
5804             {
5805               /* We may need a .plt entry if this reloc refers to a
5806                  function in a shared lib.  */
5807               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5808                 return FALSE;
5809               h->pointer_equality_needed = 1;
5810             }
5811           /* Fall through.  */
5812
5813         case R_PPC64_REL30:
5814         case R_PPC64_REL32:
5815         case R_PPC64_REL64:
5816         case R_PPC64_ADDR32:
5817         case R_PPC64_UADDR16:
5818         case R_PPC64_UADDR32:
5819         case R_PPC64_UADDR64:
5820         case R_PPC64_TOC:
5821           if (h != NULL && !bfd_link_pic (info))
5822             /* We may need a copy reloc.  */
5823             h->non_got_ref = 1;
5824
5825           /* Don't propagate .opd relocs.  */
5826           if (NO_OPD_RELOCS && opd_sym_map != NULL)
5827             break;
5828
5829           /* If we are creating a shared library, and this is a reloc
5830              against a global symbol, or a non PC relative reloc
5831              against a local symbol, then we need to copy the reloc
5832              into the shared library.  However, if we are linking with
5833              -Bsymbolic, we do not need to copy a reloc against a
5834              global symbol which is defined in an object we are
5835              including in the link (i.e., DEF_REGULAR is set).  At
5836              this point we have not seen all the input files, so it is
5837              possible that DEF_REGULAR is not set now but will be set
5838              later (it is never cleared).  In case of a weak definition,
5839              DEF_REGULAR may be cleared later by a strong definition in
5840              a shared library.  We account for that possibility below by
5841              storing information in the dyn_relocs field of the hash
5842              table entry.  A similar situation occurs when creating
5843              shared libraries and symbol visibility changes render the
5844              symbol local.
5845
5846              If on the other hand, we are creating an executable, we
5847              may need to keep relocations for symbols satisfied by a
5848              dynamic library if we manage to avoid copy relocs for the
5849              symbol.  */
5850         dodyn:
5851           if ((bfd_link_pic (info)
5852                && (must_be_dyn_reloc (info, r_type)
5853                    || (h != NULL
5854                        && (!SYMBOLIC_BIND (info, h)
5855                            || h->root.type == bfd_link_hash_defweak
5856                            || !h->def_regular))))
5857               || (ELIMINATE_COPY_RELOCS
5858                   && !bfd_link_pic (info)
5859                   && h != NULL
5860                   && (h->root.type == bfd_link_hash_defweak
5861                       || !h->def_regular))
5862               || (!bfd_link_pic (info)
5863                   && ifunc != NULL))
5864             {
5865               /* We must copy these reloc types into the output file.
5866                  Create a reloc section in dynobj and make room for
5867                  this reloc.  */
5868               if (sreloc == NULL)
5869                 {
5870                   sreloc = _bfd_elf_make_dynamic_reloc_section
5871                     (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5872
5873                   if (sreloc == NULL)
5874                     return FALSE;
5875                 }
5876
5877               /* If this is a global symbol, we count the number of
5878                  relocations we need for this symbol.  */
5879               if (h != NULL)
5880                 {
5881                   struct elf_dyn_relocs *p;
5882                   struct elf_dyn_relocs **head;
5883
5884                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5885                   p = *head;
5886                   if (p == NULL || p->sec != sec)
5887                     {
5888                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5889                       if (p == NULL)
5890                         return FALSE;
5891                       p->next = *head;
5892                       *head = p;
5893                       p->sec = sec;
5894                       p->count = 0;
5895                       p->pc_count = 0;
5896                     }
5897                   p->count += 1;
5898                   if (!must_be_dyn_reloc (info, r_type))
5899                     p->pc_count += 1;
5900                 }
5901               else
5902                 {
5903                   /* Track dynamic relocs needed for local syms too.
5904                      We really need local syms available to do this
5905                      easily.  Oh well.  */
5906                   struct ppc_dyn_relocs *p;
5907                   struct ppc_dyn_relocs **head;
5908                   bfd_boolean is_ifunc;
5909                   asection *s;
5910                   void *vpp;
5911                   Elf_Internal_Sym *isym;
5912
5913                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5914                                                 abfd, r_symndx);
5915                   if (isym == NULL)
5916                     return FALSE;
5917
5918                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5919                   if (s == NULL)
5920                     s = sec;
5921
5922                   vpp = &elf_section_data (s)->local_dynrel;
5923                   head = (struct ppc_dyn_relocs **) vpp;
5924                   is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5925                   p = *head;
5926                   if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5927                     p = p->next;
5928                   if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5929                     {
5930                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5931                       if (p == NULL)
5932                         return FALSE;
5933                       p->next = *head;
5934                       *head = p;
5935                       p->sec = sec;
5936                       p->ifunc = is_ifunc;
5937                       p->count = 0;
5938                     }
5939                   p->count += 1;
5940                 }
5941             }
5942           break;
5943
5944         default:
5945           break;
5946         }
5947     }
5948
5949   return TRUE;
5950 }
5951
5952 /* Merge backend specific data from an object file to the output
5953    object file when linking.  */
5954
5955 static bfd_boolean
5956 ppc64_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
5957 {
5958   unsigned long iflags, oflags;
5959
5960   if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
5961     return TRUE;
5962
5963   if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
5964     return TRUE;
5965
5966   if (!_bfd_generic_verify_endian_match (ibfd, obfd))
5967     return FALSE;
5968
5969   iflags = elf_elfheader (ibfd)->e_flags;
5970   oflags = elf_elfheader (obfd)->e_flags;
5971
5972   if (iflags & ~EF_PPC64_ABI)
5973     {
5974       (*_bfd_error_handler)
5975         (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
5976       bfd_set_error (bfd_error_bad_value);
5977       return FALSE;
5978     }
5979   else if (iflags != oflags && iflags != 0)
5980     {
5981       (*_bfd_error_handler)
5982         (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
5983          ibfd, iflags, oflags);
5984       bfd_set_error (bfd_error_bad_value);
5985       return FALSE;
5986     }
5987
5988   /* Merge Tag_compatibility attributes and any common GNU ones.  */
5989   _bfd_elf_merge_object_attributes (ibfd, obfd);
5990
5991   return TRUE;
5992 }
5993
5994 static bfd_boolean
5995 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
5996 {
5997   /* Print normal ELF private data.  */
5998   _bfd_elf_print_private_bfd_data (abfd, ptr);
5999
6000   if (elf_elfheader (abfd)->e_flags != 0)
6001     {
6002       FILE *file = ptr;
6003
6004       /* xgettext:c-format */
6005       fprintf (file, _("private flags = 0x%lx:"),
6006                elf_elfheader (abfd)->e_flags);
6007
6008       if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
6009         fprintf (file, _(" [abiv%ld]"),
6010                  elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
6011       fputc ('\n', file);
6012     }
6013
6014   return TRUE;
6015 }
6016
6017 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
6018    of the code entry point, and its section, which must be in the same
6019    object as OPD_SEC.  Returns (bfd_vma) -1 on error.  */
6020
6021 static bfd_vma
6022 opd_entry_value (asection *opd_sec,
6023                  bfd_vma offset,
6024                  asection **code_sec,
6025                  bfd_vma *code_off,
6026                  bfd_boolean in_code_sec)
6027 {
6028   bfd *opd_bfd = opd_sec->owner;
6029   Elf_Internal_Rela *relocs;
6030   Elf_Internal_Rela *lo, *hi, *look;
6031   bfd_vma val;
6032
6033   /* No relocs implies we are linking a --just-symbols object, or looking
6034      at a final linked executable with addr2line or somesuch.  */
6035   if (opd_sec->reloc_count == 0)
6036     {
6037       bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
6038
6039       if (contents == NULL)
6040         {
6041           if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
6042             return (bfd_vma) -1;
6043           ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
6044         }
6045
6046       /* PR 17512: file: 64b9dfbb.  */
6047       if (offset + 7 >= opd_sec->size || offset + 7 < offset)
6048         return (bfd_vma) -1;
6049
6050       val = bfd_get_64 (opd_bfd, contents + offset);
6051       if (code_sec != NULL)
6052         {
6053           asection *sec, *likely = NULL;
6054
6055           if (in_code_sec)
6056             {
6057               sec = *code_sec;
6058               if (sec->vma <= val
6059                   && val < sec->vma + sec->size)
6060                 likely = sec;
6061               else
6062                 val = -1;
6063             }
6064           else
6065             for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
6066               if (sec->vma <= val
6067                   && (sec->flags & SEC_LOAD) != 0
6068                   && (sec->flags & SEC_ALLOC) != 0)
6069                 likely = sec;
6070           if (likely != NULL)
6071             {
6072               *code_sec = likely;
6073               if (code_off != NULL)
6074                 *code_off = val - likely->vma;
6075             }
6076         }
6077       return val;
6078     }
6079
6080   BFD_ASSERT (is_ppc64_elf (opd_bfd));
6081
6082   relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
6083   if (relocs == NULL)
6084     relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
6085   /* PR 17512: file: df8e1fd6.  */
6086   if (relocs == NULL)
6087     return (bfd_vma) -1;
6088
6089   /* Go find the opd reloc at the sym address.  */
6090   lo = relocs;
6091   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
6092   val = (bfd_vma) -1;
6093   while (lo < hi)
6094     {
6095       look = lo + (hi - lo) / 2;
6096       if (look->r_offset < offset)
6097         lo = look + 1;
6098       else if (look->r_offset > offset)
6099         hi = look;
6100       else
6101         {
6102           Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
6103
6104           if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
6105               && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
6106             {
6107               unsigned long symndx = ELF64_R_SYM (look->r_info);
6108               asection *sec = NULL;
6109
6110               if (symndx >= symtab_hdr->sh_info
6111                   && elf_sym_hashes (opd_bfd) != NULL)
6112                 {
6113                   struct elf_link_hash_entry **sym_hashes;
6114                   struct elf_link_hash_entry *rh;
6115
6116                   sym_hashes = elf_sym_hashes (opd_bfd);
6117                   rh = sym_hashes[symndx - symtab_hdr->sh_info];
6118                   if (rh != NULL)
6119                     {
6120                       rh = elf_follow_link (rh);
6121                       if (rh->root.type != bfd_link_hash_defined
6122                           && rh->root.type != bfd_link_hash_defweak)
6123                         break;
6124                       if (rh->root.u.def.section->owner == opd_bfd)
6125                         {
6126                           val = rh->root.u.def.value;
6127                           sec = rh->root.u.def.section;
6128                         }
6129                     }
6130                 }
6131
6132               if (sec == NULL)
6133                 {
6134                   Elf_Internal_Sym *sym;
6135
6136                   if (symndx < symtab_hdr->sh_info)
6137                     {
6138                       sym = (Elf_Internal_Sym *) symtab_hdr->contents;
6139                       if (sym == NULL)
6140                         {
6141                           size_t symcnt = symtab_hdr->sh_info;
6142                           sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6143                                                       symcnt, 0,
6144                                                       NULL, NULL, NULL);
6145                           if (sym == NULL)
6146                             break;
6147                           symtab_hdr->contents = (bfd_byte *) sym;
6148                         }
6149                       sym += symndx;
6150                     }
6151                   else
6152                     {
6153                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6154                                                   1, symndx,
6155                                                   NULL, NULL, NULL);
6156                       if (sym == NULL)
6157                         break;
6158                     }
6159                   sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6160                   if (sec == NULL)
6161                     break;
6162                   BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
6163                   val = sym->st_value;
6164                 }
6165
6166               val += look->r_addend;
6167               if (code_off != NULL)
6168                 *code_off = val;
6169               if (code_sec != NULL)
6170                 {
6171                   if (in_code_sec && *code_sec != sec)
6172                     return -1;
6173                   else
6174                     *code_sec = sec;
6175                 }
6176               if (sec->output_section != NULL)
6177                 val += sec->output_section->vma + sec->output_offset;
6178             }
6179           break;
6180         }
6181     }
6182
6183   return val;
6184 }
6185
6186 /* If the ELF symbol SYM might be a function in SEC, return the
6187    function size and set *CODE_OFF to the function's entry point,
6188    otherwise return zero.  */
6189
6190 static bfd_size_type
6191 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6192                               bfd_vma *code_off)
6193 {
6194   bfd_size_type size;
6195
6196   if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6197                      | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6198     return 0;
6199
6200   size = 0;
6201   if (!(sym->flags & BSF_SYNTHETIC))
6202     size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6203
6204   if (strcmp (sym->section->name, ".opd") == 0)
6205     {
6206       struct _opd_sec_data *opd = get_opd_info (sym->section);
6207       bfd_vma symval = sym->value;
6208
6209       if (opd != NULL
6210           && opd->adjust != NULL
6211           && elf_section_data (sym->section)->relocs != NULL)
6212         {
6213           /* opd_entry_value will use cached relocs that have been
6214              adjusted, but with raw symbols.  That means both local
6215              and global symbols need adjusting.  */
6216           long adjust = opd->adjust[OPD_NDX (symval)];
6217           if (adjust == -1)
6218             return 0;
6219           symval += adjust;
6220         }
6221
6222       if (opd_entry_value (sym->section, symval,
6223                            &sec, code_off, TRUE) == (bfd_vma) -1)
6224         return 0;
6225       /* An old ABI binary with dot-syms has a size of 24 on the .opd
6226          symbol.  This size has nothing to do with the code size of the
6227          function, which is what we're supposed to return, but the
6228          code size isn't available without looking up the dot-sym.
6229          However, doing that would be a waste of time particularly
6230          since elf_find_function will look at the dot-sym anyway.
6231          Now, elf_find_function will keep the largest size of any
6232          function sym found at the code address of interest, so return
6233          1 here to avoid it incorrectly caching a larger function size
6234          for a small function.  This does mean we return the wrong
6235          size for a new-ABI function of size 24, but all that does is
6236          disable caching for such functions.  */
6237       if (size == 24)
6238         size = 1;
6239     }
6240   else
6241     {
6242       if (sym->section != sec)
6243         return 0;
6244       *code_off = sym->value;
6245     }
6246   if (size == 0)
6247     size = 1;
6248   return size;
6249 }
6250
6251 /* Return true if symbol is defined in a regular object file.  */
6252
6253 static bfd_boolean
6254 is_static_defined (struct elf_link_hash_entry *h)
6255 {
6256   return ((h->root.type == bfd_link_hash_defined
6257            || h->root.type == bfd_link_hash_defweak)
6258           && h->root.u.def.section != NULL
6259           && h->root.u.def.section->output_section != NULL);
6260 }
6261
6262 /* If FDH is a function descriptor symbol, return the associated code
6263    entry symbol if it is defined.  Return NULL otherwise.  */
6264
6265 static struct ppc_link_hash_entry *
6266 defined_code_entry (struct ppc_link_hash_entry *fdh)
6267 {
6268   if (fdh->is_func_descriptor)
6269     {
6270       struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6271       if (fh->elf.root.type == bfd_link_hash_defined
6272           || fh->elf.root.type == bfd_link_hash_defweak)
6273         return fh;
6274     }
6275   return NULL;
6276 }
6277
6278 /* If FH is a function code entry symbol, return the associated
6279    function descriptor symbol if it is defined.  Return NULL otherwise.  */
6280
6281 static struct ppc_link_hash_entry *
6282 defined_func_desc (struct ppc_link_hash_entry *fh)
6283 {
6284   if (fh->oh != NULL
6285       && fh->oh->is_func_descriptor)
6286     {
6287       struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6288       if (fdh->elf.root.type == bfd_link_hash_defined
6289           || fdh->elf.root.type == bfd_link_hash_defweak)
6290         return fdh;
6291     }
6292   return NULL;
6293 }
6294
6295 /* Mark all our entry sym sections, both opd and code section.  */
6296
6297 static void
6298 ppc64_elf_gc_keep (struct bfd_link_info *info)
6299 {
6300   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6301   struct bfd_sym_chain *sym;
6302
6303   if (htab == NULL)
6304     return;
6305
6306   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6307     {
6308       struct ppc_link_hash_entry *eh, *fh;
6309       asection *sec;
6310
6311       eh = (struct ppc_link_hash_entry *)
6312         elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6313       if (eh == NULL)
6314         continue;
6315       if (eh->elf.root.type != bfd_link_hash_defined
6316           && eh->elf.root.type != bfd_link_hash_defweak)
6317         continue;
6318
6319       fh = defined_code_entry (eh);
6320       if (fh != NULL)
6321         {
6322           sec = fh->elf.root.u.def.section;
6323           sec->flags |= SEC_KEEP;
6324         }
6325       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6326                && opd_entry_value (eh->elf.root.u.def.section,
6327                                    eh->elf.root.u.def.value,
6328                                    &sec, NULL, FALSE) != (bfd_vma) -1)
6329         sec->flags |= SEC_KEEP;
6330
6331       sec = eh->elf.root.u.def.section;
6332       sec->flags |= SEC_KEEP;
6333     }
6334 }
6335
6336 /* Mark sections containing dynamically referenced symbols.  When
6337    building shared libraries, we must assume that any visible symbol is
6338    referenced.  */
6339
6340 static bfd_boolean
6341 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6342 {
6343   struct bfd_link_info *info = (struct bfd_link_info *) inf;
6344   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6345   struct ppc_link_hash_entry *fdh;
6346   struct bfd_elf_dynamic_list *d = info->dynamic_list;
6347
6348   /* Dynamic linking info is on the func descriptor sym.  */
6349   fdh = defined_func_desc (eh);
6350   if (fdh != NULL)
6351     eh = fdh;
6352
6353   if ((eh->elf.root.type == bfd_link_hash_defined
6354        || eh->elf.root.type == bfd_link_hash_defweak)
6355       && (eh->elf.ref_dynamic
6356           || ((eh->elf.def_regular || ELF_COMMON_DEF_P (&eh->elf))
6357               && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6358               && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6359               && (!bfd_link_executable (info)
6360                   || info->export_dynamic
6361                   || (eh->elf.dynamic
6362                       && d != NULL
6363                       && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
6364               && (strchr (eh->elf.root.root.string, ELF_VER_CHR) != NULL
6365                   || !bfd_hide_sym_by_version (info->version_info,
6366                                                eh->elf.root.root.string)))))
6367     {
6368       asection *code_sec;
6369       struct ppc_link_hash_entry *fh;
6370
6371       eh->elf.root.u.def.section->flags |= SEC_KEEP;
6372
6373       /* Function descriptor syms cause the associated
6374          function code sym section to be marked.  */
6375       fh = defined_code_entry (eh);
6376       if (fh != NULL)
6377         {
6378           code_sec = fh->elf.root.u.def.section;
6379           code_sec->flags |= SEC_KEEP;
6380         }
6381       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6382                && opd_entry_value (eh->elf.root.u.def.section,
6383                                    eh->elf.root.u.def.value,
6384                                    &code_sec, NULL, FALSE) != (bfd_vma) -1)
6385         code_sec->flags |= SEC_KEEP;
6386     }
6387
6388   return TRUE;
6389 }
6390
6391 /* Return the section that should be marked against GC for a given
6392    relocation.  */
6393
6394 static asection *
6395 ppc64_elf_gc_mark_hook (asection *sec,
6396                         struct bfd_link_info *info,
6397                         Elf_Internal_Rela *rel,
6398                         struct elf_link_hash_entry *h,
6399                         Elf_Internal_Sym *sym)
6400 {
6401   asection *rsec;
6402
6403   /* Syms return NULL if we're marking .opd, so we avoid marking all
6404      function sections, as all functions are referenced in .opd.  */
6405   rsec = NULL;
6406   if (get_opd_info (sec) != NULL)
6407     return rsec;
6408
6409   if (h != NULL)
6410     {
6411       enum elf_ppc64_reloc_type r_type;
6412       struct ppc_link_hash_entry *eh, *fh, *fdh;
6413
6414       r_type = ELF64_R_TYPE (rel->r_info);
6415       switch (r_type)
6416         {
6417         case R_PPC64_GNU_VTINHERIT:
6418         case R_PPC64_GNU_VTENTRY:
6419           break;
6420
6421         default:
6422           switch (h->root.type)
6423             {
6424             case bfd_link_hash_defined:
6425             case bfd_link_hash_defweak:
6426               eh = (struct ppc_link_hash_entry *) h;
6427               fdh = defined_func_desc (eh);
6428               if (fdh != NULL)
6429                 eh = fdh;
6430
6431               /* Function descriptor syms cause the associated
6432                  function code sym section to be marked.  */
6433               fh = defined_code_entry (eh);
6434               if (fh != NULL)
6435                 {
6436                   /* They also mark their opd section.  */
6437                   eh->elf.root.u.def.section->gc_mark = 1;
6438
6439                   rsec = fh->elf.root.u.def.section;
6440                 }
6441               else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6442                        && opd_entry_value (eh->elf.root.u.def.section,
6443                                            eh->elf.root.u.def.value,
6444                                            &rsec, NULL, FALSE) != (bfd_vma) -1)
6445                 eh->elf.root.u.def.section->gc_mark = 1;
6446               else
6447                 rsec = h->root.u.def.section;
6448               break;
6449
6450             case bfd_link_hash_common:
6451               rsec = h->root.u.c.p->section;
6452               break;
6453
6454             default:
6455               return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6456             }
6457         }
6458     }
6459   else
6460     {
6461       struct _opd_sec_data *opd;
6462
6463       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6464       opd = get_opd_info (rsec);
6465       if (opd != NULL && opd->func_sec != NULL)
6466         {
6467           rsec->gc_mark = 1;
6468
6469           rsec = opd->func_sec[OPD_NDX (sym->st_value + rel->r_addend)];
6470         }
6471     }
6472
6473   return rsec;
6474 }
6475
6476 /* Update the .got, .plt. and dynamic reloc reference counts for the
6477    section being removed.  */
6478
6479 static bfd_boolean
6480 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
6481                          asection *sec, const Elf_Internal_Rela *relocs)
6482 {
6483   struct ppc_link_hash_table *htab;
6484   Elf_Internal_Shdr *symtab_hdr;
6485   struct elf_link_hash_entry **sym_hashes;
6486   struct got_entry **local_got_ents;
6487   const Elf_Internal_Rela *rel, *relend;
6488
6489   if (bfd_link_relocatable (info))
6490     return TRUE;
6491
6492   if ((sec->flags & SEC_ALLOC) == 0)
6493     return TRUE;
6494
6495   elf_section_data (sec)->local_dynrel = NULL;
6496
6497   htab = ppc_hash_table (info);
6498   if (htab == NULL)
6499     return FALSE;
6500
6501   symtab_hdr = &elf_symtab_hdr (abfd);
6502   sym_hashes = elf_sym_hashes (abfd);
6503   local_got_ents = elf_local_got_ents (abfd);
6504
6505   relend = relocs + sec->reloc_count;
6506   for (rel = relocs; rel < relend; rel++)
6507     {
6508       unsigned long r_symndx;
6509       enum elf_ppc64_reloc_type r_type;
6510       struct elf_link_hash_entry *h = NULL;
6511       struct plt_entry **plt_list;
6512       unsigned char tls_type = 0;
6513
6514       r_symndx = ELF64_R_SYM (rel->r_info);
6515       r_type = ELF64_R_TYPE (rel->r_info);
6516       if (r_symndx >= symtab_hdr->sh_info)
6517         {
6518           struct ppc_link_hash_entry *eh;
6519           struct elf_dyn_relocs **pp;
6520           struct elf_dyn_relocs *p;
6521
6522           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6523           h = elf_follow_link (h);
6524           eh = (struct ppc_link_hash_entry *) h;
6525
6526           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6527             if (p->sec == sec)
6528               {
6529                 /* Everything must go for SEC.  */
6530                 *pp = p->next;
6531                 break;
6532               }
6533         }
6534
6535       switch (r_type)
6536         {
6537         case R_PPC64_GOT_TLSLD16:
6538         case R_PPC64_GOT_TLSLD16_LO:
6539         case R_PPC64_GOT_TLSLD16_HI:
6540         case R_PPC64_GOT_TLSLD16_HA:
6541           tls_type = TLS_TLS | TLS_LD;
6542           goto dogot;
6543
6544         case R_PPC64_GOT_TLSGD16:
6545         case R_PPC64_GOT_TLSGD16_LO:
6546         case R_PPC64_GOT_TLSGD16_HI:
6547         case R_PPC64_GOT_TLSGD16_HA:
6548           tls_type = TLS_TLS | TLS_GD;
6549           goto dogot;
6550
6551         case R_PPC64_GOT_TPREL16_DS:
6552         case R_PPC64_GOT_TPREL16_LO_DS:
6553         case R_PPC64_GOT_TPREL16_HI:
6554         case R_PPC64_GOT_TPREL16_HA:
6555           tls_type = TLS_TLS | TLS_TPREL;
6556           goto dogot;
6557
6558         case R_PPC64_GOT_DTPREL16_DS:
6559         case R_PPC64_GOT_DTPREL16_LO_DS:
6560         case R_PPC64_GOT_DTPREL16_HI:
6561         case R_PPC64_GOT_DTPREL16_HA:
6562           tls_type = TLS_TLS | TLS_DTPREL;
6563           goto dogot;
6564
6565         case R_PPC64_GOT16:
6566         case R_PPC64_GOT16_DS:
6567         case R_PPC64_GOT16_HA:
6568         case R_PPC64_GOT16_HI:
6569         case R_PPC64_GOT16_LO:
6570         case R_PPC64_GOT16_LO_DS:
6571         dogot:
6572           {
6573             struct got_entry *ent;
6574
6575             if (h != NULL)
6576               ent = h->got.glist;
6577             else
6578               ent = local_got_ents[r_symndx];
6579
6580             for (; ent != NULL; ent = ent->next)
6581               if (ent->addend == rel->r_addend
6582                   && ent->owner == abfd
6583                   && ent->tls_type == tls_type)
6584                 break;
6585             if (ent == NULL)
6586               abort ();
6587             if (ent->got.refcount > 0)
6588               ent->got.refcount -= 1;
6589           }
6590           break;
6591
6592         case R_PPC64_PLT16_HA:
6593         case R_PPC64_PLT16_HI:
6594         case R_PPC64_PLT16_LO:
6595         case R_PPC64_PLT32:
6596         case R_PPC64_PLT64:
6597         case R_PPC64_REL14:
6598         case R_PPC64_REL14_BRNTAKEN:
6599         case R_PPC64_REL14_BRTAKEN:
6600         case R_PPC64_REL24:
6601           plt_list = NULL;
6602           if (h != NULL)
6603             plt_list = &h->plt.plist;
6604           else if (local_got_ents != NULL)
6605             {
6606               struct plt_entry **local_plt = (struct plt_entry **)
6607                 (local_got_ents + symtab_hdr->sh_info);
6608               unsigned char *local_got_tls_masks = (unsigned char *)
6609                 (local_plt + symtab_hdr->sh_info);
6610               if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6611                 plt_list = local_plt + r_symndx;
6612             }
6613           if (plt_list)
6614             {
6615               struct plt_entry *ent;
6616
6617               for (ent = *plt_list; ent != NULL; ent = ent->next)
6618                 if (ent->addend == rel->r_addend)
6619                   break;
6620               if (ent != NULL && ent->plt.refcount > 0)
6621                 ent->plt.refcount -= 1;
6622             }
6623           break;
6624
6625         default:
6626           break;
6627         }
6628     }
6629   return TRUE;
6630 }
6631
6632 /* The maximum size of .sfpr.  */
6633 #define SFPR_MAX (218*4)
6634
6635 struct sfpr_def_parms
6636 {
6637   const char name[12];
6638   unsigned char lo, hi;
6639   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6640   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6641 };
6642
6643 /* Auto-generate _save*, _rest* functions in .sfpr.
6644    If STUB_SEC is non-null, define alias symbols in STUB_SEC
6645    instead.  */
6646
6647 static bfd_boolean
6648 sfpr_define (struct bfd_link_info *info,
6649              const struct sfpr_def_parms *parm,
6650              asection *stub_sec)
6651 {
6652   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6653   unsigned int i;
6654   size_t len = strlen (parm->name);
6655   bfd_boolean writing = FALSE;
6656   char sym[16];
6657
6658   if (htab == NULL)
6659     return FALSE;
6660
6661   memcpy (sym, parm->name, len);
6662   sym[len + 2] = 0;
6663
6664   for (i = parm->lo; i <= parm->hi; i++)
6665     {
6666       struct ppc_link_hash_entry *h;
6667
6668       sym[len + 0] = i / 10 + '0';
6669       sym[len + 1] = i % 10 + '0';
6670       h = (struct ppc_link_hash_entry *)
6671         elf_link_hash_lookup (&htab->elf, sym, writing, TRUE, TRUE);
6672       if (stub_sec != NULL)
6673         {
6674           if (h != NULL
6675               && h->elf.root.type == bfd_link_hash_defined
6676               && h->elf.root.u.def.section == htab->sfpr)
6677             {
6678               struct elf_link_hash_entry *s;
6679               char buf[32];
6680               sprintf (buf, "%08x.%s", stub_sec->id & 0xffffffff, sym);
6681               s = elf_link_hash_lookup (&htab->elf, buf, TRUE, TRUE, FALSE);
6682               if (s == NULL)
6683                 return FALSE;
6684               if (s->root.type == bfd_link_hash_new
6685                   || (s->root.type = bfd_link_hash_defined
6686                       && s->root.u.def.section == stub_sec))
6687                 {
6688                   s->root.type = bfd_link_hash_defined;
6689                   s->root.u.def.section = stub_sec;
6690                   s->root.u.def.value = (stub_sec->size
6691                                          + h->elf.root.u.def.value);
6692                   s->ref_regular = 1;
6693                   s->def_regular = 1;
6694                   s->ref_regular_nonweak = 1;
6695                   s->forced_local = 1;
6696                   s->non_elf = 0;
6697                   s->root.linker_def = 1;
6698                 }
6699             }
6700           continue;
6701         }
6702       if (h != NULL)
6703         {
6704           h->save_res = 1;
6705           if (!h->elf.def_regular)
6706             {
6707               h->elf.root.type = bfd_link_hash_defined;
6708               h->elf.root.u.def.section = htab->sfpr;
6709               h->elf.root.u.def.value = htab->sfpr->size;
6710               h->elf.type = STT_FUNC;
6711               h->elf.def_regular = 1;
6712               h->elf.non_elf = 0;
6713               _bfd_elf_link_hash_hide_symbol (info, &h->elf, TRUE);
6714               writing = TRUE;
6715               if (htab->sfpr->contents == NULL)
6716                 {
6717                   htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6718                   if (htab->sfpr->contents == NULL)
6719                     return FALSE;
6720                 }
6721             }
6722         }
6723       if (writing)
6724         {
6725           bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6726           if (i != parm->hi)
6727             p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6728           else
6729             p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6730           htab->sfpr->size = p - htab->sfpr->contents;
6731         }
6732     }
6733
6734   return TRUE;
6735 }
6736
6737 static bfd_byte *
6738 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6739 {
6740   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6741   return p + 4;
6742 }
6743
6744 static bfd_byte *
6745 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6746 {
6747   p = savegpr0 (abfd, p, r);
6748   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6749   p = p + 4;
6750   bfd_put_32 (abfd, BLR, p);
6751   return p + 4;
6752 }
6753
6754 static bfd_byte *
6755 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6756 {
6757   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6758   return p + 4;
6759 }
6760
6761 static bfd_byte *
6762 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6763 {
6764   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6765   p = p + 4;
6766   p = restgpr0 (abfd, p, r);
6767   bfd_put_32 (abfd, MTLR_R0, p);
6768   p = p + 4;
6769   if (r == 29)
6770     {
6771       p = restgpr0 (abfd, p, 30);
6772       p = restgpr0 (abfd, p, 31);
6773     }
6774   bfd_put_32 (abfd, BLR, p);
6775   return p + 4;
6776 }
6777
6778 static bfd_byte *
6779 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6780 {
6781   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6782   return p + 4;
6783 }
6784
6785 static bfd_byte *
6786 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6787 {
6788   p = savegpr1 (abfd, p, r);
6789   bfd_put_32 (abfd, BLR, p);
6790   return p + 4;
6791 }
6792
6793 static bfd_byte *
6794 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6795 {
6796   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6797   return p + 4;
6798 }
6799
6800 static bfd_byte *
6801 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6802 {
6803   p = restgpr1 (abfd, p, r);
6804   bfd_put_32 (abfd, BLR, p);
6805   return p + 4;
6806 }
6807
6808 static bfd_byte *
6809 savefpr (bfd *abfd, bfd_byte *p, int r)
6810 {
6811   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6812   return p + 4;
6813 }
6814
6815 static bfd_byte *
6816 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6817 {
6818   p = savefpr (abfd, p, r);
6819   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6820   p = p + 4;
6821   bfd_put_32 (abfd, BLR, p);
6822   return p + 4;
6823 }
6824
6825 static bfd_byte *
6826 restfpr (bfd *abfd, bfd_byte *p, int r)
6827 {
6828   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6829   return p + 4;
6830 }
6831
6832 static bfd_byte *
6833 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6834 {
6835   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6836   p = p + 4;
6837   p = restfpr (abfd, p, r);
6838   bfd_put_32 (abfd, MTLR_R0, p);
6839   p = p + 4;
6840   if (r == 29)
6841     {
6842       p = restfpr (abfd, p, 30);
6843       p = restfpr (abfd, p, 31);
6844     }
6845   bfd_put_32 (abfd, BLR, p);
6846   return p + 4;
6847 }
6848
6849 static bfd_byte *
6850 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6851 {
6852   p = savefpr (abfd, p, r);
6853   bfd_put_32 (abfd, BLR, p);
6854   return p + 4;
6855 }
6856
6857 static bfd_byte *
6858 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6859 {
6860   p = restfpr (abfd, p, r);
6861   bfd_put_32 (abfd, BLR, p);
6862   return p + 4;
6863 }
6864
6865 static bfd_byte *
6866 savevr (bfd *abfd, bfd_byte *p, int r)
6867 {
6868   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6869   p = p + 4;
6870   bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6871   return p + 4;
6872 }
6873
6874 static bfd_byte *
6875 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6876 {
6877   p = savevr (abfd, p, r);
6878   bfd_put_32 (abfd, BLR, p);
6879   return p + 4;
6880 }
6881
6882 static bfd_byte *
6883 restvr (bfd *abfd, bfd_byte *p, int r)
6884 {
6885   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6886   p = p + 4;
6887   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6888   return p + 4;
6889 }
6890
6891 static bfd_byte *
6892 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6893 {
6894   p = restvr (abfd, p, r);
6895   bfd_put_32 (abfd, BLR, p);
6896   return p + 4;
6897 }
6898
6899 /* Called via elf_link_hash_traverse to transfer dynamic linking
6900    information on function code symbol entries to their corresponding
6901    function descriptor symbol entries.  */
6902
6903 static bfd_boolean
6904 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6905 {
6906   struct bfd_link_info *info;
6907   struct ppc_link_hash_table *htab;
6908   struct plt_entry *ent;
6909   struct ppc_link_hash_entry *fh;
6910   struct ppc_link_hash_entry *fdh;
6911   bfd_boolean force_local;
6912
6913   fh = (struct ppc_link_hash_entry *) h;
6914   if (fh->elf.root.type == bfd_link_hash_indirect)
6915     return TRUE;
6916
6917   info = inf;
6918   htab = ppc_hash_table (info);
6919   if (htab == NULL)
6920     return FALSE;
6921
6922   /* Resolve undefined references to dot-symbols as the value
6923      in the function descriptor, if we have one in a regular object.
6924      This is to satisfy cases like ".quad .foo".  Calls to functions
6925      in dynamic objects are handled elsewhere.  */
6926   if (fh->elf.root.type == bfd_link_hash_undefweak
6927       && fh->was_undefined
6928       && (fdh = defined_func_desc (fh)) != NULL
6929       && get_opd_info (fdh->elf.root.u.def.section) != NULL
6930       && opd_entry_value (fdh->elf.root.u.def.section,
6931                           fdh->elf.root.u.def.value,
6932                           &fh->elf.root.u.def.section,
6933                           &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
6934     {
6935       fh->elf.root.type = fdh->elf.root.type;
6936       fh->elf.forced_local = 1;
6937       fh->elf.def_regular = fdh->elf.def_regular;
6938       fh->elf.def_dynamic = fdh->elf.def_dynamic;
6939     }
6940
6941   /* If this is a function code symbol, transfer dynamic linking
6942      information to the function descriptor symbol.  */
6943   if (!fh->is_func)
6944     return TRUE;
6945
6946   for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6947     if (ent->plt.refcount > 0)
6948       break;
6949   if (ent == NULL
6950       || fh->elf.root.root.string[0] != '.'
6951       || fh->elf.root.root.string[1] == '\0')
6952     return TRUE;
6953
6954   /* Find the corresponding function descriptor symbol.  Create it
6955      as undefined if necessary.  */
6956
6957   fdh = lookup_fdh (fh, htab);
6958   if (fdh == NULL
6959       && !bfd_link_executable (info)
6960       && (fh->elf.root.type == bfd_link_hash_undefined
6961           || fh->elf.root.type == bfd_link_hash_undefweak))
6962     {
6963       fdh = make_fdh (info, fh);
6964       if (fdh == NULL)
6965         return FALSE;
6966     }
6967
6968   /* Fake function descriptors are made undefweak.  If the function
6969      code symbol is strong undefined, make the fake sym the same.
6970      If the function code symbol is defined, then force the fake
6971      descriptor local;  We can't support overriding of symbols in a
6972      shared library on a fake descriptor.  */
6973
6974   if (fdh != NULL
6975       && fdh->fake
6976       && fdh->elf.root.type == bfd_link_hash_undefweak)
6977     {
6978       if (fh->elf.root.type == bfd_link_hash_undefined)
6979         {
6980           fdh->elf.root.type = bfd_link_hash_undefined;
6981           bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
6982         }
6983       else if (fh->elf.root.type == bfd_link_hash_defined
6984                || fh->elf.root.type == bfd_link_hash_defweak)
6985         {
6986           _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6987         }
6988     }
6989
6990   if (fdh != NULL
6991       && !fdh->elf.forced_local
6992       && (!bfd_link_executable (info)
6993           || fdh->elf.def_dynamic
6994           || fdh->elf.ref_dynamic
6995           || (fdh->elf.root.type == bfd_link_hash_undefweak
6996               && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
6997     {
6998       if (fdh->elf.dynindx == -1)
6999         if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
7000           return FALSE;
7001       fdh->elf.ref_regular |= fh->elf.ref_regular;
7002       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
7003       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
7004       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
7005       if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
7006         {
7007           move_plt_plist (fh, fdh);
7008           fdh->elf.needs_plt = 1;
7009         }
7010       fdh->is_func_descriptor = 1;
7011       fdh->oh = fh;
7012       fh->oh = fdh;
7013     }
7014
7015   /* Now that the info is on the function descriptor, clear the
7016      function code sym info.  Any function code syms for which we
7017      don't have a definition in a regular file, we force local.
7018      This prevents a shared library from exporting syms that have
7019      been imported from another library.  Function code syms that
7020      are really in the library we must leave global to prevent the
7021      linker dragging in a definition from a static library.  */
7022   force_local = (!fh->elf.def_regular
7023                  || fdh == NULL
7024                  || !fdh->elf.def_regular
7025                  || fdh->elf.forced_local);
7026   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7027
7028   return TRUE;
7029 }
7030
7031 static const struct sfpr_def_parms save_res_funcs[] =
7032   {
7033     { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
7034     { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
7035     { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
7036     { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
7037     { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
7038     { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
7039     { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
7040     { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
7041     { "._savef", 14, 31, savefpr, savefpr1_tail },
7042     { "._restf", 14, 31, restfpr, restfpr1_tail },
7043     { "_savevr_", 20, 31, savevr, savevr_tail },
7044     { "_restvr_", 20, 31, restvr, restvr_tail }
7045   };
7046
7047 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
7048    this hook to a) provide some gcc support functions, and b) transfer
7049    dynamic linking information gathered so far on function code symbol
7050    entries, to their corresponding function descriptor symbol entries.  */
7051
7052 static bfd_boolean
7053 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
7054                             struct bfd_link_info *info)
7055 {
7056   struct ppc_link_hash_table *htab;
7057
7058   htab = ppc_hash_table (info);
7059   if (htab == NULL)
7060     return FALSE;
7061
7062   /* Provide any missing _save* and _rest* functions.  */
7063   if (htab->sfpr != NULL)
7064     {
7065       unsigned int i;
7066
7067       htab->sfpr->size = 0;
7068       for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
7069         if (!sfpr_define (info, &save_res_funcs[i], NULL))
7070           return FALSE;
7071       if (htab->sfpr->size == 0)
7072         htab->sfpr->flags |= SEC_EXCLUDE;
7073     }
7074
7075   if (bfd_link_relocatable (info))
7076     return TRUE;
7077
7078   if (htab->elf.hgot != NULL)
7079     {
7080       _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
7081       /* Make .TOC. defined so as to prevent it being made dynamic.
7082          The wrong value here is fixed later in ppc64_elf_set_toc.  */
7083       if (!htab->elf.hgot->def_regular
7084           || htab->elf.hgot->root.type != bfd_link_hash_defined)
7085         {
7086           htab->elf.hgot->root.type = bfd_link_hash_defined;
7087           htab->elf.hgot->root.u.def.value = 0;
7088           htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
7089           htab->elf.hgot->def_regular = 1;
7090           htab->elf.hgot->root.linker_def = 1;
7091         }
7092       htab->elf.hgot->type = STT_OBJECT;
7093       htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
7094                                | STV_HIDDEN);
7095     }
7096
7097   elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
7098
7099   return TRUE;
7100 }
7101
7102 /* Return true if we have dynamic relocs that apply to read-only sections.  */
7103
7104 static bfd_boolean
7105 readonly_dynrelocs (struct elf_link_hash_entry *h)
7106 {
7107   struct ppc_link_hash_entry *eh;
7108   struct elf_dyn_relocs *p;
7109
7110   eh = (struct ppc_link_hash_entry *) h;
7111   for (p = eh->dyn_relocs; p != NULL; p = p->next)
7112     {
7113       asection *s = p->sec->output_section;
7114
7115       if (s != NULL && (s->flags & SEC_READONLY) != 0)
7116         return TRUE;
7117     }
7118   return FALSE;
7119 }
7120
7121 /* Adjust a symbol defined by a dynamic object and referenced by a
7122    regular object.  The current definition is in some section of the
7123    dynamic object, but we're not including those sections.  We have to
7124    change the definition to something the rest of the link can
7125    understand.  */
7126
7127 static bfd_boolean
7128 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
7129                                  struct elf_link_hash_entry *h)
7130 {
7131   struct ppc_link_hash_table *htab;
7132   asection *s;
7133
7134   htab = ppc_hash_table (info);
7135   if (htab == NULL)
7136     return FALSE;
7137
7138   /* Deal with function syms.  */
7139   if (h->type == STT_FUNC
7140       || h->type == STT_GNU_IFUNC
7141       || h->needs_plt)
7142     {
7143       /* Clear procedure linkage table information for any symbol that
7144          won't need a .plt entry.  */
7145       struct plt_entry *ent;
7146       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
7147         if (ent->plt.refcount > 0)
7148           break;
7149       if (ent == NULL
7150           || (h->type != STT_GNU_IFUNC
7151               && (SYMBOL_CALLS_LOCAL (info, h)
7152                   || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
7153                       && h->root.type == bfd_link_hash_undefweak)))
7154           || ((struct ppc_link_hash_entry *) h)->save_res)
7155         {
7156           h->plt.plist = NULL;
7157           h->needs_plt = 0;
7158           h->pointer_equality_needed = 0;
7159         }
7160       else if (abiversion (info->output_bfd) == 2)
7161         {
7162           /* Taking a function's address in a read/write section
7163              doesn't require us to define the function symbol in the
7164              executable on a global entry stub.  A dynamic reloc can
7165              be used instead.  */
7166           if (h->pointer_equality_needed
7167               && h->type != STT_GNU_IFUNC
7168               && !readonly_dynrelocs (h))
7169             {
7170               h->pointer_equality_needed = 0;
7171               h->non_got_ref = 0;
7172             }
7173
7174           /* After adjust_dynamic_symbol, non_got_ref set in the
7175              non-shared case means that we have allocated space in
7176              .dynbss for the symbol and thus dyn_relocs for this
7177              symbol should be discarded.
7178              If we get here we know we are making a PLT entry for this
7179              symbol, and in an executable we'd normally resolve
7180              relocations against this symbol to the PLT entry.  Allow
7181              dynamic relocs if the reference is weak, and the dynamic
7182              relocs will not cause text relocation.  */
7183           else if (!h->ref_regular_nonweak
7184                    && h->non_got_ref
7185                    && h->type != STT_GNU_IFUNC
7186                    && !readonly_dynrelocs (h))
7187             h->non_got_ref = 0;
7188
7189           /* If making a plt entry, then we don't need copy relocs.  */
7190           return TRUE;
7191         }
7192     }
7193   else
7194     h->plt.plist = NULL;
7195
7196   /* If this is a weak symbol, and there is a real definition, the
7197      processor independent code will have arranged for us to see the
7198      real definition first, and we can just use the same value.  */
7199   if (h->u.weakdef != NULL)
7200     {
7201       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
7202                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
7203       h->root.u.def.section = h->u.weakdef->root.u.def.section;
7204       h->root.u.def.value = h->u.weakdef->root.u.def.value;
7205       if (ELIMINATE_COPY_RELOCS)
7206         h->non_got_ref = h->u.weakdef->non_got_ref;
7207       return TRUE;
7208     }
7209
7210   /* If we are creating a shared library, we must presume that the
7211      only references to the symbol are via the global offset table.
7212      For such cases we need not do anything here; the relocations will
7213      be handled correctly by relocate_section.  */
7214   if (bfd_link_pic (info))
7215     return TRUE;
7216
7217   /* If there are no references to this symbol that do not use the
7218      GOT, we don't need to generate a copy reloc.  */
7219   if (!h->non_got_ref)
7220     return TRUE;
7221
7222   /* Don't generate a copy reloc for symbols defined in the executable.  */
7223   if (!h->def_dynamic || !h->ref_regular || h->def_regular)
7224     return TRUE;
7225
7226   /* If -z nocopyreloc was given, don't generate them either.  */
7227   if (info->nocopyreloc)
7228     {
7229       h->non_got_ref = 0;
7230       return TRUE;
7231     }
7232
7233   /* If we didn't find any dynamic relocs in read-only sections, then
7234      we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
7235   if (ELIMINATE_COPY_RELOCS && !readonly_dynrelocs (h))
7236     {
7237       h->non_got_ref = 0;
7238       return TRUE;
7239     }
7240
7241   /* Protected variables do not work with .dynbss.  The copy in
7242      .dynbss won't be used by the shared library with the protected
7243      definition for the variable.  Text relocations are preferable
7244      to an incorrect program.  */
7245   if (h->protected_def)
7246     {
7247       h->non_got_ref = 0;
7248       return TRUE;
7249     }
7250
7251   if (h->plt.plist != NULL)
7252     {
7253       /* We should never get here, but unfortunately there are versions
7254          of gcc out there that improperly (for this ABI) put initialized
7255          function pointers, vtable refs and suchlike in read-only
7256          sections.  Allow them to proceed, but warn that this might
7257          break at runtime.  */
7258       info->callbacks->einfo
7259         (_("%P: copy reloc against `%T' requires lazy plt linking; "
7260            "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7261          h->root.root.string);
7262     }
7263
7264   /* This is a reference to a symbol defined by a dynamic object which
7265      is not a function.  */
7266
7267   /* We must allocate the symbol in our .dynbss section, which will
7268      become part of the .bss section of the executable.  There will be
7269      an entry for this symbol in the .dynsym section.  The dynamic
7270      object will contain position independent code, so all references
7271      from the dynamic object to this symbol will go through the global
7272      offset table.  The dynamic linker will use the .dynsym entry to
7273      determine the address it must put in the global offset table, so
7274      both the dynamic object and the regular object will refer to the
7275      same memory location for the variable.  */
7276
7277   /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
7278      to copy the initial value out of the dynamic object and into the
7279      runtime process image.  We need to remember the offset into the
7280      .rela.bss section we are going to use.  */
7281   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7282     {
7283       htab->relbss->size += sizeof (Elf64_External_Rela);
7284       h->needs_copy = 1;
7285     }
7286
7287   s = htab->dynbss;
7288
7289   return _bfd_elf_adjust_dynamic_copy (info, h, s);
7290 }
7291
7292 /* If given a function descriptor symbol, hide both the function code
7293    sym and the descriptor.  */
7294 static void
7295 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7296                        struct elf_link_hash_entry *h,
7297                        bfd_boolean force_local)
7298 {
7299   struct ppc_link_hash_entry *eh;
7300   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7301
7302   eh = (struct ppc_link_hash_entry *) h;
7303   if (eh->is_func_descriptor)
7304     {
7305       struct ppc_link_hash_entry *fh = eh->oh;
7306
7307       if (fh == NULL)
7308         {
7309           const char *p, *q;
7310           struct ppc_link_hash_table *htab;
7311           char save;
7312
7313           /* We aren't supposed to use alloca in BFD because on
7314              systems which do not have alloca the version in libiberty
7315              calls xmalloc, which might cause the program to crash
7316              when it runs out of memory.  This function doesn't have a
7317              return status, so there's no way to gracefully return an
7318              error.  So cheat.  We know that string[-1] can be safely
7319              accessed;  It's either a string in an ELF string table,
7320              or allocated in an objalloc structure.  */
7321
7322           p = eh->elf.root.root.string - 1;
7323           save = *p;
7324           *(char *) p = '.';
7325           htab = ppc_hash_table (info);
7326           if (htab == NULL)
7327             return;
7328
7329           fh = (struct ppc_link_hash_entry *)
7330             elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7331           *(char *) p = save;
7332
7333           /* Unfortunately, if it so happens that the string we were
7334              looking for was allocated immediately before this string,
7335              then we overwrote the string terminator.  That's the only
7336              reason the lookup should fail.  */
7337           if (fh == NULL)
7338             {
7339               q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7340               while (q >= eh->elf.root.root.string && *q == *p)
7341                 --q, --p;
7342               if (q < eh->elf.root.root.string && *p == '.')
7343                 fh = (struct ppc_link_hash_entry *)
7344                   elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7345             }
7346           if (fh != NULL)
7347             {
7348               eh->oh = fh;
7349               fh->oh = eh;
7350             }
7351         }
7352       if (fh != NULL)
7353         _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7354     }
7355 }
7356
7357 static bfd_boolean
7358 get_sym_h (struct elf_link_hash_entry **hp,
7359            Elf_Internal_Sym **symp,
7360            asection **symsecp,
7361            unsigned char **tls_maskp,
7362            Elf_Internal_Sym **locsymsp,
7363            unsigned long r_symndx,
7364            bfd *ibfd)
7365 {
7366   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7367
7368   if (r_symndx >= symtab_hdr->sh_info)
7369     {
7370       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7371       struct elf_link_hash_entry *h;
7372
7373       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7374       h = elf_follow_link (h);
7375
7376       if (hp != NULL)
7377         *hp = h;
7378
7379       if (symp != NULL)
7380         *symp = NULL;
7381
7382       if (symsecp != NULL)
7383         {
7384           asection *symsec = NULL;
7385           if (h->root.type == bfd_link_hash_defined
7386               || h->root.type == bfd_link_hash_defweak)
7387             symsec = h->root.u.def.section;
7388           *symsecp = symsec;
7389         }
7390
7391       if (tls_maskp != NULL)
7392         {
7393           struct ppc_link_hash_entry *eh;
7394
7395           eh = (struct ppc_link_hash_entry *) h;
7396           *tls_maskp = &eh->tls_mask;
7397         }
7398     }
7399   else
7400     {
7401       Elf_Internal_Sym *sym;
7402       Elf_Internal_Sym *locsyms = *locsymsp;
7403
7404       if (locsyms == NULL)
7405         {
7406           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7407           if (locsyms == NULL)
7408             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7409                                             symtab_hdr->sh_info,
7410                                             0, NULL, NULL, NULL);
7411           if (locsyms == NULL)
7412             return FALSE;
7413           *locsymsp = locsyms;
7414         }
7415       sym = locsyms + r_symndx;
7416
7417       if (hp != NULL)
7418         *hp = NULL;
7419
7420       if (symp != NULL)
7421         *symp = sym;
7422
7423       if (symsecp != NULL)
7424         *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7425
7426       if (tls_maskp != NULL)
7427         {
7428           struct got_entry **lgot_ents;
7429           unsigned char *tls_mask;
7430
7431           tls_mask = NULL;
7432           lgot_ents = elf_local_got_ents (ibfd);
7433           if (lgot_ents != NULL)
7434             {
7435               struct plt_entry **local_plt = (struct plt_entry **)
7436                 (lgot_ents + symtab_hdr->sh_info);
7437               unsigned char *lgot_masks = (unsigned char *)
7438                 (local_plt + symtab_hdr->sh_info);
7439               tls_mask = &lgot_masks[r_symndx];
7440             }
7441           *tls_maskp = tls_mask;
7442         }
7443     }
7444   return TRUE;
7445 }
7446
7447 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
7448    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7449    type suitable for optimization, and 1 otherwise.  */
7450
7451 static int
7452 get_tls_mask (unsigned char **tls_maskp,
7453               unsigned long *toc_symndx,
7454               bfd_vma *toc_addend,
7455               Elf_Internal_Sym **locsymsp,
7456               const Elf_Internal_Rela *rel,
7457               bfd *ibfd)
7458 {
7459   unsigned long r_symndx;
7460   int next_r;
7461   struct elf_link_hash_entry *h;
7462   Elf_Internal_Sym *sym;
7463   asection *sec;
7464   bfd_vma off;
7465
7466   r_symndx = ELF64_R_SYM (rel->r_info);
7467   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7468     return 0;
7469
7470   if ((*tls_maskp != NULL && **tls_maskp != 0)
7471       || sec == NULL
7472       || ppc64_elf_section_data (sec) == NULL
7473       || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7474     return 1;
7475
7476   /* Look inside a TOC section too.  */
7477   if (h != NULL)
7478     {
7479       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7480       off = h->root.u.def.value;
7481     }
7482   else
7483     off = sym->st_value;
7484   off += rel->r_addend;
7485   BFD_ASSERT (off % 8 == 0);
7486   r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7487   next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7488   if (toc_symndx != NULL)
7489     *toc_symndx = r_symndx;
7490   if (toc_addend != NULL)
7491     *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7492   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7493     return 0;
7494   if ((h == NULL || is_static_defined (h))
7495       && (next_r == -1 || next_r == -2))
7496     return 1 - next_r;
7497   return 1;
7498 }
7499
7500 /* Find (or create) an entry in the tocsave hash table.  */
7501
7502 static struct tocsave_entry *
7503 tocsave_find (struct ppc_link_hash_table *htab,
7504               enum insert_option insert,
7505               Elf_Internal_Sym **local_syms,
7506               const Elf_Internal_Rela *irela,
7507               bfd *ibfd)
7508 {
7509   unsigned long r_indx;
7510   struct elf_link_hash_entry *h;
7511   Elf_Internal_Sym *sym;
7512   struct tocsave_entry ent, *p;
7513   hashval_t hash;
7514   struct tocsave_entry **slot;
7515
7516   r_indx = ELF64_R_SYM (irela->r_info);
7517   if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7518     return NULL;
7519   if (ent.sec == NULL || ent.sec->output_section == NULL)
7520     {
7521       (*_bfd_error_handler)
7522         (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"));
7523       return NULL;
7524     }
7525
7526   if (h != NULL)
7527     ent.offset = h->root.u.def.value;
7528   else
7529     ent.offset = sym->st_value;
7530   ent.offset += irela->r_addend;
7531
7532   hash = tocsave_htab_hash (&ent);
7533   slot = ((struct tocsave_entry **)
7534           htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7535   if (slot == NULL)
7536     return NULL;
7537
7538   if (*slot == NULL)
7539     {
7540       p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7541       if (p == NULL)
7542         return NULL;
7543       *p = ent;
7544       *slot = p;
7545     }
7546   return *slot;
7547 }
7548
7549 /* Adjust all global syms defined in opd sections.  In gcc generated
7550    code for the old ABI, these will already have been done.  */
7551
7552 static bfd_boolean
7553 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7554 {
7555   struct ppc_link_hash_entry *eh;
7556   asection *sym_sec;
7557   struct _opd_sec_data *opd;
7558
7559   if (h->root.type == bfd_link_hash_indirect)
7560     return TRUE;
7561
7562   if (h->root.type != bfd_link_hash_defined
7563       && h->root.type != bfd_link_hash_defweak)
7564     return TRUE;
7565
7566   eh = (struct ppc_link_hash_entry *) h;
7567   if (eh->adjust_done)
7568     return TRUE;
7569
7570   sym_sec = eh->elf.root.u.def.section;
7571   opd = get_opd_info (sym_sec);
7572   if (opd != NULL && opd->adjust != NULL)
7573     {
7574       long adjust = opd->adjust[OPD_NDX (eh->elf.root.u.def.value)];
7575       if (adjust == -1)
7576         {
7577           /* This entry has been deleted.  */
7578           asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7579           if (dsec == NULL)
7580             {
7581               for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7582                 if (discarded_section (dsec))
7583                   {
7584                     ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7585                     break;
7586                   }
7587             }
7588           eh->elf.root.u.def.value = 0;
7589           eh->elf.root.u.def.section = dsec;
7590         }
7591       else
7592         eh->elf.root.u.def.value += adjust;
7593       eh->adjust_done = 1;
7594     }
7595   return TRUE;
7596 }
7597
7598 /* Handles decrementing dynamic reloc counts for the reloc specified by
7599    R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM
7600    have already been determined.  */
7601
7602 static bfd_boolean
7603 dec_dynrel_count (bfd_vma r_info,
7604                   asection *sec,
7605                   struct bfd_link_info *info,
7606                   Elf_Internal_Sym **local_syms,
7607                   struct elf_link_hash_entry *h,
7608                   Elf_Internal_Sym *sym)
7609 {
7610   enum elf_ppc64_reloc_type r_type;
7611   asection *sym_sec = NULL;
7612
7613   /* Can this reloc be dynamic?  This switch, and later tests here
7614      should be kept in sync with the code in check_relocs.  */
7615   r_type = ELF64_R_TYPE (r_info);
7616   switch (r_type)
7617     {
7618     default:
7619       return TRUE;
7620
7621     case R_PPC64_TPREL16:
7622     case R_PPC64_TPREL16_LO:
7623     case R_PPC64_TPREL16_HI:
7624     case R_PPC64_TPREL16_HA:
7625     case R_PPC64_TPREL16_DS:
7626     case R_PPC64_TPREL16_LO_DS:
7627     case R_PPC64_TPREL16_HIGH:
7628     case R_PPC64_TPREL16_HIGHA:
7629     case R_PPC64_TPREL16_HIGHER:
7630     case R_PPC64_TPREL16_HIGHERA:
7631     case R_PPC64_TPREL16_HIGHEST:
7632     case R_PPC64_TPREL16_HIGHESTA:
7633       if (!bfd_link_pic (info))
7634         return TRUE;
7635
7636     case R_PPC64_TPREL64:
7637     case R_PPC64_DTPMOD64:
7638     case R_PPC64_DTPREL64:
7639     case R_PPC64_ADDR64:
7640     case R_PPC64_REL30:
7641     case R_PPC64_REL32:
7642     case R_PPC64_REL64:
7643     case R_PPC64_ADDR14:
7644     case R_PPC64_ADDR14_BRNTAKEN:
7645     case R_PPC64_ADDR14_BRTAKEN:
7646     case R_PPC64_ADDR16:
7647     case R_PPC64_ADDR16_DS:
7648     case R_PPC64_ADDR16_HA:
7649     case R_PPC64_ADDR16_HI:
7650     case R_PPC64_ADDR16_HIGH:
7651     case R_PPC64_ADDR16_HIGHA:
7652     case R_PPC64_ADDR16_HIGHER:
7653     case R_PPC64_ADDR16_HIGHERA:
7654     case R_PPC64_ADDR16_HIGHEST:
7655     case R_PPC64_ADDR16_HIGHESTA:
7656     case R_PPC64_ADDR16_LO:
7657     case R_PPC64_ADDR16_LO_DS:
7658     case R_PPC64_ADDR24:
7659     case R_PPC64_ADDR32:
7660     case R_PPC64_UADDR16:
7661     case R_PPC64_UADDR32:
7662     case R_PPC64_UADDR64:
7663     case R_PPC64_TOC:
7664       break;
7665     }
7666
7667   if (local_syms != NULL)
7668     {
7669       unsigned long r_symndx;
7670       bfd *ibfd = sec->owner;
7671
7672       r_symndx = ELF64_R_SYM (r_info);
7673       if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7674         return FALSE;
7675     }
7676
7677   if ((bfd_link_pic (info)
7678        && (must_be_dyn_reloc (info, r_type)
7679            || (h != NULL
7680                && (!SYMBOLIC_BIND (info, h)
7681                    || h->root.type == bfd_link_hash_defweak
7682                    || !h->def_regular))))
7683       || (ELIMINATE_COPY_RELOCS
7684           && !bfd_link_pic (info)
7685           && h != NULL
7686           && (h->root.type == bfd_link_hash_defweak
7687               || !h->def_regular)))
7688     ;
7689   else
7690     return TRUE;
7691
7692   if (h != NULL)
7693     {
7694       struct elf_dyn_relocs *p;
7695       struct elf_dyn_relocs **pp;
7696       pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7697
7698       /* elf_gc_sweep may have already removed all dyn relocs associated
7699          with local syms for a given section.  Also, symbol flags are
7700          changed by elf_gc_sweep_symbol, confusing the test above.  Don't
7701          report a dynreloc miscount.  */
7702       if (*pp == NULL && info->gc_sections)
7703         return TRUE;
7704
7705       while ((p = *pp) != NULL)
7706         {
7707           if (p->sec == sec)
7708             {
7709               if (!must_be_dyn_reloc (info, r_type))
7710                 p->pc_count -= 1;
7711               p->count -= 1;
7712               if (p->count == 0)
7713                 *pp = p->next;
7714               return TRUE;
7715             }
7716           pp = &p->next;
7717         }
7718     }
7719   else
7720     {
7721       struct ppc_dyn_relocs *p;
7722       struct ppc_dyn_relocs **pp;
7723       void *vpp;
7724       bfd_boolean is_ifunc;
7725
7726       if (local_syms == NULL)
7727         sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7728       if (sym_sec == NULL)
7729         sym_sec = sec;
7730
7731       vpp = &elf_section_data (sym_sec)->local_dynrel;
7732       pp = (struct ppc_dyn_relocs **) vpp;
7733
7734       if (*pp == NULL && info->gc_sections)
7735         return TRUE;
7736
7737       is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7738       while ((p = *pp) != NULL)
7739         {
7740           if (p->sec == sec && p->ifunc == is_ifunc)
7741             {
7742               p->count -= 1;
7743               if (p->count == 0)
7744                 *pp = p->next;
7745               return TRUE;
7746             }
7747           pp = &p->next;
7748         }
7749     }
7750
7751   info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7752                           sec->owner, sec);
7753   bfd_set_error (bfd_error_bad_value);
7754   return FALSE;
7755 }
7756
7757 /* Remove unused Official Procedure Descriptor entries.  Currently we
7758    only remove those associated with functions in discarded link-once
7759    sections, or weakly defined functions that have been overridden.  It
7760    would be possible to remove many more entries for statically linked
7761    applications.  */
7762
7763 bfd_boolean
7764 ppc64_elf_edit_opd (struct bfd_link_info *info)
7765 {
7766   bfd *ibfd;
7767   bfd_boolean some_edited = FALSE;
7768   asection *need_pad = NULL;
7769   struct ppc_link_hash_table *htab;
7770
7771   htab = ppc_hash_table (info);
7772   if (htab == NULL)
7773     return FALSE;
7774
7775   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
7776     {
7777       asection *sec;
7778       Elf_Internal_Rela *relstart, *rel, *relend;
7779       Elf_Internal_Shdr *symtab_hdr;
7780       Elf_Internal_Sym *local_syms;
7781       struct _opd_sec_data *opd;
7782       bfd_boolean need_edit, add_aux_fields, broken;
7783       bfd_size_type cnt_16b = 0;
7784
7785       if (!is_ppc64_elf (ibfd))
7786         continue;
7787
7788       sec = bfd_get_section_by_name (ibfd, ".opd");
7789       if (sec == NULL || sec->size == 0)
7790         continue;
7791
7792       if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7793         continue;
7794
7795       if (sec->output_section == bfd_abs_section_ptr)
7796         continue;
7797
7798       /* Look through the section relocs.  */
7799       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7800         continue;
7801
7802       local_syms = NULL;
7803       symtab_hdr = &elf_symtab_hdr (ibfd);
7804
7805       /* Read the relocations.  */
7806       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7807                                             info->keep_memory);
7808       if (relstart == NULL)
7809         return FALSE;
7810
7811       /* First run through the relocs to check they are sane, and to
7812          determine whether we need to edit this opd section.  */
7813       need_edit = FALSE;
7814       broken = FALSE;
7815       need_pad = sec;
7816       relend = relstart + sec->reloc_count;
7817       for (rel = relstart; rel < relend; )
7818         {
7819           enum elf_ppc64_reloc_type r_type;
7820           unsigned long r_symndx;
7821           asection *sym_sec;
7822           struct elf_link_hash_entry *h;
7823           Elf_Internal_Sym *sym;
7824           bfd_vma offset;
7825
7826           /* .opd contains an array of 16 or 24 byte entries.  We're
7827              only interested in the reloc pointing to a function entry
7828              point.  */
7829           offset = rel->r_offset;
7830           if (rel + 1 == relend
7831               || rel[1].r_offset != offset + 8)
7832             {
7833               /* If someone messes with .opd alignment then after a
7834                  "ld -r" we might have padding in the middle of .opd.
7835                  Also, there's nothing to prevent someone putting
7836                  something silly in .opd with the assembler.  No .opd
7837                  optimization for them!  */
7838             broken_opd:
7839               (*_bfd_error_handler)
7840                 (_("%B: .opd is not a regular array of opd entries"), ibfd);
7841               broken = TRUE;
7842               break;
7843             }
7844
7845           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7846               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7847             {
7848               (*_bfd_error_handler)
7849                 (_("%B: unexpected reloc type %u in .opd section"),
7850                  ibfd, r_type);
7851               broken = TRUE;
7852               break;
7853             }
7854
7855           r_symndx = ELF64_R_SYM (rel->r_info);
7856           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7857                           r_symndx, ibfd))
7858             goto error_ret;
7859
7860           if (sym_sec == NULL || sym_sec->owner == NULL)
7861             {
7862               const char *sym_name;
7863               if (h != NULL)
7864                 sym_name = h->root.root.string;
7865               else
7866                 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7867                                              sym_sec);
7868
7869               (*_bfd_error_handler)
7870                 (_("%B: undefined sym `%s' in .opd section"),
7871                  ibfd, sym_name);
7872               broken = TRUE;
7873               break;
7874             }
7875
7876           /* opd entries are always for functions defined in the
7877              current input bfd.  If the symbol isn't defined in the
7878              input bfd, then we won't be using the function in this
7879              bfd;  It must be defined in a linkonce section in another
7880              bfd, or is weak.  It's also possible that we are
7881              discarding the function due to a linker script /DISCARD/,
7882              which we test for via the output_section.  */
7883           if (sym_sec->owner != ibfd
7884               || sym_sec->output_section == bfd_abs_section_ptr)
7885             need_edit = TRUE;
7886
7887           rel += 2;
7888           if (rel + 1 == relend
7889               || (rel + 2 < relend
7890                   && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC))
7891             ++rel;
7892
7893           if (rel == relend)
7894             {
7895               if (sec->size == offset + 24)
7896                 {
7897                   need_pad = NULL;
7898                   break;
7899                 }
7900               if (sec->size == offset + 16)
7901                 {
7902                   cnt_16b++;
7903                   break;
7904                 }
7905               goto broken_opd;
7906             }
7907           else if (rel + 1 < relend
7908                    && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7909                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7910             {
7911               if (rel[0].r_offset == offset + 16)
7912                 cnt_16b++;
7913               else if (rel[0].r_offset != offset + 24)
7914                 goto broken_opd;
7915             }
7916           else
7917             goto broken_opd;
7918         }
7919
7920       add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
7921
7922       if (!broken && (need_edit || add_aux_fields))
7923         {
7924           Elf_Internal_Rela *write_rel;
7925           Elf_Internal_Shdr *rel_hdr;
7926           bfd_byte *rptr, *wptr;
7927           bfd_byte *new_contents;
7928           bfd_size_type amt;
7929
7930           new_contents = NULL;
7931           amt = OPD_NDX (sec->size) * sizeof (long);
7932           opd = &ppc64_elf_section_data (sec)->u.opd;
7933           opd->adjust = bfd_zalloc (sec->owner, amt);
7934           if (opd->adjust == NULL)
7935             return FALSE;
7936           ppc64_elf_section_data (sec)->sec_type = sec_opd;
7937
7938           /* This seems a waste of time as input .opd sections are all
7939              zeros as generated by gcc, but I suppose there's no reason
7940              this will always be so.  We might start putting something in
7941              the third word of .opd entries.  */
7942           if ((sec->flags & SEC_IN_MEMORY) == 0)
7943             {
7944               bfd_byte *loc;
7945               if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7946                 {
7947                   if (loc != NULL)
7948                     free (loc);
7949                 error_ret:
7950                   if (local_syms != NULL
7951                       && symtab_hdr->contents != (unsigned char *) local_syms)
7952                     free (local_syms);
7953                   if (elf_section_data (sec)->relocs != relstart)
7954                     free (relstart);
7955                   return FALSE;
7956                 }
7957               sec->contents = loc;
7958               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7959             }
7960
7961           elf_section_data (sec)->relocs = relstart;
7962
7963           new_contents = sec->contents;
7964           if (add_aux_fields)
7965             {
7966               new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7967               if (new_contents == NULL)
7968                 return FALSE;
7969               need_pad = NULL;
7970             }
7971           wptr = new_contents;
7972           rptr = sec->contents;
7973           write_rel = relstart;
7974           for (rel = relstart; rel < relend; )
7975             {
7976               unsigned long r_symndx;
7977               asection *sym_sec;
7978               struct elf_link_hash_entry *h;
7979               struct ppc_link_hash_entry *fdh = NULL;
7980               Elf_Internal_Sym *sym;
7981               long opd_ent_size;
7982               Elf_Internal_Rela *next_rel;
7983               bfd_boolean skip;
7984
7985               r_symndx = ELF64_R_SYM (rel->r_info);
7986               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7987                               r_symndx, ibfd))
7988                 goto error_ret;
7989
7990               next_rel = rel + 2;
7991               if (next_rel + 1 == relend
7992                   || (next_rel + 2 < relend
7993                       && ELF64_R_TYPE (next_rel[2].r_info) == R_PPC64_TOC))
7994                 ++next_rel;
7995
7996               /* See if the .opd entry is full 24 byte or
7997                  16 byte (with fd_aux entry overlapped with next
7998                  fd_func).  */
7999               opd_ent_size = 24;
8000               if (next_rel == relend)
8001                 {
8002                   if (sec->size == rel->r_offset + 16)
8003                     opd_ent_size = 16;
8004                 }
8005               else if (next_rel->r_offset == rel->r_offset + 16)
8006                 opd_ent_size = 16;
8007
8008               if (h != NULL
8009                   && h->root.root.string[0] == '.')
8010                 {
8011                   fdh = lookup_fdh ((struct ppc_link_hash_entry *) h, htab);
8012                   if (fdh != NULL
8013                       && fdh->elf.root.type != bfd_link_hash_defined
8014                       && fdh->elf.root.type != bfd_link_hash_defweak)
8015                     fdh = NULL;
8016                 }
8017
8018               skip = (sym_sec->owner != ibfd
8019                       || sym_sec->output_section == bfd_abs_section_ptr);
8020               if (skip)
8021                 {
8022                   if (fdh != NULL && sym_sec->owner == ibfd)
8023                     {
8024                       /* Arrange for the function descriptor sym
8025                          to be dropped.  */
8026                       fdh->elf.root.u.def.value = 0;
8027                       fdh->elf.root.u.def.section = sym_sec;
8028                     }
8029                   opd->adjust[OPD_NDX (rel->r_offset)] = -1;
8030
8031                   if (NO_OPD_RELOCS || bfd_link_relocatable (info))
8032                     rel = next_rel;
8033                   else
8034                     while (1)
8035                       {
8036                         if (!dec_dynrel_count (rel->r_info, sec, info,
8037                                                NULL, h, sym))
8038                           goto error_ret;
8039
8040                         if (++rel == next_rel)
8041                           break;
8042
8043                         r_symndx = ELF64_R_SYM (rel->r_info);
8044                         if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8045                                         r_symndx, ibfd))
8046                           goto error_ret;
8047                       }
8048                 }
8049               else
8050                 {
8051                   /* We'll be keeping this opd entry.  */
8052                   long adjust;
8053
8054                   if (fdh != NULL)
8055                     {
8056                       /* Redefine the function descriptor symbol to
8057                          this location in the opd section.  It is
8058                          necessary to update the value here rather
8059                          than using an array of adjustments as we do
8060                          for local symbols, because various places
8061                          in the generic ELF code use the value
8062                          stored in u.def.value.  */
8063                       fdh->elf.root.u.def.value = wptr - new_contents;
8064                       fdh->adjust_done = 1;
8065                     }
8066
8067                   /* Local syms are a bit tricky.  We could
8068                      tweak them as they can be cached, but
8069                      we'd need to look through the local syms
8070                      for the function descriptor sym which we
8071                      don't have at the moment.  So keep an
8072                      array of adjustments.  */
8073                   adjust = (wptr - new_contents) - (rptr - sec->contents);
8074                   opd->adjust[OPD_NDX (rel->r_offset)] = adjust;
8075
8076                   if (wptr != rptr)
8077                     memcpy (wptr, rptr, opd_ent_size);
8078                   wptr += opd_ent_size;
8079                   if (add_aux_fields && opd_ent_size == 16)
8080                     {
8081                       memset (wptr, '\0', 8);
8082                       wptr += 8;
8083                     }
8084
8085                   /* We need to adjust any reloc offsets to point to the
8086                      new opd entries.  */
8087                   for ( ; rel != next_rel; ++rel)
8088                     {
8089                       rel->r_offset += adjust;
8090                       if (write_rel != rel)
8091                         memcpy (write_rel, rel, sizeof (*rel));
8092                       ++write_rel;
8093                     }
8094                 }
8095
8096               rptr += opd_ent_size;
8097             }
8098
8099           sec->size = wptr - new_contents;
8100           sec->reloc_count = write_rel - relstart;
8101           if (add_aux_fields)
8102             {
8103               free (sec->contents);
8104               sec->contents = new_contents;
8105             }
8106
8107           /* Fudge the header size too, as this is used later in
8108              elf_bfd_final_link if we are emitting relocs.  */
8109           rel_hdr = _bfd_elf_single_rel_hdr (sec);
8110           rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
8111           some_edited = TRUE;
8112         }
8113       else if (elf_section_data (sec)->relocs != relstart)
8114         free (relstart);
8115
8116       if (local_syms != NULL
8117           && symtab_hdr->contents != (unsigned char *) local_syms)
8118         {
8119           if (!info->keep_memory)
8120             free (local_syms);
8121           else
8122             symtab_hdr->contents = (unsigned char *) local_syms;
8123         }
8124     }
8125
8126   if (some_edited)
8127     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
8128
8129   /* If we are doing a final link and the last .opd entry is just 16 byte
8130      long, add a 8 byte padding after it.  */
8131   if (need_pad != NULL && !bfd_link_relocatable (info))
8132     {
8133       bfd_byte *p;
8134
8135       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
8136         {
8137           BFD_ASSERT (need_pad->size > 0);
8138
8139           p = bfd_malloc (need_pad->size + 8);
8140           if (p == NULL)
8141             return FALSE;
8142
8143           if (! bfd_get_section_contents (need_pad->owner, need_pad,
8144                                           p, 0, need_pad->size))
8145             return FALSE;
8146
8147           need_pad->contents = p;
8148           need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8149         }
8150       else
8151         {
8152           p = bfd_realloc (need_pad->contents, need_pad->size + 8);
8153           if (p == NULL)
8154             return FALSE;
8155
8156           need_pad->contents = p;
8157         }
8158
8159       memset (need_pad->contents + need_pad->size, 0, 8);
8160       need_pad->size += 8;
8161     }
8162
8163   return TRUE;
8164 }
8165
8166 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
8167
8168 asection *
8169 ppc64_elf_tls_setup (struct bfd_link_info *info)
8170 {
8171   struct ppc_link_hash_table *htab;
8172
8173   htab = ppc_hash_table (info);
8174   if (htab == NULL)
8175     return NULL;
8176
8177   if (abiversion (info->output_bfd) == 1)
8178     htab->opd_abi = 1;
8179
8180   if (htab->params->no_multi_toc)
8181     htab->do_multi_toc = 0;
8182   else if (!htab->do_multi_toc)
8183     htab->params->no_multi_toc = 1;
8184
8185   htab->tls_get_addr = ((struct ppc_link_hash_entry *)
8186                         elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
8187                                               FALSE, FALSE, TRUE));
8188   /* Move dynamic linking info to the function descriptor sym.  */
8189   if (htab->tls_get_addr != NULL)
8190     func_desc_adjust (&htab->tls_get_addr->elf, info);
8191   htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
8192                            elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
8193                                                  FALSE, FALSE, TRUE));
8194   if (htab->params->tls_get_addr_opt)
8195     {
8196       struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
8197
8198       opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
8199                                   FALSE, FALSE, TRUE);
8200       if (opt != NULL)
8201         func_desc_adjust (opt, info);
8202       opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
8203                                      FALSE, FALSE, TRUE);
8204       if (opt_fd != NULL
8205           && (opt_fd->root.type == bfd_link_hash_defined
8206               || opt_fd->root.type == bfd_link_hash_defweak))
8207         {
8208           /* If glibc supports an optimized __tls_get_addr call stub,
8209              signalled by the presence of __tls_get_addr_opt, and we'll
8210              be calling __tls_get_addr via a plt call stub, then
8211              make __tls_get_addr point to __tls_get_addr_opt.  */
8212           tga_fd = &htab->tls_get_addr_fd->elf;
8213           if (htab->elf.dynamic_sections_created
8214               && tga_fd != NULL
8215               && (tga_fd->type == STT_FUNC
8216                   || tga_fd->needs_plt)
8217               && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
8218                    || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
8219                        && tga_fd->root.type == bfd_link_hash_undefweak)))
8220             {
8221               struct plt_entry *ent;
8222
8223               for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
8224                 if (ent->plt.refcount > 0)
8225                   break;
8226               if (ent != NULL)
8227                 {
8228                   tga_fd->root.type = bfd_link_hash_indirect;
8229                   tga_fd->root.u.i.link = &opt_fd->root;
8230                   ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
8231                   if (opt_fd->dynindx != -1)
8232                     {
8233                       /* Use __tls_get_addr_opt in dynamic relocations.  */
8234                       opt_fd->dynindx = -1;
8235                       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8236                                               opt_fd->dynstr_index);
8237                       if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8238                         return NULL;
8239                     }
8240                   htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8241                   tga = &htab->tls_get_addr->elf;
8242                   if (opt != NULL && tga != NULL)
8243                     {
8244                       tga->root.type = bfd_link_hash_indirect;
8245                       tga->root.u.i.link = &opt->root;
8246                       ppc64_elf_copy_indirect_symbol (info, opt, tga);
8247                       _bfd_elf_link_hash_hide_symbol (info, opt,
8248                                                       tga->forced_local);
8249                       htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8250                     }
8251                   htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8252                   htab->tls_get_addr_fd->is_func_descriptor = 1;
8253                   if (htab->tls_get_addr != NULL)
8254                     {
8255                       htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8256                       htab->tls_get_addr->is_func = 1;
8257                     }
8258                 }
8259             }
8260         }
8261       else if (htab->params->tls_get_addr_opt < 0)
8262         htab->params->tls_get_addr_opt = 0;
8263     }
8264   return _bfd_elf_tls_setup (info->output_bfd, info);
8265 }
8266
8267 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8268    HASH1 or HASH2.  */
8269
8270 static bfd_boolean
8271 branch_reloc_hash_match (const bfd *ibfd,
8272                          const Elf_Internal_Rela *rel,
8273                          const struct ppc_link_hash_entry *hash1,
8274                          const struct ppc_link_hash_entry *hash2)
8275 {
8276   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8277   enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8278   unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8279
8280   if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8281     {
8282       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8283       struct elf_link_hash_entry *h;
8284
8285       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8286       h = elf_follow_link (h);
8287       if (h == &hash1->elf || h == &hash2->elf)
8288         return TRUE;
8289     }
8290   return FALSE;
8291 }
8292
8293 /* Run through all the TLS relocs looking for optimization
8294    opportunities.  The linker has been hacked (see ppc64elf.em) to do
8295    a preliminary section layout so that we know the TLS segment
8296    offsets.  We can't optimize earlier because some optimizations need
8297    to know the tp offset, and we need to optimize before allocating
8298    dynamic relocations.  */
8299
8300 bfd_boolean
8301 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8302 {
8303   bfd *ibfd;
8304   asection *sec;
8305   struct ppc_link_hash_table *htab;
8306   unsigned char *toc_ref;
8307   int pass;
8308
8309   if (!bfd_link_executable (info))
8310     return TRUE;
8311
8312   htab = ppc_hash_table (info);
8313   if (htab == NULL)
8314     return FALSE;
8315
8316   /* Make two passes over the relocs.  On the first pass, mark toc
8317      entries involved with tls relocs, and check that tls relocs
8318      involved in setting up a tls_get_addr call are indeed followed by
8319      such a call.  If they are not, we can't do any tls optimization.
8320      On the second pass twiddle tls_mask flags to notify
8321      relocate_section that optimization can be done, and adjust got
8322      and plt refcounts.  */
8323   toc_ref = NULL;
8324   for (pass = 0; pass < 2; ++pass)
8325     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8326       {
8327         Elf_Internal_Sym *locsyms = NULL;
8328         asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8329
8330         for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8331           if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8332             {
8333               Elf_Internal_Rela *relstart, *rel, *relend;
8334               bfd_boolean found_tls_get_addr_arg = 0;
8335
8336               /* Read the relocations.  */
8337               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8338                                                     info->keep_memory);
8339               if (relstart == NULL)
8340                 {
8341                   free (toc_ref);
8342                   return FALSE;
8343                 }
8344
8345               relend = relstart + sec->reloc_count;
8346               for (rel = relstart; rel < relend; rel++)
8347                 {
8348                   enum elf_ppc64_reloc_type r_type;
8349                   unsigned long r_symndx;
8350                   struct elf_link_hash_entry *h;
8351                   Elf_Internal_Sym *sym;
8352                   asection *sym_sec;
8353                   unsigned char *tls_mask;
8354                   unsigned char tls_set, tls_clear, tls_type = 0;
8355                   bfd_vma value;
8356                   bfd_boolean ok_tprel, is_local;
8357                   long toc_ref_index = 0;
8358                   int expecting_tls_get_addr = 0;
8359                   bfd_boolean ret = FALSE;
8360
8361                   r_symndx = ELF64_R_SYM (rel->r_info);
8362                   if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8363                                   r_symndx, ibfd))
8364                     {
8365                     err_free_rel:
8366                       if (elf_section_data (sec)->relocs != relstart)
8367                         free (relstart);
8368                       if (toc_ref != NULL)
8369                         free (toc_ref);
8370                       if (locsyms != NULL
8371                           && (elf_symtab_hdr (ibfd).contents
8372                               != (unsigned char *) locsyms))
8373                         free (locsyms);
8374                       return ret;
8375                     }
8376
8377                   if (h != NULL)
8378                     {
8379                       if (h->root.type == bfd_link_hash_defined
8380                           || h->root.type == bfd_link_hash_defweak)
8381                         value = h->root.u.def.value;
8382                       else if (h->root.type == bfd_link_hash_undefweak)
8383                         value = 0;
8384                       else
8385                         {
8386                           found_tls_get_addr_arg = 0;
8387                           continue;
8388                         }
8389                     }
8390                   else
8391                     /* Symbols referenced by TLS relocs must be of type
8392                        STT_TLS.  So no need for .opd local sym adjust.  */
8393                     value = sym->st_value;
8394
8395                   ok_tprel = FALSE;
8396                   is_local = FALSE;
8397                   if (h == NULL
8398                       || !h->def_dynamic)
8399                     {
8400                       is_local = TRUE;
8401                       if (h != NULL
8402                           && h->root.type == bfd_link_hash_undefweak)
8403                         ok_tprel = TRUE;
8404                       else if (sym_sec != NULL
8405                                && sym_sec->output_section != NULL)
8406                         {
8407                           value += sym_sec->output_offset;
8408                           value += sym_sec->output_section->vma;
8409                           value -= htab->elf.tls_sec->vma;
8410                           ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8411                                       < (bfd_vma) 1 << 32);
8412                         }
8413                     }
8414
8415                   r_type = ELF64_R_TYPE (rel->r_info);
8416                   /* If this section has old-style __tls_get_addr calls
8417                      without marker relocs, then check that each
8418                      __tls_get_addr call reloc is preceded by a reloc
8419                      that conceivably belongs to the __tls_get_addr arg
8420                      setup insn.  If we don't find matching arg setup
8421                      relocs, don't do any tls optimization.  */
8422                   if (pass == 0
8423                       && sec->has_tls_get_addr_call
8424                       && h != NULL
8425                       && (h == &htab->tls_get_addr->elf
8426                           || h == &htab->tls_get_addr_fd->elf)
8427                       && !found_tls_get_addr_arg
8428                       && is_branch_reloc (r_type))
8429                     {
8430                       info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8431                                                 "TLS optimization disabled\n"),
8432                                               ibfd, sec, rel->r_offset);
8433                       ret = TRUE;
8434                       goto err_free_rel;
8435                     }
8436
8437                   found_tls_get_addr_arg = 0;
8438                   switch (r_type)
8439                     {
8440                     case R_PPC64_GOT_TLSLD16:
8441                     case R_PPC64_GOT_TLSLD16_LO:
8442                       expecting_tls_get_addr = 1;
8443                       found_tls_get_addr_arg = 1;
8444                       /* Fall thru */
8445
8446                     case R_PPC64_GOT_TLSLD16_HI:
8447                     case R_PPC64_GOT_TLSLD16_HA:
8448                       /* These relocs should never be against a symbol
8449                          defined in a shared lib.  Leave them alone if
8450                          that turns out to be the case.  */
8451                       if (!is_local)
8452                         continue;
8453
8454                       /* LD -> LE */
8455                       tls_set = 0;
8456                       tls_clear = TLS_LD;
8457                       tls_type = TLS_TLS | TLS_LD;
8458                       break;
8459
8460                     case R_PPC64_GOT_TLSGD16:
8461                     case R_PPC64_GOT_TLSGD16_LO:
8462                       expecting_tls_get_addr = 1;
8463                       found_tls_get_addr_arg = 1;
8464                       /* Fall thru */
8465
8466                     case R_PPC64_GOT_TLSGD16_HI:
8467                     case R_PPC64_GOT_TLSGD16_HA:
8468                       if (ok_tprel)
8469                         /* GD -> LE */
8470                         tls_set = 0;
8471                       else
8472                         /* GD -> IE */
8473                         tls_set = TLS_TLS | TLS_TPRELGD;
8474                       tls_clear = TLS_GD;
8475                       tls_type = TLS_TLS | TLS_GD;
8476                       break;
8477
8478                     case R_PPC64_GOT_TPREL16_DS:
8479                     case R_PPC64_GOT_TPREL16_LO_DS:
8480                     case R_PPC64_GOT_TPREL16_HI:
8481                     case R_PPC64_GOT_TPREL16_HA:
8482                       if (ok_tprel)
8483                         {
8484                           /* IE -> LE */
8485                           tls_set = 0;
8486                           tls_clear = TLS_TPREL;
8487                           tls_type = TLS_TLS | TLS_TPREL;
8488                           break;
8489                         }
8490                       continue;
8491
8492                     case R_PPC64_TLSGD:
8493                     case R_PPC64_TLSLD:
8494                       found_tls_get_addr_arg = 1;
8495                       /* Fall thru */
8496
8497                     case R_PPC64_TLS:
8498                     case R_PPC64_TOC16:
8499                     case R_PPC64_TOC16_LO:
8500                       if (sym_sec == NULL || sym_sec != toc)
8501                         continue;
8502
8503                       /* Mark this toc entry as referenced by a TLS
8504                          code sequence.  We can do that now in the
8505                          case of R_PPC64_TLS, and after checking for
8506                          tls_get_addr for the TOC16 relocs.  */
8507                       if (toc_ref == NULL)
8508                         toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8509                       if (toc_ref == NULL)
8510                         goto err_free_rel;
8511
8512                       if (h != NULL)
8513                         value = h->root.u.def.value;
8514                       else
8515                         value = sym->st_value;
8516                       value += rel->r_addend;
8517                       if (value % 8 != 0)
8518                         continue;
8519                       BFD_ASSERT (value < toc->size
8520                                   && toc->output_offset % 8 == 0);
8521                       toc_ref_index = (value + toc->output_offset) / 8;
8522                       if (r_type == R_PPC64_TLS
8523                           || r_type == R_PPC64_TLSGD
8524                           || r_type == R_PPC64_TLSLD)
8525                         {
8526                           toc_ref[toc_ref_index] = 1;
8527                           continue;
8528                         }
8529
8530                       if (pass != 0 && toc_ref[toc_ref_index] == 0)
8531                         continue;
8532
8533                       tls_set = 0;
8534                       tls_clear = 0;
8535                       expecting_tls_get_addr = 2;
8536                       break;
8537
8538                     case R_PPC64_TPREL64:
8539                       if (pass == 0
8540                           || sec != toc
8541                           || toc_ref == NULL
8542                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8543                         continue;
8544                       if (ok_tprel)
8545                         {
8546                           /* IE -> LE */
8547                           tls_set = TLS_EXPLICIT;
8548                           tls_clear = TLS_TPREL;
8549                           break;
8550                         }
8551                       continue;
8552
8553                     case R_PPC64_DTPMOD64:
8554                       if (pass == 0
8555                           || sec != toc
8556                           || toc_ref == NULL
8557                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8558                         continue;
8559                       if (rel + 1 < relend
8560                           && (rel[1].r_info
8561                               == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8562                           && rel[1].r_offset == rel->r_offset + 8)
8563                         {
8564                           if (ok_tprel)
8565                             /* GD -> LE */
8566                             tls_set = TLS_EXPLICIT | TLS_GD;
8567                           else
8568                             /* GD -> IE */
8569                             tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8570                           tls_clear = TLS_GD;
8571                         }
8572                       else
8573                         {
8574                           if (!is_local)
8575                             continue;
8576
8577                           /* LD -> LE */
8578                           tls_set = TLS_EXPLICIT;
8579                           tls_clear = TLS_LD;
8580                         }
8581                       break;
8582
8583                     default:
8584                       continue;
8585                     }
8586
8587                   if (pass == 0)
8588                     {
8589                       if (!expecting_tls_get_addr
8590                           || !sec->has_tls_get_addr_call)
8591                         continue;
8592
8593                       if (rel + 1 < relend
8594                           && branch_reloc_hash_match (ibfd, rel + 1,
8595                                                       htab->tls_get_addr,
8596                                                       htab->tls_get_addr_fd))
8597                         {
8598                           if (expecting_tls_get_addr == 2)
8599                             {
8600                               /* Check for toc tls entries.  */
8601                               unsigned char *toc_tls;
8602                               int retval;
8603
8604                               retval = get_tls_mask (&toc_tls, NULL, NULL,
8605                                                      &locsyms,
8606                                                      rel, ibfd);
8607                               if (retval == 0)
8608                                 goto err_free_rel;
8609                               if (toc_tls != NULL)
8610                                 {
8611                                   if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8612                                     found_tls_get_addr_arg = 1;
8613                                   if (retval > 1)
8614                                     toc_ref[toc_ref_index] = 1;
8615                                 }
8616                             }
8617                           continue;
8618                         }
8619
8620                       if (expecting_tls_get_addr != 1)
8621                         continue;
8622
8623                       /* Uh oh, we didn't find the expected call.  We
8624                          could just mark this symbol to exclude it
8625                          from tls optimization but it's safer to skip
8626                          the entire optimization.  */
8627                       info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8628                                                 "TLS optimization disabled\n"),
8629                                               ibfd, sec, rel->r_offset);
8630                       ret = TRUE;
8631                       goto err_free_rel;
8632                     }
8633
8634                   if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8635                     {
8636                       struct plt_entry *ent;
8637                       for (ent = htab->tls_get_addr->elf.plt.plist;
8638                            ent != NULL;
8639                            ent = ent->next)
8640                         if (ent->addend == 0)
8641                           {
8642                             if (ent->plt.refcount > 0)
8643                               {
8644                                 ent->plt.refcount -= 1;
8645                                 expecting_tls_get_addr = 0;
8646                               }
8647                             break;
8648                           }
8649                     }
8650
8651                   if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8652                     {
8653                       struct plt_entry *ent;
8654                       for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8655                            ent != NULL;
8656                            ent = ent->next)
8657                         if (ent->addend == 0)
8658                           {
8659                             if (ent->plt.refcount > 0)
8660                               ent->plt.refcount -= 1;
8661                             break;
8662                           }
8663                     }
8664
8665                   if (tls_clear == 0)
8666                     continue;
8667
8668                   if ((tls_set & TLS_EXPLICIT) == 0)
8669                     {
8670                       struct got_entry *ent;
8671
8672                       /* Adjust got entry for this reloc.  */
8673                       if (h != NULL)
8674                         ent = h->got.glist;
8675                       else
8676                         ent = elf_local_got_ents (ibfd)[r_symndx];
8677
8678                       for (; ent != NULL; ent = ent->next)
8679                         if (ent->addend == rel->r_addend
8680                             && ent->owner == ibfd
8681                             && ent->tls_type == tls_type)
8682                           break;
8683                       if (ent == NULL)
8684                         abort ();
8685
8686                       if (tls_set == 0)
8687                         {
8688                           /* We managed to get rid of a got entry.  */
8689                           if (ent->got.refcount > 0)
8690                             ent->got.refcount -= 1;
8691                         }
8692                     }
8693                   else
8694                     {
8695                       /* If we got rid of a DTPMOD/DTPREL reloc pair then
8696                          we'll lose one or two dyn relocs.  */
8697                       if (!dec_dynrel_count (rel->r_info, sec, info,
8698                                              NULL, h, sym))
8699                         return FALSE;
8700
8701                       if (tls_set == (TLS_EXPLICIT | TLS_GD))
8702                         {
8703                           if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8704                                                  NULL, h, sym))
8705                             return FALSE;
8706                         }
8707                     }
8708
8709                   *tls_mask |= tls_set;
8710                   *tls_mask &= ~tls_clear;
8711                 }
8712
8713               if (elf_section_data (sec)->relocs != relstart)
8714                 free (relstart);
8715             }
8716
8717         if (locsyms != NULL
8718             && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8719           {
8720             if (!info->keep_memory)
8721               free (locsyms);
8722             else
8723               elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8724           }
8725       }
8726
8727   if (toc_ref != NULL)
8728     free (toc_ref);
8729   return TRUE;
8730 }
8731
8732 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8733    the values of any global symbols in a toc section that has been
8734    edited.  Globals in toc sections should be a rarity, so this function
8735    sets a flag if any are found in toc sections other than the one just
8736    edited, so that futher hash table traversals can be avoided.  */
8737
8738 struct adjust_toc_info
8739 {
8740   asection *toc;
8741   unsigned long *skip;
8742   bfd_boolean global_toc_syms;
8743 };
8744
8745 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8746
8747 static bfd_boolean
8748 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8749 {
8750   struct ppc_link_hash_entry *eh;
8751   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8752   unsigned long i;
8753
8754   if (h->root.type != bfd_link_hash_defined
8755       && h->root.type != bfd_link_hash_defweak)
8756     return TRUE;
8757
8758   eh = (struct ppc_link_hash_entry *) h;
8759   if (eh->adjust_done)
8760     return TRUE;
8761
8762   if (eh->elf.root.u.def.section == toc_inf->toc)
8763     {
8764       if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8765         i = toc_inf->toc->rawsize >> 3;
8766       else
8767         i = eh->elf.root.u.def.value >> 3;
8768
8769       if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8770         {
8771           (*_bfd_error_handler)
8772             (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8773           do
8774             ++i;
8775           while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8776           eh->elf.root.u.def.value = (bfd_vma) i << 3;
8777         }
8778
8779       eh->elf.root.u.def.value -= toc_inf->skip[i];
8780       eh->adjust_done = 1;
8781     }
8782   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8783     toc_inf->global_toc_syms = TRUE;
8784
8785   return TRUE;
8786 }
8787
8788 /* Return TRUE iff INSN is one we expect on a _LO variety toc/got reloc.  */
8789
8790 static bfd_boolean
8791 ok_lo_toc_insn (unsigned int insn)
8792 {
8793   return ((insn & (0x3f << 26)) == 14u << 26 /* addi */
8794           || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8795           || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8796           || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8797           || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8798           || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8799           || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8800           || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8801           || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8802           || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8803           || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8804           || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8805           || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8806           || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8807           || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
8808               && (insn & 3) != 1)
8809           || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
8810               && ((insn & 3) == 0 || (insn & 3) == 3))
8811           || (insn & (0x3f << 26)) == 12u << 26 /* addic */);
8812 }
8813
8814 /* Examine all relocs referencing .toc sections in order to remove
8815    unused .toc entries.  */
8816
8817 bfd_boolean
8818 ppc64_elf_edit_toc (struct bfd_link_info *info)
8819 {
8820   bfd *ibfd;
8821   struct adjust_toc_info toc_inf;
8822   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8823
8824   htab->do_toc_opt = 1;
8825   toc_inf.global_toc_syms = TRUE;
8826   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8827     {
8828       asection *toc, *sec;
8829       Elf_Internal_Shdr *symtab_hdr;
8830       Elf_Internal_Sym *local_syms;
8831       Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8832       unsigned long *skip, *drop;
8833       unsigned char *used;
8834       unsigned char *keep, last, some_unused;
8835
8836       if (!is_ppc64_elf (ibfd))
8837         continue;
8838
8839       toc = bfd_get_section_by_name (ibfd, ".toc");
8840       if (toc == NULL
8841           || toc->size == 0
8842           || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8843           || discarded_section (toc))
8844         continue;
8845
8846       toc_relocs = NULL;
8847       local_syms = NULL;
8848       symtab_hdr = &elf_symtab_hdr (ibfd);
8849
8850       /* Look at sections dropped from the final link.  */
8851       skip = NULL;
8852       relstart = NULL;
8853       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8854         {
8855           if (sec->reloc_count == 0
8856               || !discarded_section (sec)
8857               || get_opd_info (sec)
8858               || (sec->flags & SEC_ALLOC) == 0
8859               || (sec->flags & SEC_DEBUGGING) != 0)
8860             continue;
8861
8862           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8863           if (relstart == NULL)
8864             goto error_ret;
8865
8866           /* Run through the relocs to see which toc entries might be
8867              unused.  */
8868           for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8869             {
8870               enum elf_ppc64_reloc_type r_type;
8871               unsigned long r_symndx;
8872               asection *sym_sec;
8873               struct elf_link_hash_entry *h;
8874               Elf_Internal_Sym *sym;
8875               bfd_vma val;
8876
8877               r_type = ELF64_R_TYPE (rel->r_info);
8878               switch (r_type)
8879                 {
8880                 default:
8881                   continue;
8882
8883                 case R_PPC64_TOC16:
8884                 case R_PPC64_TOC16_LO:
8885                 case R_PPC64_TOC16_HI:
8886                 case R_PPC64_TOC16_HA:
8887                 case R_PPC64_TOC16_DS:
8888                 case R_PPC64_TOC16_LO_DS:
8889                   break;
8890                 }
8891
8892               r_symndx = ELF64_R_SYM (rel->r_info);
8893               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8894                               r_symndx, ibfd))
8895                 goto error_ret;
8896
8897               if (sym_sec != toc)
8898                 continue;
8899
8900               if (h != NULL)
8901                 val = h->root.u.def.value;
8902               else
8903                 val = sym->st_value;
8904               val += rel->r_addend;
8905
8906               if (val >= toc->size)
8907                 continue;
8908
8909               /* Anything in the toc ought to be aligned to 8 bytes.
8910                  If not, don't mark as unused.  */
8911               if (val & 7)
8912                 continue;
8913
8914               if (skip == NULL)
8915                 {
8916                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8917                   if (skip == NULL)
8918                     goto error_ret;
8919                 }
8920
8921               skip[val >> 3] = ref_from_discarded;
8922             }
8923
8924           if (elf_section_data (sec)->relocs != relstart)
8925             free (relstart);
8926         }
8927
8928       /* For largetoc loads of address constants, we can convert
8929          .  addis rx,2,addr@got@ha
8930          .  ld ry,addr@got@l(rx)
8931          to
8932          .  addis rx,2,addr@toc@ha
8933          .  addi ry,rx,addr@toc@l
8934          when addr is within 2G of the toc pointer.  This then means
8935          that the word storing "addr" in the toc is no longer needed.  */
8936
8937       if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
8938           && toc->output_section->rawsize < (bfd_vma) 1 << 31
8939           && toc->reloc_count != 0)
8940         {
8941           /* Read toc relocs.  */
8942           toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8943                                                   info->keep_memory);
8944           if (toc_relocs == NULL)
8945             goto error_ret;
8946
8947           for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8948             {
8949               enum elf_ppc64_reloc_type r_type;
8950               unsigned long r_symndx;
8951               asection *sym_sec;
8952               struct elf_link_hash_entry *h;
8953               Elf_Internal_Sym *sym;
8954               bfd_vma val, addr;
8955
8956               r_type = ELF64_R_TYPE (rel->r_info);
8957               if (r_type != R_PPC64_ADDR64)
8958                 continue;
8959
8960               r_symndx = ELF64_R_SYM (rel->r_info);
8961               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8962                               r_symndx, ibfd))
8963                 goto error_ret;
8964
8965               if (sym_sec == NULL
8966                   || sym_sec->output_section == NULL
8967                   || discarded_section (sym_sec))
8968                 continue;
8969
8970               if (!SYMBOL_REFERENCES_LOCAL (info, h))
8971                 continue;
8972
8973               if (h != NULL)
8974                 {
8975                   if (h->type == STT_GNU_IFUNC)
8976                     continue;
8977                   val = h->root.u.def.value;
8978                 }
8979               else
8980                 {
8981                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
8982                     continue;
8983                   val = sym->st_value;
8984                 }
8985               val += rel->r_addend;
8986               val += sym_sec->output_section->vma + sym_sec->output_offset;
8987
8988               /* We don't yet know the exact toc pointer value, but we
8989                  know it will be somewhere in the toc section.  Don't
8990                  optimize if the difference from any possible toc
8991                  pointer is outside [ff..f80008000, 7fff7fff].  */
8992               addr = toc->output_section->vma + TOC_BASE_OFF;
8993               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8994                 continue;
8995
8996               addr = toc->output_section->vma + toc->output_section->rawsize;
8997               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8998                 continue;
8999
9000               if (skip == NULL)
9001                 {
9002                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9003                   if (skip == NULL)
9004                     goto error_ret;
9005                 }
9006
9007               skip[rel->r_offset >> 3]
9008                 |= can_optimize | ((rel - toc_relocs) << 2);
9009             }
9010         }
9011
9012       if (skip == NULL)
9013         continue;
9014
9015       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
9016       if (used == NULL)
9017         {
9018         error_ret:
9019           if (local_syms != NULL
9020               && symtab_hdr->contents != (unsigned char *) local_syms)
9021             free (local_syms);
9022           if (sec != NULL
9023               && relstart != NULL
9024               && elf_section_data (sec)->relocs != relstart)
9025             free (relstart);
9026           if (toc_relocs != NULL
9027               && elf_section_data (toc)->relocs != toc_relocs)
9028             free (toc_relocs);
9029           if (skip != NULL)
9030             free (skip);
9031           return FALSE;
9032         }
9033
9034       /* Now check all kept sections that might reference the toc.
9035          Check the toc itself last.  */
9036       for (sec = (ibfd->sections == toc && toc->next ? toc->next
9037                   : ibfd->sections);
9038            sec != NULL;
9039            sec = (sec == toc ? NULL
9040                   : sec->next == NULL ? toc
9041                   : sec->next == toc && toc->next ? toc->next
9042                   : sec->next))
9043         {
9044           int repeat;
9045
9046           if (sec->reloc_count == 0
9047               || discarded_section (sec)
9048               || get_opd_info (sec)
9049               || (sec->flags & SEC_ALLOC) == 0
9050               || (sec->flags & SEC_DEBUGGING) != 0)
9051             continue;
9052
9053           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9054                                                 info->keep_memory);
9055           if (relstart == NULL)
9056             {
9057               free (used);
9058               goto error_ret;
9059             }
9060
9061           /* Mark toc entries referenced as used.  */
9062           do
9063             {
9064               repeat = 0;
9065               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9066                 {
9067                   enum elf_ppc64_reloc_type r_type;
9068                   unsigned long r_symndx;
9069                   asection *sym_sec;
9070                   struct elf_link_hash_entry *h;
9071                   Elf_Internal_Sym *sym;
9072                   bfd_vma val;
9073                   enum {no_check, check_lo, check_ha} insn_check;
9074
9075                   r_type = ELF64_R_TYPE (rel->r_info);
9076                   switch (r_type)
9077                     {
9078                     default:
9079                       insn_check = no_check;
9080                       break;
9081
9082                     case R_PPC64_GOT_TLSLD16_HA:
9083                     case R_PPC64_GOT_TLSGD16_HA:
9084                     case R_PPC64_GOT_TPREL16_HA:
9085                     case R_PPC64_GOT_DTPREL16_HA:
9086                     case R_PPC64_GOT16_HA:
9087                     case R_PPC64_TOC16_HA:
9088                       insn_check = check_ha;
9089                       break;
9090
9091                     case R_PPC64_GOT_TLSLD16_LO:
9092                     case R_PPC64_GOT_TLSGD16_LO:
9093                     case R_PPC64_GOT_TPREL16_LO_DS:
9094                     case R_PPC64_GOT_DTPREL16_LO_DS:
9095                     case R_PPC64_GOT16_LO:
9096                     case R_PPC64_GOT16_LO_DS:
9097                     case R_PPC64_TOC16_LO:
9098                     case R_PPC64_TOC16_LO_DS:
9099                       insn_check = check_lo;
9100                       break;
9101                     }
9102
9103                   if (insn_check != no_check)
9104                     {
9105                       bfd_vma off = rel->r_offset & ~3;
9106                       unsigned char buf[4];
9107                       unsigned int insn;
9108
9109                       if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
9110                         {
9111                           free (used);
9112                           goto error_ret;
9113                         }
9114                       insn = bfd_get_32 (ibfd, buf);
9115                       if (insn_check == check_lo
9116                           ? !ok_lo_toc_insn (insn)
9117                           : ((insn & ((0x3f << 26) | 0x1f << 16))
9118                              != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9119                         {
9120                           char str[12];
9121
9122                           ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
9123                           sprintf (str, "%#08x", insn);
9124                           info->callbacks->einfo
9125                             (_("%P: %H: toc optimization is not supported for"
9126                                " %s instruction.\n"),
9127                              ibfd, sec, rel->r_offset & ~3, str);
9128                         }
9129                     }
9130
9131                   switch (r_type)
9132                     {
9133                     case R_PPC64_TOC16:
9134                     case R_PPC64_TOC16_LO:
9135                     case R_PPC64_TOC16_HI:
9136                     case R_PPC64_TOC16_HA:
9137                     case R_PPC64_TOC16_DS:
9138                     case R_PPC64_TOC16_LO_DS:
9139                       /* In case we're taking addresses of toc entries.  */
9140                     case R_PPC64_ADDR64:
9141                       break;
9142
9143                     default:
9144                       continue;
9145                     }
9146
9147                   r_symndx = ELF64_R_SYM (rel->r_info);
9148                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9149                                   r_symndx, ibfd))
9150                     {
9151                       free (used);
9152                       goto error_ret;
9153                     }
9154
9155                   if (sym_sec != toc)
9156                     continue;
9157
9158                   if (h != NULL)
9159                     val = h->root.u.def.value;
9160                   else
9161                     val = sym->st_value;
9162                   val += rel->r_addend;
9163
9164                   if (val >= toc->size)
9165                     continue;
9166
9167                   if ((skip[val >> 3] & can_optimize) != 0)
9168                     {
9169                       bfd_vma off;
9170                       unsigned char opc;
9171
9172                       switch (r_type)
9173                         {
9174                         case R_PPC64_TOC16_HA:
9175                           break;
9176
9177                         case R_PPC64_TOC16_LO_DS:
9178                           off = rel->r_offset;
9179                           off += (bfd_big_endian (ibfd) ? -2 : 3);
9180                           if (!bfd_get_section_contents (ibfd, sec, &opc,
9181                                                          off, 1))
9182                             {
9183                               free (used);
9184                               goto error_ret;
9185                             }
9186                           if ((opc & (0x3f << 2)) == (58u << 2))
9187                             break;
9188                           /* Fall thru */
9189
9190                         default:
9191                           /* Wrong sort of reloc, or not a ld.  We may
9192                              as well clear ref_from_discarded too.  */
9193                           skip[val >> 3] = 0;
9194                         }
9195                     }
9196
9197                   if (sec != toc)
9198                     used[val >> 3] = 1;
9199                   /* For the toc section, we only mark as used if this
9200                      entry itself isn't unused.  */
9201                   else if ((used[rel->r_offset >> 3]
9202                             || !(skip[rel->r_offset >> 3] & ref_from_discarded))
9203                            && !used[val >> 3])
9204                     {
9205                       /* Do all the relocs again, to catch reference
9206                          chains.  */
9207                       repeat = 1;
9208                       used[val >> 3] = 1;
9209                     }
9210                 }
9211             }
9212           while (repeat);
9213
9214           if (elf_section_data (sec)->relocs != relstart)
9215             free (relstart);
9216         }
9217
9218       /* Merge the used and skip arrays.  Assume that TOC
9219          doublewords not appearing as either used or unused belong
9220          to to an entry more than one doubleword in size.  */
9221       for (drop = skip, keep = used, last = 0, some_unused = 0;
9222            drop < skip + (toc->size + 7) / 8;
9223            ++drop, ++keep)
9224         {
9225           if (*keep)
9226             {
9227               *drop &= ~ref_from_discarded;
9228               if ((*drop & can_optimize) != 0)
9229                 some_unused = 1;
9230               last = 0;
9231             }
9232           else if ((*drop & ref_from_discarded) != 0)
9233             {
9234               some_unused = 1;
9235               last = ref_from_discarded;
9236             }
9237           else
9238             *drop = last;
9239         }
9240
9241       free (used);
9242
9243       if (some_unused)
9244         {
9245           bfd_byte *contents, *src;
9246           unsigned long off;
9247           Elf_Internal_Sym *sym;
9248           bfd_boolean local_toc_syms = FALSE;
9249
9250           /* Shuffle the toc contents, and at the same time convert the
9251              skip array from booleans into offsets.  */
9252           if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9253             goto error_ret;
9254
9255           elf_section_data (toc)->this_hdr.contents = contents;
9256
9257           for (src = contents, off = 0, drop = skip;
9258                src < contents + toc->size;
9259                src += 8, ++drop)
9260             {
9261               if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9262                 off += 8;
9263               else if (off != 0)
9264                 {
9265                   *drop = off;
9266                   memcpy (src - off, src, 8);
9267                 }
9268             }
9269           *drop = off;
9270           toc->rawsize = toc->size;
9271           toc->size = src - contents - off;
9272
9273           /* Adjust addends for relocs against the toc section sym,
9274              and optimize any accesses we can.  */
9275           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9276             {
9277               if (sec->reloc_count == 0
9278                   || discarded_section (sec))
9279                 continue;
9280
9281               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9282                                                     info->keep_memory);
9283               if (relstart == NULL)
9284                 goto error_ret;
9285
9286               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9287                 {
9288                   enum elf_ppc64_reloc_type r_type;
9289                   unsigned long r_symndx;
9290                   asection *sym_sec;
9291                   struct elf_link_hash_entry *h;
9292                   bfd_vma val;
9293
9294                   r_type = ELF64_R_TYPE (rel->r_info);
9295                   switch (r_type)
9296                     {
9297                     default:
9298                       continue;
9299
9300                     case R_PPC64_TOC16:
9301                     case R_PPC64_TOC16_LO:
9302                     case R_PPC64_TOC16_HI:
9303                     case R_PPC64_TOC16_HA:
9304                     case R_PPC64_TOC16_DS:
9305                     case R_PPC64_TOC16_LO_DS:
9306                     case R_PPC64_ADDR64:
9307                       break;
9308                     }
9309
9310                   r_symndx = ELF64_R_SYM (rel->r_info);
9311                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9312                                   r_symndx, ibfd))
9313                     goto error_ret;
9314
9315                   if (sym_sec != toc)
9316                     continue;
9317
9318                   if (h != NULL)
9319                     val = h->root.u.def.value;
9320                   else
9321                     {
9322                       val = sym->st_value;
9323                       if (val != 0)
9324                         local_toc_syms = TRUE;
9325                     }
9326
9327                   val += rel->r_addend;
9328
9329                   if (val > toc->rawsize)
9330                     val = toc->rawsize;
9331                   else if ((skip[val >> 3] & ref_from_discarded) != 0)
9332                     continue;
9333                   else if ((skip[val >> 3] & can_optimize) != 0)
9334                     {
9335                       Elf_Internal_Rela *tocrel
9336                         = toc_relocs + (skip[val >> 3] >> 2);
9337                       unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9338
9339                       switch (r_type)
9340                         {
9341                         case R_PPC64_TOC16_HA:
9342                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9343                           break;
9344
9345                         case R_PPC64_TOC16_LO_DS:
9346                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9347                           break;
9348
9349                         default:
9350                           if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9351                             ppc_howto_init ();
9352                           info->callbacks->einfo
9353                             (_("%P: %H: %s references "
9354                                "optimized away TOC entry\n"),
9355                              ibfd, sec, rel->r_offset,
9356                              ppc64_elf_howto_table[r_type]->name);
9357                           bfd_set_error (bfd_error_bad_value);
9358                           goto error_ret;
9359                         }
9360                       rel->r_addend = tocrel->r_addend;
9361                       elf_section_data (sec)->relocs = relstart;
9362                       continue;
9363                     }
9364
9365                   if (h != NULL || sym->st_value != 0)
9366                     continue;
9367
9368                   rel->r_addend -= skip[val >> 3];
9369                   elf_section_data (sec)->relocs = relstart;
9370                 }
9371
9372               if (elf_section_data (sec)->relocs != relstart)
9373                 free (relstart);
9374             }
9375
9376           /* We shouldn't have local or global symbols defined in the TOC,
9377              but handle them anyway.  */
9378           if (local_syms != NULL)
9379             for (sym = local_syms;
9380                  sym < local_syms + symtab_hdr->sh_info;
9381                  ++sym)
9382               if (sym->st_value != 0
9383                   && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9384                 {
9385                   unsigned long i;
9386
9387                   if (sym->st_value > toc->rawsize)
9388                     i = toc->rawsize >> 3;
9389                   else
9390                     i = sym->st_value >> 3;
9391
9392                   if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9393                     {
9394                       if (local_toc_syms)
9395                         (*_bfd_error_handler)
9396                           (_("%s defined on removed toc entry"),
9397                            bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9398                       do
9399                         ++i;
9400                       while ((skip[i] & (ref_from_discarded | can_optimize)));
9401                       sym->st_value = (bfd_vma) i << 3;
9402                     }
9403
9404                   sym->st_value -= skip[i];
9405                   symtab_hdr->contents = (unsigned char *) local_syms;
9406                 }
9407
9408           /* Adjust any global syms defined in this toc input section.  */
9409           if (toc_inf.global_toc_syms)
9410             {
9411               toc_inf.toc = toc;
9412               toc_inf.skip = skip;
9413               toc_inf.global_toc_syms = FALSE;
9414               elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9415                                       &toc_inf);
9416             }
9417
9418           if (toc->reloc_count != 0)
9419             {
9420               Elf_Internal_Shdr *rel_hdr;
9421               Elf_Internal_Rela *wrel;
9422               bfd_size_type sz;
9423
9424               /* Remove unused toc relocs, and adjust those we keep.  */
9425               if (toc_relocs == NULL)
9426                 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9427                                                         info->keep_memory);
9428               if (toc_relocs == NULL)
9429                 goto error_ret;
9430
9431               wrel = toc_relocs;
9432               for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9433                 if ((skip[rel->r_offset >> 3]
9434                      & (ref_from_discarded | can_optimize)) == 0)
9435                   {
9436                     wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9437                     wrel->r_info = rel->r_info;
9438                     wrel->r_addend = rel->r_addend;
9439                     ++wrel;
9440                   }
9441                 else if (!dec_dynrel_count (rel->r_info, toc, info,
9442                                             &local_syms, NULL, NULL))
9443                   goto error_ret;
9444
9445               elf_section_data (toc)->relocs = toc_relocs;
9446               toc->reloc_count = wrel - toc_relocs;
9447               rel_hdr = _bfd_elf_single_rel_hdr (toc);
9448               sz = rel_hdr->sh_entsize;
9449               rel_hdr->sh_size = toc->reloc_count * sz;
9450             }
9451         }
9452       else if (toc_relocs != NULL
9453                && elf_section_data (toc)->relocs != toc_relocs)
9454         free (toc_relocs);
9455
9456       if (local_syms != NULL
9457           && symtab_hdr->contents != (unsigned char *) local_syms)
9458         {
9459           if (!info->keep_memory)
9460             free (local_syms);
9461           else
9462             symtab_hdr->contents = (unsigned char *) local_syms;
9463         }
9464       free (skip);
9465     }
9466
9467   return TRUE;
9468 }
9469
9470 /* Return true iff input section I references the TOC using
9471    instructions limited to +/-32k offsets.  */
9472
9473 bfd_boolean
9474 ppc64_elf_has_small_toc_reloc (asection *i)
9475 {
9476   return (is_ppc64_elf (i->owner)
9477           && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9478 }
9479
9480 /* Allocate space for one GOT entry.  */
9481
9482 static void
9483 allocate_got (struct elf_link_hash_entry *h,
9484               struct bfd_link_info *info,
9485               struct got_entry *gent)
9486 {
9487   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9488   bfd_boolean dyn;
9489   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9490   int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9491                  ? 16 : 8);
9492   int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9493                   ? 2 : 1) * sizeof (Elf64_External_Rela);
9494   asection *got = ppc64_elf_tdata (gent->owner)->got;
9495
9496   gent->got.offset = got->size;
9497   got->size += entsize;
9498
9499   dyn = htab->elf.dynamic_sections_created;
9500   if (h->type == STT_GNU_IFUNC)
9501     {
9502       htab->elf.irelplt->size += rentsize;
9503       htab->got_reli_size += rentsize;
9504     }
9505   else if ((bfd_link_pic (info)
9506             || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
9507            && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9508                || h->root.type != bfd_link_hash_undefweak))
9509     {
9510       asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9511       relgot->size += rentsize;
9512     }
9513 }
9514
9515 /* This function merges got entries in the same toc group.  */
9516
9517 static void
9518 merge_got_entries (struct got_entry **pent)
9519 {
9520   struct got_entry *ent, *ent2;
9521
9522   for (ent = *pent; ent != NULL; ent = ent->next)
9523     if (!ent->is_indirect)
9524       for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9525         if (!ent2->is_indirect
9526             && ent2->addend == ent->addend
9527             && ent2->tls_type == ent->tls_type
9528             && elf_gp (ent2->owner) == elf_gp (ent->owner))
9529           {
9530             ent2->is_indirect = TRUE;
9531             ent2->got.ent = ent;
9532           }
9533 }
9534
9535 /* Allocate space in .plt, .got and associated reloc sections for
9536    dynamic relocs.  */
9537
9538 static bfd_boolean
9539 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9540 {
9541   struct bfd_link_info *info;
9542   struct ppc_link_hash_table *htab;
9543   asection *s;
9544   struct ppc_link_hash_entry *eh;
9545   struct elf_dyn_relocs *p;
9546   struct got_entry **pgent, *gent;
9547
9548   if (h->root.type == bfd_link_hash_indirect)
9549     return TRUE;
9550
9551   info = (struct bfd_link_info *) inf;
9552   htab = ppc_hash_table (info);
9553   if (htab == NULL)
9554     return FALSE;
9555
9556   if ((htab->elf.dynamic_sections_created
9557        && h->dynindx != -1
9558        && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
9559       || h->type == STT_GNU_IFUNC)
9560     {
9561       struct plt_entry *pent;
9562       bfd_boolean doneone = FALSE;
9563       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9564         if (pent->plt.refcount > 0)
9565           {
9566             if (!htab->elf.dynamic_sections_created
9567                 || h->dynindx == -1)
9568               {
9569                 s = htab->elf.iplt;
9570                 pent->plt.offset = s->size;
9571                 s->size += PLT_ENTRY_SIZE (htab);
9572                 s = htab->elf.irelplt;
9573               }
9574             else
9575               {
9576                 /* If this is the first .plt entry, make room for the special
9577                    first entry.  */
9578                 s = htab->elf.splt;
9579                 if (s->size == 0)
9580                   s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9581
9582                 pent->plt.offset = s->size;
9583
9584                 /* Make room for this entry.  */
9585                 s->size += PLT_ENTRY_SIZE (htab);
9586
9587                 /* Make room for the .glink code.  */
9588                 s = htab->glink;
9589                 if (s->size == 0)
9590                   s->size += GLINK_CALL_STUB_SIZE;
9591                 if (htab->opd_abi)
9592                   {
9593                     /* We need bigger stubs past index 32767.  */
9594                     if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9595                       s->size += 4;
9596                     s->size += 2*4;
9597                   }
9598                 else
9599                   s->size += 4;
9600
9601                 /* We also need to make an entry in the .rela.plt section.  */
9602                 s = htab->elf.srelplt;
9603               }
9604             s->size += sizeof (Elf64_External_Rela);
9605             doneone = TRUE;
9606           }
9607         else
9608           pent->plt.offset = (bfd_vma) -1;
9609       if (!doneone)
9610         {
9611           h->plt.plist = NULL;
9612           h->needs_plt = 0;
9613         }
9614     }
9615   else
9616     {
9617       h->plt.plist = NULL;
9618       h->needs_plt = 0;
9619     }
9620
9621   eh = (struct ppc_link_hash_entry *) h;
9622   /* Run through the TLS GD got entries first if we're changing them
9623      to TPREL.  */
9624   if ((eh->tls_mask & TLS_TPRELGD) != 0)
9625     for (gent = h->got.glist; gent != NULL; gent = gent->next)
9626       if (gent->got.refcount > 0
9627           && (gent->tls_type & TLS_GD) != 0)
9628         {
9629           /* This was a GD entry that has been converted to TPREL.  If
9630              there happens to be a TPREL entry we can use that one.  */
9631           struct got_entry *ent;
9632           for (ent = h->got.glist; ent != NULL; ent = ent->next)
9633             if (ent->got.refcount > 0
9634                 && (ent->tls_type & TLS_TPREL) != 0
9635                 && ent->addend == gent->addend
9636                 && ent->owner == gent->owner)
9637               {
9638                 gent->got.refcount = 0;
9639                 break;
9640               }
9641
9642           /* If not, then we'll be using our own TPREL entry.  */
9643           if (gent->got.refcount != 0)
9644             gent->tls_type = TLS_TLS | TLS_TPREL;
9645         }
9646
9647   /* Remove any list entry that won't generate a word in the GOT before
9648      we call merge_got_entries.  Otherwise we risk merging to empty
9649      entries.  */
9650   pgent = &h->got.glist;
9651   while ((gent = *pgent) != NULL)
9652     if (gent->got.refcount > 0)
9653       {
9654         if ((gent->tls_type & TLS_LD) != 0
9655             && !h->def_dynamic)
9656           {
9657             ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9658             *pgent = gent->next;
9659           }
9660         else
9661           pgent = &gent->next;
9662       }
9663     else
9664       *pgent = gent->next;
9665
9666   if (!htab->do_multi_toc)
9667     merge_got_entries (&h->got.glist);
9668
9669   for (gent = h->got.glist; gent != NULL; gent = gent->next)
9670     if (!gent->is_indirect)
9671       {
9672         /* Make sure this symbol is output as a dynamic symbol.
9673            Undefined weak syms won't yet be marked as dynamic,
9674            nor will all TLS symbols.  */
9675         if (h->dynindx == -1
9676             && !h->forced_local
9677             && h->type != STT_GNU_IFUNC
9678             && htab->elf.dynamic_sections_created)
9679           {
9680             if (! bfd_elf_link_record_dynamic_symbol (info, h))
9681               return FALSE;
9682           }
9683
9684         if (!is_ppc64_elf (gent->owner))
9685           abort ();
9686
9687         allocate_got (h, info, gent);
9688       }
9689
9690   if (eh->dyn_relocs == NULL
9691       || (!htab->elf.dynamic_sections_created
9692           && h->type != STT_GNU_IFUNC))
9693     return TRUE;
9694
9695   /* In the shared -Bsymbolic case, discard space allocated for
9696      dynamic pc-relative relocs against symbols which turn out to be
9697      defined in regular objects.  For the normal shared case, discard
9698      space for relocs that have become local due to symbol visibility
9699      changes.  */
9700
9701   if (bfd_link_pic (info))
9702     {
9703       /* Relocs that use pc_count are those that appear on a call insn,
9704          or certain REL relocs (see must_be_dyn_reloc) that can be
9705          generated via assembly.  We want calls to protected symbols to
9706          resolve directly to the function rather than going via the plt.
9707          If people want function pointer comparisons to work as expected
9708          then they should avoid writing weird assembly.  */
9709       if (SYMBOL_CALLS_LOCAL (info, h))
9710         {
9711           struct elf_dyn_relocs **pp;
9712
9713           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9714             {
9715               p->count -= p->pc_count;
9716               p->pc_count = 0;
9717               if (p->count == 0)
9718                 *pp = p->next;
9719               else
9720                 pp = &p->next;
9721             }
9722         }
9723
9724       /* Also discard relocs on undefined weak syms with non-default
9725          visibility.  */
9726       if (eh->dyn_relocs != NULL
9727           && h->root.type == bfd_link_hash_undefweak)
9728         {
9729           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9730             eh->dyn_relocs = NULL;
9731
9732           /* Make sure this symbol is output as a dynamic symbol.
9733              Undefined weak syms won't yet be marked as dynamic.  */
9734           else if (h->dynindx == -1
9735                    && !h->forced_local)
9736             {
9737               if (! bfd_elf_link_record_dynamic_symbol (info, h))
9738                 return FALSE;
9739             }
9740         }
9741     }
9742   else if (h->type == STT_GNU_IFUNC)
9743     {
9744       if (!h->non_got_ref)
9745         eh->dyn_relocs = NULL;
9746     }
9747   else if (ELIMINATE_COPY_RELOCS)
9748     {
9749       /* For the non-shared case, discard space for relocs against
9750          symbols which turn out to need copy relocs or are not
9751          dynamic.  */
9752
9753       if (!h->non_got_ref
9754           && !h->def_regular)
9755         {
9756           /* Make sure this symbol is output as a dynamic symbol.
9757              Undefined weak syms won't yet be marked as dynamic.  */
9758           if (h->dynindx == -1
9759               && !h->forced_local)
9760             {
9761               if (! bfd_elf_link_record_dynamic_symbol (info, h))
9762                 return FALSE;
9763             }
9764
9765           /* If that succeeded, we know we'll be keeping all the
9766              relocs.  */
9767           if (h->dynindx != -1)
9768             goto keep;
9769         }
9770
9771       eh->dyn_relocs = NULL;
9772
9773     keep: ;
9774     }
9775
9776   /* Finally, allocate space.  */
9777   for (p = eh->dyn_relocs; p != NULL; p = p->next)
9778     {
9779       asection *sreloc = elf_section_data (p->sec)->sreloc;
9780       if (eh->elf.type == STT_GNU_IFUNC)
9781         sreloc = htab->elf.irelplt;
9782       sreloc->size += p->count * sizeof (Elf64_External_Rela);
9783     }
9784
9785   return TRUE;
9786 }
9787
9788 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9789    to set up space for global entry stubs.  These are put in glink,
9790    after the branch table.  */
9791
9792 static bfd_boolean
9793 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
9794 {
9795   struct bfd_link_info *info;
9796   struct ppc_link_hash_table *htab;
9797   struct plt_entry *pent;
9798   asection *s;
9799
9800   if (h->root.type == bfd_link_hash_indirect)
9801     return TRUE;
9802
9803   if (!h->pointer_equality_needed)
9804     return TRUE;
9805
9806   if (h->def_regular)
9807     return TRUE;
9808
9809   info = inf;
9810   htab = ppc_hash_table (info);
9811   if (htab == NULL)
9812     return FALSE;
9813
9814   s = htab->glink;
9815   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9816     if (pent->plt.offset != (bfd_vma) -1
9817         && pent->addend == 0)
9818       {
9819         /* For ELFv2, if this symbol is not defined in a regular file
9820            and we are not generating a shared library or pie, then we
9821            need to define the symbol in the executable on a call stub.
9822            This is to avoid text relocations.  */
9823         s->size = (s->size + 15) & -16;
9824         h->root.u.def.section = s;
9825         h->root.u.def.value = s->size;
9826         s->size += 16;
9827         break;
9828       }
9829   return TRUE;
9830 }
9831
9832 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9833    read-only sections.  */
9834
9835 static bfd_boolean
9836 maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
9837 {
9838   if (h->root.type == bfd_link_hash_indirect)
9839     return TRUE;
9840
9841   if (readonly_dynrelocs (h))
9842     {
9843       ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
9844
9845       /* Not an error, just cut short the traversal.  */
9846       return FALSE;
9847     }
9848   return TRUE;
9849 }
9850
9851 /* Set the sizes of the dynamic sections.  */
9852
9853 static bfd_boolean
9854 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
9855                                  struct bfd_link_info *info)
9856 {
9857   struct ppc_link_hash_table *htab;
9858   bfd *dynobj;
9859   asection *s;
9860   bfd_boolean relocs;
9861   bfd *ibfd;
9862   struct got_entry *first_tlsld;
9863
9864   htab = ppc_hash_table (info);
9865   if (htab == NULL)
9866     return FALSE;
9867
9868   dynobj = htab->elf.dynobj;
9869   if (dynobj == NULL)
9870     abort ();
9871
9872   if (htab->elf.dynamic_sections_created)
9873     {
9874       /* Set the contents of the .interp section to the interpreter.  */
9875       if (bfd_link_executable (info) && !info->nointerp)
9876         {
9877           s = bfd_get_linker_section (dynobj, ".interp");
9878           if (s == NULL)
9879             abort ();
9880           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
9881           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
9882         }
9883     }
9884
9885   /* Set up .got offsets for local syms, and space for local dynamic
9886      relocs.  */
9887   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9888     {
9889       struct got_entry **lgot_ents;
9890       struct got_entry **end_lgot_ents;
9891       struct plt_entry **local_plt;
9892       struct plt_entry **end_local_plt;
9893       unsigned char *lgot_masks;
9894       bfd_size_type locsymcount;
9895       Elf_Internal_Shdr *symtab_hdr;
9896
9897       if (!is_ppc64_elf (ibfd))
9898         continue;
9899
9900       for (s = ibfd->sections; s != NULL; s = s->next)
9901         {
9902           struct ppc_dyn_relocs *p;
9903
9904           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
9905             {
9906               if (!bfd_is_abs_section (p->sec)
9907                   && bfd_is_abs_section (p->sec->output_section))
9908                 {
9909                   /* Input section has been discarded, either because
9910                      it is a copy of a linkonce section or due to
9911                      linker script /DISCARD/, so we'll be discarding
9912                      the relocs too.  */
9913                 }
9914               else if (p->count != 0)
9915                 {
9916                   asection *srel = elf_section_data (p->sec)->sreloc;
9917                   if (p->ifunc)
9918                     srel = htab->elf.irelplt;
9919                   srel->size += p->count * sizeof (Elf64_External_Rela);
9920                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
9921                     info->flags |= DF_TEXTREL;
9922                 }
9923             }
9924         }
9925
9926       lgot_ents = elf_local_got_ents (ibfd);
9927       if (!lgot_ents)
9928         continue;
9929
9930       symtab_hdr = &elf_symtab_hdr (ibfd);
9931       locsymcount = symtab_hdr->sh_info;
9932       end_lgot_ents = lgot_ents + locsymcount;
9933       local_plt = (struct plt_entry **) end_lgot_ents;
9934       end_local_plt = local_plt + locsymcount;
9935       lgot_masks = (unsigned char *) end_local_plt;
9936       s = ppc64_elf_tdata (ibfd)->got;
9937       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
9938         {
9939           struct got_entry **pent, *ent;
9940
9941           pent = lgot_ents;
9942           while ((ent = *pent) != NULL)
9943             if (ent->got.refcount > 0)
9944               {
9945                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
9946                   {
9947                     ppc64_tlsld_got (ibfd)->got.refcount += 1;
9948                     *pent = ent->next;
9949                   }
9950                 else
9951                   {
9952                     unsigned int ent_size = 8;
9953                     unsigned int rel_size = sizeof (Elf64_External_Rela);
9954
9955                     ent->got.offset = s->size;
9956                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
9957                       {
9958                         ent_size *= 2;
9959                         rel_size *= 2;
9960                       }
9961                     s->size += ent_size;
9962                     if ((*lgot_masks & PLT_IFUNC) != 0)
9963                       {
9964                         htab->elf.irelplt->size += rel_size;
9965                         htab->got_reli_size += rel_size;
9966                       }
9967                     else if (bfd_link_pic (info))
9968                       {
9969                         asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9970                         srel->size += rel_size;
9971                       }
9972                     pent = &ent->next;
9973                   }
9974               }
9975             else
9976               *pent = ent->next;
9977         }
9978
9979       /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt.  */
9980       for (; local_plt < end_local_plt; ++local_plt)
9981         {
9982           struct plt_entry *ent;
9983
9984           for (ent = *local_plt; ent != NULL; ent = ent->next)
9985             if (ent->plt.refcount > 0)
9986               {
9987                 s = htab->elf.iplt;
9988                 ent->plt.offset = s->size;
9989                 s->size += PLT_ENTRY_SIZE (htab);
9990
9991                 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
9992               }
9993             else
9994               ent->plt.offset = (bfd_vma) -1;
9995         }
9996     }
9997
9998   /* Allocate global sym .plt and .got entries, and space for global
9999      sym dynamic relocs.  */
10000   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
10001   /* Stash the end of glink branch table.  */
10002   if (htab->glink != NULL)
10003     htab->glink->rawsize = htab->glink->size;
10004
10005   if (!htab->opd_abi && !bfd_link_pic (info))
10006     elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
10007
10008   first_tlsld = NULL;
10009   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10010     {
10011       struct got_entry *ent;
10012
10013       if (!is_ppc64_elf (ibfd))
10014         continue;
10015
10016       ent = ppc64_tlsld_got (ibfd);
10017       if (ent->got.refcount > 0)
10018         {
10019           if (!htab->do_multi_toc && first_tlsld != NULL)
10020             {
10021               ent->is_indirect = TRUE;
10022               ent->got.ent = first_tlsld;
10023             }
10024           else
10025             {
10026               if (first_tlsld == NULL)
10027                 first_tlsld = ent;
10028               s = ppc64_elf_tdata (ibfd)->got;
10029               ent->got.offset = s->size;
10030               ent->owner = ibfd;
10031               s->size += 16;
10032               if (bfd_link_pic (info))
10033                 {
10034                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10035                   srel->size += sizeof (Elf64_External_Rela);
10036                 }
10037             }
10038         }
10039       else
10040         ent->got.offset = (bfd_vma) -1;
10041     }
10042
10043   /* We now have determined the sizes of the various dynamic sections.
10044      Allocate memory for them.  */
10045   relocs = FALSE;
10046   for (s = dynobj->sections; s != NULL; s = s->next)
10047     {
10048       if ((s->flags & SEC_LINKER_CREATED) == 0)
10049         continue;
10050
10051       if (s == htab->brlt || s == htab->relbrlt)
10052         /* These haven't been allocated yet;  don't strip.  */
10053         continue;
10054       else if (s == htab->elf.sgot
10055                || s == htab->elf.splt
10056                || s == htab->elf.iplt
10057                || s == htab->glink
10058                || s == htab->dynbss)
10059         {
10060           /* Strip this section if we don't need it; see the
10061              comment below.  */
10062         }
10063       else if (s == htab->glink_eh_frame)
10064         {
10065           if (!bfd_is_abs_section (s->output_section))
10066             /* Not sized yet.  */
10067             continue;
10068         }
10069       else if (CONST_STRNEQ (s->name, ".rela"))
10070         {
10071           if (s->size != 0)
10072             {
10073               if (s != htab->elf.srelplt)
10074                 relocs = TRUE;
10075
10076               /* We use the reloc_count field as a counter if we need
10077                  to copy relocs into the output file.  */
10078               s->reloc_count = 0;
10079             }
10080         }
10081       else
10082         {
10083           /* It's not one of our sections, so don't allocate space.  */
10084           continue;
10085         }
10086
10087       if (s->size == 0)
10088         {
10089           /* If we don't need this section, strip it from the
10090              output file.  This is mostly to handle .rela.bss and
10091              .rela.plt.  We must create both sections in
10092              create_dynamic_sections, because they must be created
10093              before the linker maps input sections to output
10094              sections.  The linker does that before
10095              adjust_dynamic_symbol is called, and it is that
10096              function which decides whether anything needs to go
10097              into these sections.  */
10098           s->flags |= SEC_EXCLUDE;
10099           continue;
10100         }
10101
10102       if ((s->flags & SEC_HAS_CONTENTS) == 0)
10103         continue;
10104
10105       /* Allocate memory for the section contents.  We use bfd_zalloc
10106          here in case unused entries are not reclaimed before the
10107          section's contents are written out.  This should not happen,
10108          but this way if it does we get a R_PPC64_NONE reloc in .rela
10109          sections instead of garbage.
10110          We also rely on the section contents being zero when writing
10111          the GOT.  */
10112       s->contents = bfd_zalloc (dynobj, s->size);
10113       if (s->contents == NULL)
10114         return FALSE;
10115     }
10116
10117   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10118     {
10119       if (!is_ppc64_elf (ibfd))
10120         continue;
10121
10122       s = ppc64_elf_tdata (ibfd)->got;
10123       if (s != NULL && s != htab->elf.sgot)
10124         {
10125           if (s->size == 0)
10126             s->flags |= SEC_EXCLUDE;
10127           else
10128             {
10129               s->contents = bfd_zalloc (ibfd, s->size);
10130               if (s->contents == NULL)
10131                 return FALSE;
10132             }
10133         }
10134       s = ppc64_elf_tdata (ibfd)->relgot;
10135       if (s != NULL)
10136         {
10137           if (s->size == 0)
10138             s->flags |= SEC_EXCLUDE;
10139           else
10140             {
10141               s->contents = bfd_zalloc (ibfd, s->size);
10142               if (s->contents == NULL)
10143                 return FALSE;
10144               relocs = TRUE;
10145               s->reloc_count = 0;
10146             }
10147         }
10148     }
10149
10150   if (htab->elf.dynamic_sections_created)
10151     {
10152       bfd_boolean tls_opt;
10153
10154       /* Add some entries to the .dynamic section.  We fill in the
10155          values later, in ppc64_elf_finish_dynamic_sections, but we
10156          must add the entries now so that we get the correct size for
10157          the .dynamic section.  The DT_DEBUG entry is filled in by the
10158          dynamic linker and used by the debugger.  */
10159 #define add_dynamic_entry(TAG, VAL) \
10160   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10161
10162       if (bfd_link_executable (info))
10163         {
10164           if (!add_dynamic_entry (DT_DEBUG, 0))
10165             return FALSE;
10166         }
10167
10168       if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
10169         {
10170           if (!add_dynamic_entry (DT_PLTGOT, 0)
10171               || !add_dynamic_entry (DT_PLTRELSZ, 0)
10172               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
10173               || !add_dynamic_entry (DT_JMPREL, 0)
10174               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
10175             return FALSE;
10176         }
10177
10178       if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
10179         {
10180           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
10181               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
10182             return FALSE;
10183         }
10184
10185       tls_opt = (htab->params->tls_get_addr_opt
10186                  && htab->tls_get_addr_fd != NULL
10187                  && htab->tls_get_addr_fd->elf.plt.plist != NULL);
10188       if (tls_opt || !htab->opd_abi)
10189         {
10190           if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
10191             return FALSE;
10192         }
10193
10194       if (relocs)
10195         {
10196           if (!add_dynamic_entry (DT_RELA, 0)
10197               || !add_dynamic_entry (DT_RELASZ, 0)
10198               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
10199             return FALSE;
10200
10201           /* If any dynamic relocs apply to a read-only section,
10202              then we need a DT_TEXTREL entry.  */
10203           if ((info->flags & DF_TEXTREL) == 0)
10204             elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
10205
10206           if ((info->flags & DF_TEXTREL) != 0)
10207             {
10208               if (!add_dynamic_entry (DT_TEXTREL, 0))
10209                 return FALSE;
10210             }
10211         }
10212     }
10213 #undef add_dynamic_entry
10214
10215   return TRUE;
10216 }
10217
10218 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
10219
10220 static bfd_boolean
10221 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
10222 {
10223   if (h->plt.plist != NULL
10224       && !h->def_regular
10225       && !h->pointer_equality_needed)
10226     return FALSE;
10227
10228   return _bfd_elf_hash_symbol (h);
10229 }
10230
10231 /* Determine the type of stub needed, if any, for a call.  */
10232
10233 static inline enum ppc_stub_type
10234 ppc_type_of_stub (asection *input_sec,
10235                   const Elf_Internal_Rela *rel,
10236                   struct ppc_link_hash_entry **hash,
10237                   struct plt_entry **plt_ent,
10238                   bfd_vma destination,
10239                   unsigned long local_off)
10240 {
10241   struct ppc_link_hash_entry *h = *hash;
10242   bfd_vma location;
10243   bfd_vma branch_offset;
10244   bfd_vma max_branch_offset;
10245   enum elf_ppc64_reloc_type r_type;
10246
10247   if (h != NULL)
10248     {
10249       struct plt_entry *ent;
10250       struct ppc_link_hash_entry *fdh = h;
10251       if (h->oh != NULL
10252           && h->oh->is_func_descriptor)
10253         {
10254           fdh = ppc_follow_link (h->oh);
10255           *hash = fdh;
10256         }
10257
10258       for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10259         if (ent->addend == rel->r_addend
10260             && ent->plt.offset != (bfd_vma) -1)
10261           {
10262             *plt_ent = ent;
10263             return ppc_stub_plt_call;
10264           }
10265
10266       /* Here, we know we don't have a plt entry.  If we don't have a
10267          either a defined function descriptor or a defined entry symbol
10268          in a regular object file, then it is pointless trying to make
10269          any other type of stub.  */
10270       if (!is_static_defined (&fdh->elf)
10271           && !is_static_defined (&h->elf))
10272         return ppc_stub_none;
10273     }
10274   else if (elf_local_got_ents (input_sec->owner) != NULL)
10275     {
10276       Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10277       struct plt_entry **local_plt = (struct plt_entry **)
10278         elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10279       unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10280
10281       if (local_plt[r_symndx] != NULL)
10282         {
10283           struct plt_entry *ent;
10284
10285           for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10286             if (ent->addend == rel->r_addend
10287                 && ent->plt.offset != (bfd_vma) -1)
10288               {
10289                 *plt_ent = ent;
10290                 return ppc_stub_plt_call;
10291               }
10292         }
10293     }
10294
10295   /* Determine where the call point is.  */
10296   location = (input_sec->output_offset
10297               + input_sec->output_section->vma
10298               + rel->r_offset);
10299
10300   branch_offset = destination - location;
10301   r_type = ELF64_R_TYPE (rel->r_info);
10302
10303   /* Determine if a long branch stub is needed.  */
10304   max_branch_offset = 1 << 25;
10305   if (r_type != R_PPC64_REL24)
10306     max_branch_offset = 1 << 15;
10307
10308   if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10309     /* We need a stub.  Figure out whether a long_branch or plt_branch
10310        is needed later.  */
10311     return ppc_stub_long_branch;
10312
10313   return ppc_stub_none;
10314 }
10315
10316 /* With power7 weakly ordered memory model, it is possible for ld.so
10317    to update a plt entry in one thread and have another thread see a
10318    stale zero toc entry.  To avoid this we need some sort of acquire
10319    barrier in the call stub.  One solution is to make the load of the
10320    toc word seem to appear to depend on the load of the function entry
10321    word.  Another solution is to test for r2 being zero, and branch to
10322    the appropriate glink entry if so.
10323
10324    .    fake dep barrier        compare
10325    .    ld 12,xxx(2)            ld 12,xxx(2)
10326    .    mtctr 12                mtctr 12
10327    .    xor 11,12,12            ld 2,xxx+8(2)
10328    .    add 2,2,11              cmpldi 2,0
10329    .    ld 2,xxx+8(2)           bnectr+
10330    .    bctr                    b <glink_entry>
10331
10332    The solution involving the compare turns out to be faster, so
10333    that's what we use unless the branch won't reach.  */
10334
10335 #define ALWAYS_USE_FAKE_DEP 0
10336 #define ALWAYS_EMIT_R2SAVE 0
10337
10338 #define PPC_LO(v) ((v) & 0xffff)
10339 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10340 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10341
10342 static inline unsigned int
10343 plt_stub_size (struct ppc_link_hash_table *htab,
10344                struct ppc_stub_hash_entry *stub_entry,
10345                bfd_vma off)
10346 {
10347   unsigned size = 12;
10348
10349   if (ALWAYS_EMIT_R2SAVE
10350       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10351     size += 4;
10352   if (PPC_HA (off) != 0)
10353     size += 4;
10354   if (htab->opd_abi)
10355     {
10356       size += 4;
10357       if (htab->params->plt_static_chain)
10358         size += 4;
10359       if (htab->params->plt_thread_safe
10360           && htab->elf.dynamic_sections_created
10361           && stub_entry->h != NULL
10362           && stub_entry->h->elf.dynindx != -1)
10363         size += 8;
10364       if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
10365         size += 4;
10366     }
10367   if (stub_entry->h != NULL
10368       && (stub_entry->h == htab->tls_get_addr_fd
10369           || stub_entry->h == htab->tls_get_addr)
10370       && htab->params->tls_get_addr_opt)
10371     size += 13 * 4;
10372   return size;
10373 }
10374
10375 /* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
10376    then return the padding needed to do so.  */
10377 static inline unsigned int
10378 plt_stub_pad (struct ppc_link_hash_table *htab,
10379               struct ppc_stub_hash_entry *stub_entry,
10380               bfd_vma plt_off)
10381 {
10382   int stub_align = 1 << htab->params->plt_stub_align;
10383   unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10384   bfd_vma stub_off = stub_entry->group->stub_sec->size;
10385
10386   if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10387       > ((stub_size - 1) & -stub_align))
10388     return stub_align - (stub_off & (stub_align - 1));
10389   return 0;
10390 }
10391
10392 /* Build a .plt call stub.  */
10393
10394 static inline bfd_byte *
10395 build_plt_stub (struct ppc_link_hash_table *htab,
10396                 struct ppc_stub_hash_entry *stub_entry,
10397                 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10398 {
10399   bfd *obfd = htab->params->stub_bfd;
10400   bfd_boolean plt_load_toc = htab->opd_abi;
10401   bfd_boolean plt_static_chain = htab->params->plt_static_chain;
10402   bfd_boolean plt_thread_safe = (htab->params->plt_thread_safe
10403                                  && htab->elf.dynamic_sections_created
10404                                  && stub_entry->h != NULL
10405                                  && stub_entry->h->elf.dynindx != -1);
10406   bfd_boolean use_fake_dep = plt_thread_safe;
10407   bfd_vma cmp_branch_off = 0;
10408
10409   if (!ALWAYS_USE_FAKE_DEP
10410       && plt_load_toc
10411       && plt_thread_safe
10412       && !((stub_entry->h == htab->tls_get_addr_fd
10413             || stub_entry->h == htab->tls_get_addr)
10414            && htab->params->tls_get_addr_opt))
10415     {
10416       bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10417       bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10418                           / PLT_ENTRY_SIZE (htab));
10419       bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10420       bfd_vma to, from;
10421
10422       if (pltindex > 32768)
10423         glinkoff += (pltindex - 32768) * 4;
10424       to = (glinkoff
10425             + htab->glink->output_offset
10426             + htab->glink->output_section->vma);
10427       from = (p - stub_entry->group->stub_sec->contents
10428               + 4 * (ALWAYS_EMIT_R2SAVE
10429                      || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10430               + 4 * (PPC_HA (offset) != 0)
10431               + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10432                      != PPC_HA (offset))
10433               + 4 * (plt_static_chain != 0)
10434               + 20
10435               + stub_entry->group->stub_sec->output_offset
10436               + stub_entry->group->stub_sec->output_section->vma);
10437       cmp_branch_off = to - from;
10438       use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10439     }
10440
10441   if (PPC_HA (offset) != 0)
10442     {
10443       if (r != NULL)
10444         {
10445           if (ALWAYS_EMIT_R2SAVE
10446               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10447             r[0].r_offset += 4;
10448           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10449           r[1].r_offset = r[0].r_offset + 4;
10450           r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10451           r[1].r_addend = r[0].r_addend;
10452           if (plt_load_toc)
10453             {
10454               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10455                 {
10456                   r[2].r_offset = r[1].r_offset + 4;
10457                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10458                   r[2].r_addend = r[0].r_addend;
10459                 }
10460               else
10461                 {
10462                   r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10463                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10464                   r[2].r_addend = r[0].r_addend + 8;
10465                   if (plt_static_chain)
10466                     {
10467                       r[3].r_offset = r[2].r_offset + 4;
10468                       r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10469                       r[3].r_addend = r[0].r_addend + 16;
10470                     }
10471                 }
10472             }
10473         }
10474       if (ALWAYS_EMIT_R2SAVE
10475           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10476         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10477       if (plt_load_toc)
10478         {
10479           bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10480           bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p),  p += 4;
10481         }
10482       else
10483         {
10484           bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
10485           bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p),  p += 4;
10486         }
10487       if (plt_load_toc
10488           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10489         {
10490           bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10491           offset = 0;
10492         }
10493       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10494       if (plt_load_toc)
10495         {
10496           if (use_fake_dep)
10497             {
10498               bfd_put_32 (obfd, XOR_R2_R12_R12, p),             p += 4;
10499               bfd_put_32 (obfd, ADD_R11_R11_R2, p),             p += 4;
10500             }
10501           bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10502           if (plt_static_chain)
10503             bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10504         }
10505     }
10506   else
10507     {
10508       if (r != NULL)
10509         {
10510           if (ALWAYS_EMIT_R2SAVE
10511               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10512             r[0].r_offset += 4;
10513           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10514           if (plt_load_toc)
10515             {
10516               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10517                 {
10518                   r[1].r_offset = r[0].r_offset + 4;
10519                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10520                   r[1].r_addend = r[0].r_addend;
10521                 }
10522               else
10523                 {
10524                   r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10525                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10526                   r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10527                   if (plt_static_chain)
10528                     {
10529                       r[2].r_offset = r[1].r_offset + 4;
10530                       r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10531                       r[2].r_addend = r[0].r_addend + 8;
10532                     }
10533                 }
10534             }
10535         }
10536       if (ALWAYS_EMIT_R2SAVE
10537           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10538         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10539       bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p),       p += 4;
10540       if (plt_load_toc
10541           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10542         {
10543           bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),   p += 4;
10544           offset = 0;
10545         }
10546       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10547       if (plt_load_toc)
10548         {
10549           if (use_fake_dep)
10550             {
10551               bfd_put_32 (obfd, XOR_R11_R12_R12, p),            p += 4;
10552               bfd_put_32 (obfd, ADD_R2_R2_R11, p),              p += 4;
10553             }
10554           if (plt_static_chain)
10555             bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10556           bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10557         }
10558     }
10559   if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10560     {
10561       bfd_put_32 (obfd, CMPLDI_R2_0, p),                        p += 4;
10562       bfd_put_32 (obfd, BNECTR_P4, p),                          p += 4;
10563       bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10564     }
10565   else
10566     bfd_put_32 (obfd, BCTR, p),                                 p += 4;
10567   return p;
10568 }
10569
10570 /* Build a special .plt call stub for __tls_get_addr.  */
10571
10572 #define LD_R11_0R3      0xe9630000
10573 #define LD_R12_0R3      0xe9830000
10574 #define MR_R0_R3        0x7c601b78
10575 #define CMPDI_R11_0     0x2c2b0000
10576 #define ADD_R3_R12_R13  0x7c6c6a14
10577 #define BEQLR           0x4d820020
10578 #define MR_R3_R0        0x7c030378
10579 #define STD_R11_0R1     0xf9610000
10580 #define BCTRL           0x4e800421
10581 #define LD_R11_0R1      0xe9610000
10582 #define MTLR_R11        0x7d6803a6
10583
10584 static inline bfd_byte *
10585 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10586                          struct ppc_stub_hash_entry *stub_entry,
10587                          bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10588 {
10589   bfd *obfd = htab->params->stub_bfd;
10590
10591   bfd_put_32 (obfd, LD_R11_0R3 + 0, p),         p += 4;
10592   bfd_put_32 (obfd, LD_R12_0R3 + 8, p),         p += 4;
10593   bfd_put_32 (obfd, MR_R0_R3, p),               p += 4;
10594   bfd_put_32 (obfd, CMPDI_R11_0, p),            p += 4;
10595   bfd_put_32 (obfd, ADD_R3_R12_R13, p),         p += 4;
10596   bfd_put_32 (obfd, BEQLR, p),                  p += 4;
10597   bfd_put_32 (obfd, MR_R3_R0, p),               p += 4;
10598   bfd_put_32 (obfd, MFLR_R11, p),               p += 4;
10599   bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10600
10601   if (r != NULL)
10602     r[0].r_offset += 9 * 4;
10603   p = build_plt_stub (htab, stub_entry, p, offset, r);
10604   bfd_put_32 (obfd, BCTRL, p - 4);
10605
10606   bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p),     p += 4;
10607   bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10608   bfd_put_32 (obfd, MTLR_R11, p),               p += 4;
10609   bfd_put_32 (obfd, BLR, p),                    p += 4;
10610
10611   return p;
10612 }
10613
10614 static Elf_Internal_Rela *
10615 get_relocs (asection *sec, int count)
10616 {
10617   Elf_Internal_Rela *relocs;
10618   struct bfd_elf_section_data *elfsec_data;
10619
10620   elfsec_data = elf_section_data (sec);
10621   relocs = elfsec_data->relocs;
10622   if (relocs == NULL)
10623     {
10624       bfd_size_type relsize;
10625       relsize = sec->reloc_count * sizeof (*relocs);
10626       relocs = bfd_alloc (sec->owner, relsize);
10627       if (relocs == NULL)
10628         return NULL;
10629       elfsec_data->relocs = relocs;
10630       elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10631                                           sizeof (Elf_Internal_Shdr));
10632       if (elfsec_data->rela.hdr == NULL)
10633         return NULL;
10634       elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10635                                         * sizeof (Elf64_External_Rela));
10636       elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10637       sec->reloc_count = 0;
10638     }
10639   relocs += sec->reloc_count;
10640   sec->reloc_count += count;
10641   return relocs;
10642 }
10643
10644 static bfd_vma
10645 get_r2off (struct bfd_link_info *info,
10646            struct ppc_stub_hash_entry *stub_entry)
10647 {
10648   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10649   bfd_vma r2off = htab->sec_info[stub_entry->target_section->id].toc_off;
10650
10651   if (r2off == 0)
10652     {
10653       /* Support linking -R objects.  Get the toc pointer from the
10654          opd entry.  */
10655       char buf[8];
10656       if (!htab->opd_abi)
10657         return r2off;
10658       asection *opd = stub_entry->h->elf.root.u.def.section;
10659       bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10660
10661       if (strcmp (opd->name, ".opd") != 0
10662           || opd->reloc_count != 0)
10663         {
10664           info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
10665                                   stub_entry->h->elf.root.root.string);
10666           bfd_set_error (bfd_error_bad_value);
10667           return (bfd_vma) -1;
10668         }
10669       if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10670         return (bfd_vma) -1;
10671       r2off = bfd_get_64 (opd->owner, buf);
10672       r2off -= elf_gp (info->output_bfd);
10673     }
10674   r2off -= htab->sec_info[stub_entry->group->link_sec->id].toc_off;
10675   return r2off;
10676 }
10677
10678 static bfd_boolean
10679 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10680 {
10681   struct ppc_stub_hash_entry *stub_entry;
10682   struct ppc_branch_hash_entry *br_entry;
10683   struct bfd_link_info *info;
10684   struct ppc_link_hash_table *htab;
10685   bfd_byte *loc;
10686   bfd_byte *p;
10687   bfd_vma dest, off;
10688   int size;
10689   Elf_Internal_Rela *r;
10690   asection *plt;
10691
10692   /* Massage our args to the form they really have.  */
10693   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10694   info = in_arg;
10695
10696   htab = ppc_hash_table (info);
10697   if (htab == NULL)
10698     return FALSE;
10699
10700   /* Make a note of the offset within the stubs for this entry.  */
10701   stub_entry->stub_offset = stub_entry->group->stub_sec->size;
10702   loc = stub_entry->group->stub_sec->contents + stub_entry->stub_offset;
10703
10704   htab->stub_count[stub_entry->stub_type - 1] += 1;
10705   switch (stub_entry->stub_type)
10706     {
10707     case ppc_stub_long_branch:
10708     case ppc_stub_long_branch_r2off:
10709       /* Branches are relative.  This is where we are going to.  */
10710       dest = (stub_entry->target_value
10711               + stub_entry->target_section->output_offset
10712               + stub_entry->target_section->output_section->vma);
10713       dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10714       off = dest;
10715
10716       /* And this is where we are coming from.  */
10717       off -= (stub_entry->stub_offset
10718               + stub_entry->group->stub_sec->output_offset
10719               + stub_entry->group->stub_sec->output_section->vma);
10720
10721       size = 4;
10722       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10723         {
10724           bfd_vma r2off = get_r2off (info, stub_entry);
10725
10726           if (r2off == (bfd_vma) -1)
10727             {
10728               htab->stub_error = TRUE;
10729               return FALSE;
10730             }
10731           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10732           loc += 4;
10733           size = 8;
10734           if (PPC_HA (r2off) != 0)
10735             {
10736               bfd_put_32 (htab->params->stub_bfd,
10737                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
10738               loc += 4;
10739               size += 4;
10740             }
10741           if (PPC_LO (r2off) != 0)
10742             {
10743               bfd_put_32 (htab->params->stub_bfd,
10744                           ADDI_R2_R2 | PPC_LO (r2off), loc);
10745               loc += 4;
10746               size += 4;
10747             }
10748           off -= size - 4;
10749         }
10750       bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10751
10752       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10753         {
10754           info->callbacks->einfo
10755             (_("%P: long branch stub `%s' offset overflow\n"),
10756              stub_entry->root.string);
10757           htab->stub_error = TRUE;
10758           return FALSE;
10759         }
10760
10761       if (info->emitrelocations)
10762         {
10763           r = get_relocs (stub_entry->group->stub_sec, 1);
10764           if (r == NULL)
10765             return FALSE;
10766           r->r_offset = loc - stub_entry->group->stub_sec->contents;
10767           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10768           r->r_addend = dest;
10769           if (stub_entry->h != NULL)
10770             {
10771               struct elf_link_hash_entry **hashes;
10772               unsigned long symndx;
10773               struct ppc_link_hash_entry *h;
10774
10775               hashes = elf_sym_hashes (htab->params->stub_bfd);
10776               if (hashes == NULL)
10777                 {
10778                   bfd_size_type hsize;
10779
10780                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10781                   hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
10782                   if (hashes == NULL)
10783                     return FALSE;
10784                   elf_sym_hashes (htab->params->stub_bfd) = hashes;
10785                   htab->stub_globals = 1;
10786                 }
10787               symndx = htab->stub_globals++;
10788               h = stub_entry->h;
10789               hashes[symndx] = &h->elf;
10790               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10791               if (h->oh != NULL && h->oh->is_func)
10792                 h = ppc_follow_link (h->oh);
10793               if (h->elf.root.u.def.section != stub_entry->target_section)
10794                 /* H is an opd symbol.  The addend must be zero.  */
10795                 r->r_addend = 0;
10796               else
10797                 {
10798                   off = (h->elf.root.u.def.value
10799                          + h->elf.root.u.def.section->output_offset
10800                          + h->elf.root.u.def.section->output_section->vma);
10801                   r->r_addend -= off;
10802                 }
10803             }
10804         }
10805       break;
10806
10807     case ppc_stub_plt_branch:
10808     case ppc_stub_plt_branch_r2off:
10809       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10810                                          stub_entry->root.string + 9,
10811                                          FALSE, FALSE);
10812       if (br_entry == NULL)
10813         {
10814           info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
10815                                   stub_entry->root.string);
10816           htab->stub_error = TRUE;
10817           return FALSE;
10818         }
10819
10820       dest = (stub_entry->target_value
10821               + stub_entry->target_section->output_offset
10822               + stub_entry->target_section->output_section->vma);
10823       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10824         dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10825
10826       bfd_put_64 (htab->brlt->owner, dest,
10827                   htab->brlt->contents + br_entry->offset);
10828
10829       if (br_entry->iter == htab->stub_iteration)
10830         {
10831           br_entry->iter = 0;
10832
10833           if (htab->relbrlt != NULL)
10834             {
10835               /* Create a reloc for the branch lookup table entry.  */
10836               Elf_Internal_Rela rela;
10837               bfd_byte *rl;
10838
10839               rela.r_offset = (br_entry->offset
10840                                + htab->brlt->output_offset
10841                                + htab->brlt->output_section->vma);
10842               rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10843               rela.r_addend = dest;
10844
10845               rl = htab->relbrlt->contents;
10846               rl += (htab->relbrlt->reloc_count++
10847                      * sizeof (Elf64_External_Rela));
10848               bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
10849             }
10850           else if (info->emitrelocations)
10851             {
10852               r = get_relocs (htab->brlt, 1);
10853               if (r == NULL)
10854                 return FALSE;
10855               /* brlt, being SEC_LINKER_CREATED does not go through the
10856                  normal reloc processing.  Symbols and offsets are not
10857                  translated from input file to output file form, so
10858                  set up the offset per the output file.  */
10859               r->r_offset = (br_entry->offset
10860                              + htab->brlt->output_offset
10861                              + htab->brlt->output_section->vma);
10862               r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10863               r->r_addend = dest;
10864             }
10865         }
10866
10867       dest = (br_entry->offset
10868               + htab->brlt->output_offset
10869               + htab->brlt->output_section->vma);
10870
10871       off = (dest
10872              - elf_gp (htab->brlt->output_section->owner)
10873              - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
10874
10875       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10876         {
10877           info->callbacks->einfo
10878             (_("%P: linkage table error against `%T'\n"),
10879              stub_entry->root.string);
10880           bfd_set_error (bfd_error_bad_value);
10881           htab->stub_error = TRUE;
10882           return FALSE;
10883         }
10884
10885       if (info->emitrelocations)
10886         {
10887           r = get_relocs (stub_entry->group->stub_sec, 1 + (PPC_HA (off) != 0));
10888           if (r == NULL)
10889             return FALSE;
10890           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
10891           if (bfd_big_endian (info->output_bfd))
10892             r[0].r_offset += 2;
10893           if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
10894             r[0].r_offset += 4;
10895           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10896           r[0].r_addend = dest;
10897           if (PPC_HA (off) != 0)
10898             {
10899               r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10900               r[1].r_offset = r[0].r_offset + 4;
10901               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10902               r[1].r_addend = r[0].r_addend;
10903             }
10904         }
10905
10906       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10907         {
10908           if (PPC_HA (off) != 0)
10909             {
10910               size = 16;
10911               bfd_put_32 (htab->params->stub_bfd,
10912                           ADDIS_R12_R2 | PPC_HA (off), loc);
10913               loc += 4;
10914               bfd_put_32 (htab->params->stub_bfd,
10915                           LD_R12_0R12 | PPC_LO (off), loc);
10916             }
10917           else
10918             {
10919               size = 12;
10920               bfd_put_32 (htab->params->stub_bfd,
10921                           LD_R12_0R2 | PPC_LO (off), loc);
10922             }
10923         }
10924       else
10925         {
10926           bfd_vma r2off = get_r2off (info, stub_entry);
10927
10928           if (r2off == (bfd_vma) -1)
10929             {
10930               htab->stub_error = TRUE;
10931               return FALSE;
10932             }
10933
10934           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10935           loc += 4;
10936           size = 16;
10937           if (PPC_HA (off) != 0)
10938             {
10939               size += 4;
10940               bfd_put_32 (htab->params->stub_bfd,
10941                           ADDIS_R12_R2 | PPC_HA (off), loc);
10942               loc += 4;
10943               bfd_put_32 (htab->params->stub_bfd,
10944                           LD_R12_0R12 | PPC_LO (off), loc);
10945             }
10946           else
10947             bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
10948
10949           if (PPC_HA (r2off) != 0)
10950             {
10951               size += 4;
10952               loc += 4;
10953               bfd_put_32 (htab->params->stub_bfd,
10954                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
10955             }
10956           if (PPC_LO (r2off) != 0)
10957             {
10958               size += 4;
10959               loc += 4;
10960               bfd_put_32 (htab->params->stub_bfd,
10961                           ADDI_R2_R2 | PPC_LO (r2off), loc);
10962             }
10963         }
10964       loc += 4;
10965       bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, loc);
10966       loc += 4;
10967       bfd_put_32 (htab->params->stub_bfd, BCTR, loc);
10968       break;
10969
10970     case ppc_stub_plt_call:
10971     case ppc_stub_plt_call_r2save:
10972       if (stub_entry->h != NULL
10973           && stub_entry->h->is_func_descriptor
10974           && stub_entry->h->oh != NULL)
10975         {
10976           struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
10977
10978           /* If the old-ABI "dot-symbol" is undefined make it weak so
10979              we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.  */
10980           if (fh->elf.root.type == bfd_link_hash_undefined)
10981             fh->elf.root.type = bfd_link_hash_undefweak;
10982           /* Stop undo_symbol_twiddle changing it back to undefined.  */
10983           fh->was_undefined = 0;
10984         }
10985
10986       /* Now build the stub.  */
10987       dest = stub_entry->plt_ent->plt.offset & ~1;
10988       if (dest >= (bfd_vma) -2)
10989         abort ();
10990
10991       plt = htab->elf.splt;
10992       if (!htab->elf.dynamic_sections_created
10993           || stub_entry->h == NULL
10994           || stub_entry->h->elf.dynindx == -1)
10995         plt = htab->elf.iplt;
10996
10997       dest += plt->output_offset + plt->output_section->vma;
10998
10999       if (stub_entry->h == NULL
11000           && (stub_entry->plt_ent->plt.offset & 1) == 0)
11001         {
11002           Elf_Internal_Rela rela;
11003           bfd_byte *rl;
11004
11005           rela.r_offset = dest;
11006           if (htab->opd_abi)
11007             rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
11008           else
11009             rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
11010           rela.r_addend = (stub_entry->target_value
11011                            + stub_entry->target_section->output_offset
11012                            + stub_entry->target_section->output_section->vma);
11013
11014           rl = (htab->elf.irelplt->contents
11015                 + (htab->elf.irelplt->reloc_count++
11016                    * sizeof (Elf64_External_Rela)));
11017           bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
11018           stub_entry->plt_ent->plt.offset |= 1;
11019         }
11020
11021       off = (dest
11022              - elf_gp (plt->output_section->owner)
11023              - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11024
11025       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11026         {
11027           info->callbacks->einfo
11028             (_("%P: linkage table error against `%T'\n"),
11029              stub_entry->h != NULL
11030              ? stub_entry->h->elf.root.root.string
11031              : "<local sym>");
11032           bfd_set_error (bfd_error_bad_value);
11033           htab->stub_error = TRUE;
11034           return FALSE;
11035         }
11036
11037       if (htab->params->plt_stub_align != 0)
11038         {
11039           unsigned pad = plt_stub_pad (htab, stub_entry, off);
11040
11041           stub_entry->group->stub_sec->size += pad;
11042           stub_entry->stub_offset = stub_entry->group->stub_sec->size;
11043           loc += pad;
11044         }
11045
11046       r = NULL;
11047       if (info->emitrelocations)
11048         {
11049           r = get_relocs (stub_entry->group->stub_sec,
11050                           ((PPC_HA (off) != 0)
11051                            + (htab->opd_abi
11052                               ? 2 + (htab->params->plt_static_chain
11053                                      && PPC_HA (off + 16) == PPC_HA (off))
11054                               : 1)));
11055           if (r == NULL)
11056             return FALSE;
11057           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11058           if (bfd_big_endian (info->output_bfd))
11059             r[0].r_offset += 2;
11060           r[0].r_addend = dest;
11061         }
11062       if (stub_entry->h != NULL
11063           && (stub_entry->h == htab->tls_get_addr_fd
11064               || stub_entry->h == htab->tls_get_addr)
11065           && htab->params->tls_get_addr_opt)
11066         p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
11067       else
11068         p = build_plt_stub (htab, stub_entry, loc, off, r);
11069       size = p - loc;
11070       break;
11071
11072     case ppc_stub_save_res:
11073       return TRUE;
11074
11075     default:
11076       BFD_FAIL ();
11077       return FALSE;
11078     }
11079
11080   stub_entry->group->stub_sec->size += size;
11081
11082   if (htab->params->emit_stub_syms)
11083     {
11084       struct elf_link_hash_entry *h;
11085       size_t len1, len2;
11086       char *name;
11087       const char *const stub_str[] = { "long_branch",
11088                                        "long_branch_r2off",
11089                                        "plt_branch",
11090                                        "plt_branch_r2off",
11091                                        "plt_call",
11092                                        "plt_call" };
11093
11094       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
11095       len2 = strlen (stub_entry->root.string);
11096       name = bfd_malloc (len1 + len2 + 2);
11097       if (name == NULL)
11098         return FALSE;
11099       memcpy (name, stub_entry->root.string, 9);
11100       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
11101       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
11102       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
11103       if (h == NULL)
11104         return FALSE;
11105       if (h->root.type == bfd_link_hash_new)
11106         {
11107           h->root.type = bfd_link_hash_defined;
11108           h->root.u.def.section = stub_entry->group->stub_sec;
11109           h->root.u.def.value = stub_entry->stub_offset;
11110           h->ref_regular = 1;
11111           h->def_regular = 1;
11112           h->ref_regular_nonweak = 1;
11113           h->forced_local = 1;
11114           h->non_elf = 0;
11115           h->root.linker_def = 1;
11116         }
11117     }
11118
11119   return TRUE;
11120 }
11121
11122 /* As above, but don't actually build the stub.  Just bump offset so
11123    we know stub section sizes, and select plt_branch stubs where
11124    long_branch stubs won't do.  */
11125
11126 static bfd_boolean
11127 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11128 {
11129   struct ppc_stub_hash_entry *stub_entry;
11130   struct bfd_link_info *info;
11131   struct ppc_link_hash_table *htab;
11132   bfd_vma off;
11133   int size;
11134
11135   /* Massage our args to the form they really have.  */
11136   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11137   info = in_arg;
11138
11139   htab = ppc_hash_table (info);
11140   if (htab == NULL)
11141     return FALSE;
11142
11143   if (stub_entry->h != NULL
11144       && stub_entry->h->save_res
11145       && stub_entry->h->elf.root.type == bfd_link_hash_defined
11146       && stub_entry->h->elf.root.u.def.section == htab->sfpr)
11147     {
11148       /* Don't make stubs to out-of-line register save/restore
11149          functions.  Instead, emit copies of the functions.  */
11150       stub_entry->group->needs_save_res = 1;
11151       stub_entry->stub_type = ppc_stub_save_res;
11152       return TRUE;
11153     }
11154
11155   if (stub_entry->stub_type == ppc_stub_plt_call
11156       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11157     {
11158       asection *plt;
11159       off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
11160       if (off >= (bfd_vma) -2)
11161         abort ();
11162       plt = htab->elf.splt;
11163       if (!htab->elf.dynamic_sections_created
11164           || stub_entry->h == NULL
11165           || stub_entry->h->elf.dynindx == -1)
11166         plt = htab->elf.iplt;
11167       off += (plt->output_offset
11168               + plt->output_section->vma
11169               - elf_gp (plt->output_section->owner)
11170               - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11171
11172       size = plt_stub_size (htab, stub_entry, off);
11173       if (htab->params->plt_stub_align)
11174         size += plt_stub_pad (htab, stub_entry, off);
11175       if (info->emitrelocations)
11176         {
11177           stub_entry->group->stub_sec->reloc_count
11178             += ((PPC_HA (off) != 0)
11179                 + (htab->opd_abi
11180                    ? 2 + (htab->params->plt_static_chain
11181                           && PPC_HA (off + 16) == PPC_HA (off))
11182                    : 1));
11183           stub_entry->group->stub_sec->flags |= SEC_RELOC;
11184         }
11185     }
11186   else
11187     {
11188       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
11189          variants.  */
11190       bfd_vma r2off = 0;
11191       bfd_vma local_off = 0;
11192
11193       off = (stub_entry->target_value
11194              + stub_entry->target_section->output_offset
11195              + stub_entry->target_section->output_section->vma);
11196       off -= (stub_entry->group->stub_sec->size
11197               + stub_entry->group->stub_sec->output_offset
11198               + stub_entry->group->stub_sec->output_section->vma);
11199
11200       /* Reset the stub type from the plt variant in case we now
11201          can reach with a shorter stub.  */
11202       if (stub_entry->stub_type >= ppc_stub_plt_branch)
11203         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
11204
11205       size = 4;
11206       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11207         {
11208           r2off = get_r2off (info, stub_entry);
11209           if (r2off == (bfd_vma) -1)
11210             {
11211               htab->stub_error = TRUE;
11212               return FALSE;
11213             }
11214           size = 8;
11215           if (PPC_HA (r2off) != 0)
11216             size += 4;
11217           if (PPC_LO (r2off) != 0)
11218             size += 4;
11219           off -= size - 4;
11220         }
11221
11222       local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11223
11224       /* If the branch offset if too big, use a ppc_stub_plt_branch.
11225          Do the same for -R objects without function descriptors.  */
11226       if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
11227           || (stub_entry->stub_type == ppc_stub_long_branch_r2off
11228               && r2off == 0
11229               && htab->sec_info[stub_entry->target_section->id].toc_off == 0))
11230         {
11231           struct ppc_branch_hash_entry *br_entry;
11232
11233           br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11234                                              stub_entry->root.string + 9,
11235                                              TRUE, FALSE);
11236           if (br_entry == NULL)
11237             {
11238               info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
11239                                       stub_entry->root.string);
11240               htab->stub_error = TRUE;
11241               return FALSE;
11242             }
11243
11244           if (br_entry->iter != htab->stub_iteration)
11245             {
11246               br_entry->iter = htab->stub_iteration;
11247               br_entry->offset = htab->brlt->size;
11248               htab->brlt->size += 8;
11249
11250               if (htab->relbrlt != NULL)
11251                 htab->relbrlt->size += sizeof (Elf64_External_Rela);
11252               else if (info->emitrelocations)
11253                 {
11254                   htab->brlt->reloc_count += 1;
11255                   htab->brlt->flags |= SEC_RELOC;
11256                 }
11257             }
11258
11259           stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
11260           off = (br_entry->offset
11261                  + htab->brlt->output_offset
11262                  + htab->brlt->output_section->vma
11263                  - elf_gp (htab->brlt->output_section->owner)
11264                  - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11265
11266           if (info->emitrelocations)
11267             {
11268               stub_entry->group->stub_sec->reloc_count
11269                 += 1 + (PPC_HA (off) != 0);
11270               stub_entry->group->stub_sec->flags |= SEC_RELOC;
11271             }
11272
11273           if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11274             {
11275               size = 12;
11276               if (PPC_HA (off) != 0)
11277                 size = 16;
11278             }
11279           else
11280             {
11281               size = 16;
11282               if (PPC_HA (off) != 0)
11283                 size += 4;
11284
11285               if (PPC_HA (r2off) != 0)
11286                 size += 4;
11287               if (PPC_LO (r2off) != 0)
11288                 size += 4;
11289             }
11290         }
11291       else if (info->emitrelocations)
11292         {
11293           stub_entry->group->stub_sec->reloc_count += 1;
11294           stub_entry->group->stub_sec->flags |= SEC_RELOC;
11295         }
11296     }
11297
11298   stub_entry->group->stub_sec->size += size;
11299   return TRUE;
11300 }
11301
11302 /* Set up various things so that we can make a list of input sections
11303    for each output section included in the link.  Returns -1 on error,
11304    0 when no stubs will be needed, and 1 on success.  */
11305
11306 int
11307 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
11308 {
11309   unsigned int id;
11310   bfd_size_type amt;
11311   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11312
11313   if (htab == NULL)
11314     return -1;
11315
11316   htab->sec_info_arr_size = bfd_get_next_section_id ();
11317   amt = sizeof (*htab->sec_info) * (htab->sec_info_arr_size);
11318   htab->sec_info = bfd_zmalloc (amt);
11319   if (htab->sec_info == NULL)
11320     return -1;
11321
11322   /* Set toc_off for com, und, abs and ind sections.  */
11323   for (id = 0; id < 3; id++)
11324     htab->sec_info[id].toc_off = TOC_BASE_OFF;
11325
11326   return 1;
11327 }
11328
11329 /* Set up for first pass at multitoc partitioning.  */
11330
11331 void
11332 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11333 {
11334   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11335
11336   htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11337   htab->toc_bfd = NULL;
11338   htab->toc_first_sec = NULL;
11339 }
11340
11341 /* The linker repeatedly calls this function for each TOC input section
11342    and linker generated GOT section.  Group input bfds such that the toc
11343    within a group is less than 64k in size.  */
11344
11345 bfd_boolean
11346 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11347 {
11348   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11349   bfd_vma addr, off, limit;
11350
11351   if (htab == NULL)
11352     return FALSE;
11353
11354   if (!htab->second_toc_pass)
11355     {
11356       /* Keep track of the first .toc or .got section for this input bfd.  */
11357       bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11358
11359       if (new_bfd)
11360         {
11361           htab->toc_bfd = isec->owner;
11362           htab->toc_first_sec = isec;
11363         }
11364
11365       addr = isec->output_offset + isec->output_section->vma;
11366       off = addr - htab->toc_curr;
11367       limit = 0x80008000;
11368       if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11369         limit = 0x10000;
11370       if (off + isec->size > limit)
11371         {
11372           addr = (htab->toc_first_sec->output_offset
11373                   + htab->toc_first_sec->output_section->vma);
11374           htab->toc_curr = addr;
11375           htab->toc_curr &= -TOC_BASE_ALIGN;
11376         }
11377
11378       /* toc_curr is the base address of this toc group.  Set elf_gp
11379          for the input section to be the offset relative to the
11380          output toc base plus 0x8000.  Making the input elf_gp an
11381          offset allows us to move the toc as a whole without
11382          recalculating input elf_gp.  */
11383       off = htab->toc_curr - elf_gp (isec->output_section->owner);
11384       off += TOC_BASE_OFF;
11385
11386       /* Die if someone uses a linker script that doesn't keep input
11387          file .toc and .got together.  */
11388       if (new_bfd
11389           && elf_gp (isec->owner) != 0
11390           && elf_gp (isec->owner) != off)
11391         return FALSE;
11392
11393       elf_gp (isec->owner) = off;
11394       return TRUE;
11395     }
11396
11397   /* During the second pass toc_first_sec points to the start of
11398      a toc group, and toc_curr is used to track the old elf_gp.
11399      We use toc_bfd to ensure we only look at each bfd once.  */
11400   if (htab->toc_bfd == isec->owner)
11401     return TRUE;
11402   htab->toc_bfd = isec->owner;
11403
11404   if (htab->toc_first_sec == NULL
11405       || htab->toc_curr != elf_gp (isec->owner))
11406     {
11407       htab->toc_curr = elf_gp (isec->owner);
11408       htab->toc_first_sec = isec;
11409     }
11410   addr = (htab->toc_first_sec->output_offset
11411           + htab->toc_first_sec->output_section->vma);
11412   off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
11413   elf_gp (isec->owner) = off;
11414
11415   return TRUE;
11416 }
11417
11418 /* Called via elf_link_hash_traverse to merge GOT entries for global
11419    symbol H.  */
11420
11421 static bfd_boolean
11422 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11423 {
11424   if (h->root.type == bfd_link_hash_indirect)
11425     return TRUE;
11426
11427   merge_got_entries (&h->got.glist);
11428
11429   return TRUE;
11430 }
11431
11432 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11433    symbol H.  */
11434
11435 static bfd_boolean
11436 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11437 {
11438   struct got_entry *gent;
11439
11440   if (h->root.type == bfd_link_hash_indirect)
11441     return TRUE;
11442
11443   for (gent = h->got.glist; gent != NULL; gent = gent->next)
11444     if (!gent->is_indirect)
11445       allocate_got (h, (struct bfd_link_info *) inf, gent);
11446   return TRUE;
11447 }
11448
11449 /* Called on the first multitoc pass after the last call to
11450    ppc64_elf_next_toc_section.  This function removes duplicate GOT
11451    entries.  */
11452
11453 bfd_boolean
11454 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11455 {
11456   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11457   struct bfd *ibfd, *ibfd2;
11458   bfd_boolean done_something;
11459
11460   htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11461
11462   if (!htab->do_multi_toc)
11463     return FALSE;
11464
11465   /* Merge global sym got entries within a toc group.  */
11466   elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11467
11468   /* And tlsld_got.  */
11469   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11470     {
11471       struct got_entry *ent, *ent2;
11472
11473       if (!is_ppc64_elf (ibfd))
11474         continue;
11475
11476       ent = ppc64_tlsld_got (ibfd);
11477       if (!ent->is_indirect
11478           && ent->got.offset != (bfd_vma) -1)
11479         {
11480           for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
11481             {
11482               if (!is_ppc64_elf (ibfd2))
11483                 continue;
11484
11485               ent2 = ppc64_tlsld_got (ibfd2);
11486               if (!ent2->is_indirect
11487                   && ent2->got.offset != (bfd_vma) -1
11488                   && elf_gp (ibfd2) == elf_gp (ibfd))
11489                 {
11490                   ent2->is_indirect = TRUE;
11491                   ent2->got.ent = ent;
11492                 }
11493             }
11494         }
11495     }
11496
11497   /* Zap sizes of got sections.  */
11498   htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11499   htab->elf.irelplt->size -= htab->got_reli_size;
11500   htab->got_reli_size = 0;
11501
11502   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11503     {
11504       asection *got, *relgot;
11505
11506       if (!is_ppc64_elf (ibfd))
11507         continue;
11508
11509       got = ppc64_elf_tdata (ibfd)->got;
11510       if (got != NULL)
11511         {
11512           got->rawsize = got->size;
11513           got->size = 0;
11514           relgot = ppc64_elf_tdata (ibfd)->relgot;
11515           relgot->rawsize = relgot->size;
11516           relgot->size = 0;
11517         }
11518     }
11519
11520   /* Now reallocate the got, local syms first.  We don't need to
11521      allocate section contents again since we never increase size.  */
11522   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11523     {
11524       struct got_entry **lgot_ents;
11525       struct got_entry **end_lgot_ents;
11526       struct plt_entry **local_plt;
11527       struct plt_entry **end_local_plt;
11528       unsigned char *lgot_masks;
11529       bfd_size_type locsymcount;
11530       Elf_Internal_Shdr *symtab_hdr;
11531       asection *s;
11532
11533       if (!is_ppc64_elf (ibfd))
11534         continue;
11535
11536       lgot_ents = elf_local_got_ents (ibfd);
11537       if (!lgot_ents)
11538         continue;
11539
11540       symtab_hdr = &elf_symtab_hdr (ibfd);
11541       locsymcount = symtab_hdr->sh_info;
11542       end_lgot_ents = lgot_ents + locsymcount;
11543       local_plt = (struct plt_entry **) end_lgot_ents;
11544       end_local_plt = local_plt + locsymcount;
11545       lgot_masks = (unsigned char *) end_local_plt;
11546       s = ppc64_elf_tdata (ibfd)->got;
11547       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11548         {
11549           struct got_entry *ent;
11550
11551           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11552             {
11553               unsigned int ent_size = 8;
11554               unsigned int rel_size = sizeof (Elf64_External_Rela);
11555
11556               ent->got.offset = s->size;
11557               if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11558                 {
11559                   ent_size *= 2;
11560                   rel_size *= 2;
11561                 }
11562               s->size += ent_size;
11563               if ((*lgot_masks & PLT_IFUNC) != 0)
11564                 {
11565                   htab->elf.irelplt->size += rel_size;
11566                   htab->got_reli_size += rel_size;
11567                 }
11568               else if (bfd_link_pic (info))
11569                 {
11570                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11571                   srel->size += rel_size;
11572                 }
11573             }
11574         }
11575     }
11576
11577   elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11578
11579   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11580     {
11581       struct got_entry *ent;
11582
11583       if (!is_ppc64_elf (ibfd))
11584         continue;
11585
11586       ent = ppc64_tlsld_got (ibfd);
11587       if (!ent->is_indirect
11588           && ent->got.offset != (bfd_vma) -1)
11589         {
11590           asection *s = ppc64_elf_tdata (ibfd)->got;
11591           ent->got.offset = s->size;
11592           s->size += 16;
11593           if (bfd_link_pic (info))
11594             {
11595               asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11596               srel->size += sizeof (Elf64_External_Rela);
11597             }
11598         }
11599     }
11600
11601   done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11602   if (!done_something)
11603     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11604       {
11605         asection *got;
11606
11607         if (!is_ppc64_elf (ibfd))
11608           continue;
11609
11610         got = ppc64_elf_tdata (ibfd)->got;
11611         if (got != NULL)
11612           {
11613             done_something = got->rawsize != got->size;
11614             if (done_something)
11615               break;
11616           }
11617       }
11618
11619   if (done_something)
11620     (*htab->params->layout_sections_again) ();
11621
11622   /* Set up for second pass over toc sections to recalculate elf_gp
11623      on input sections.  */
11624   htab->toc_bfd = NULL;
11625   htab->toc_first_sec = NULL;
11626   htab->second_toc_pass = TRUE;
11627   return done_something;
11628 }
11629
11630 /* Called after second pass of multitoc partitioning.  */
11631
11632 void
11633 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11634 {
11635   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11636
11637   /* After the second pass, toc_curr tracks the TOC offset used
11638      for code sections below in ppc64_elf_next_input_section.  */
11639   htab->toc_curr = TOC_BASE_OFF;
11640 }
11641
11642 /* No toc references were found in ISEC.  If the code in ISEC makes no
11643    calls, then there's no need to use toc adjusting stubs when branching
11644    into ISEC.  Actually, indirect calls from ISEC are OK as they will
11645    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
11646    needed, and 2 if a cyclical call-graph was found but no other reason
11647    for a stub was detected.  If called from the top level, a return of
11648    2 means the same as a return of 0.  */
11649
11650 static int
11651 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11652 {
11653   int ret;
11654
11655   /* Mark this section as checked.  */
11656   isec->call_check_done = 1;
11657
11658   /* We know none of our code bearing sections will need toc stubs.  */
11659   if ((isec->flags & SEC_LINKER_CREATED) != 0)
11660     return 0;
11661
11662   if (isec->size == 0)
11663     return 0;
11664
11665   if (isec->output_section == NULL)
11666     return 0;
11667
11668   ret = 0;
11669   if (isec->reloc_count != 0)
11670     {
11671       Elf_Internal_Rela *relstart, *rel;
11672       Elf_Internal_Sym *local_syms;
11673       struct ppc_link_hash_table *htab;
11674
11675       relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11676                                             info->keep_memory);
11677       if (relstart == NULL)
11678         return -1;
11679
11680       /* Look for branches to outside of this section.  */
11681       local_syms = NULL;
11682       htab = ppc_hash_table (info);
11683       if (htab == NULL)
11684         return -1;
11685
11686       for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11687         {
11688           enum elf_ppc64_reloc_type r_type;
11689           unsigned long r_symndx;
11690           struct elf_link_hash_entry *h;
11691           struct ppc_link_hash_entry *eh;
11692           Elf_Internal_Sym *sym;
11693           asection *sym_sec;
11694           struct _opd_sec_data *opd;
11695           bfd_vma sym_value;
11696           bfd_vma dest;
11697
11698           r_type = ELF64_R_TYPE (rel->r_info);
11699           if (r_type != R_PPC64_REL24
11700               && r_type != R_PPC64_REL14
11701               && r_type != R_PPC64_REL14_BRTAKEN
11702               && r_type != R_PPC64_REL14_BRNTAKEN)
11703             continue;
11704
11705           r_symndx = ELF64_R_SYM (rel->r_info);
11706           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11707                           isec->owner))
11708             {
11709               ret = -1;
11710               break;
11711             }
11712
11713           /* Calls to dynamic lib functions go through a plt call stub
11714              that uses r2.  */
11715           eh = (struct ppc_link_hash_entry *) h;
11716           if (eh != NULL
11717               && (eh->elf.plt.plist != NULL
11718                   || (eh->oh != NULL
11719                       && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11720             {
11721               ret = 1;
11722               break;
11723             }
11724
11725           if (sym_sec == NULL)
11726             /* Ignore other undefined symbols.  */
11727             continue;
11728
11729           /* Assume branches to other sections not included in the
11730              link need stubs too, to cover -R and absolute syms.  */
11731           if (sym_sec->output_section == NULL)
11732             {
11733               ret = 1;
11734               break;
11735             }
11736
11737           if (h == NULL)
11738             sym_value = sym->st_value;
11739           else
11740             {
11741               if (h->root.type != bfd_link_hash_defined
11742                   && h->root.type != bfd_link_hash_defweak)
11743                 abort ();
11744               sym_value = h->root.u.def.value;
11745             }
11746           sym_value += rel->r_addend;
11747
11748           /* If this branch reloc uses an opd sym, find the code section.  */
11749           opd = get_opd_info (sym_sec);
11750           if (opd != NULL)
11751             {
11752               if (h == NULL && opd->adjust != NULL)
11753                 {
11754                   long adjust;
11755
11756                   adjust = opd->adjust[OPD_NDX (sym_value)];
11757                   if (adjust == -1)
11758                     /* Assume deleted functions won't ever be called.  */
11759                     continue;
11760                   sym_value += adjust;
11761                 }
11762
11763               dest = opd_entry_value (sym_sec, sym_value,
11764                                       &sym_sec, NULL, FALSE);
11765               if (dest == (bfd_vma) -1)
11766                 continue;
11767             }
11768           else
11769             dest = (sym_value
11770                     + sym_sec->output_offset
11771                     + sym_sec->output_section->vma);
11772
11773           /* Ignore branch to self.  */
11774           if (sym_sec == isec)
11775             continue;
11776
11777           /* If the called function uses the toc, we need a stub.  */
11778           if (sym_sec->has_toc_reloc
11779               || sym_sec->makes_toc_func_call)
11780             {
11781               ret = 1;
11782               break;
11783             }
11784
11785           /* Assume any branch that needs a long branch stub might in fact
11786              need a plt_branch stub.  A plt_branch stub uses r2.  */
11787           else if (dest - (isec->output_offset
11788                            + isec->output_section->vma
11789                            + rel->r_offset) + (1 << 25)
11790                    >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
11791                                                              ? h->other
11792                                                              : sym->st_other))
11793             {
11794               ret = 1;
11795               break;
11796             }
11797
11798           /* If calling back to a section in the process of being
11799              tested, we can't say for sure that no toc adjusting stubs
11800              are needed, so don't return zero.  */
11801           else if (sym_sec->call_check_in_progress)
11802             ret = 2;
11803
11804           /* Branches to another section that itself doesn't have any TOC
11805              references are OK.  Recursively call ourselves to check.  */
11806           else if (!sym_sec->call_check_done)
11807             {
11808               int recur;
11809
11810               /* Mark current section as indeterminate, so that other
11811                  sections that call back to current won't be marked as
11812                  known.  */
11813               isec->call_check_in_progress = 1;
11814               recur = toc_adjusting_stub_needed (info, sym_sec);
11815               isec->call_check_in_progress = 0;
11816
11817               if (recur != 0)
11818                 {
11819                   ret = recur;
11820                   if (recur != 2)
11821                     break;
11822                 }
11823             }
11824         }
11825
11826       if (local_syms != NULL
11827           && (elf_symtab_hdr (isec->owner).contents
11828               != (unsigned char *) local_syms))
11829         free (local_syms);
11830       if (elf_section_data (isec)->relocs != relstart)
11831         free (relstart);
11832     }
11833
11834   if ((ret & 1) == 0
11835       && isec->map_head.s != NULL
11836       && (strcmp (isec->output_section->name, ".init") == 0
11837           || strcmp (isec->output_section->name, ".fini") == 0))
11838     {
11839       if (isec->map_head.s->has_toc_reloc
11840           || isec->map_head.s->makes_toc_func_call)
11841         ret = 1;
11842       else if (!isec->map_head.s->call_check_done)
11843         {
11844           int recur;
11845           isec->call_check_in_progress = 1;
11846           recur = toc_adjusting_stub_needed (info, isec->map_head.s);
11847           isec->call_check_in_progress = 0;
11848           if (recur != 0)
11849             ret = recur;
11850         }
11851     }
11852
11853   if (ret == 1)
11854     isec->makes_toc_func_call = 1;
11855
11856   return ret;
11857 }
11858
11859 /* The linker repeatedly calls this function for each input section,
11860    in the order that input sections are linked into output sections.
11861    Build lists of input sections to determine groupings between which
11862    we may insert linker stubs.  */
11863
11864 bfd_boolean
11865 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
11866 {
11867   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11868
11869   if (htab == NULL)
11870     return FALSE;
11871
11872   if ((isec->output_section->flags & SEC_CODE) != 0
11873       && isec->output_section->id < htab->sec_info_arr_size)
11874     {
11875       /* This happens to make the list in reverse order,
11876          which is what we want.  */
11877       htab->sec_info[isec->id].u.list
11878         = htab->sec_info[isec->output_section->id].u.list;
11879       htab->sec_info[isec->output_section->id].u.list = isec;
11880     }
11881
11882   if (htab->multi_toc_needed)
11883     {
11884       /* Analyse sections that aren't already flagged as needing a
11885          valid toc pointer.  Exclude .fixup for the linux kernel.
11886          .fixup contains branches, but only back to the function that
11887          hit an exception.  */
11888       if (!(isec->has_toc_reloc
11889             || (isec->flags & SEC_CODE) == 0
11890             || strcmp (isec->name, ".fixup") == 0
11891             || isec->call_check_done))
11892         {
11893           if (toc_adjusting_stub_needed (info, isec) < 0)
11894             return FALSE;
11895         }
11896       /* Make all sections use the TOC assigned for this object file.
11897          This will be wrong for pasted sections;  We fix that in
11898          check_pasted_section().  */
11899       if (elf_gp (isec->owner) != 0)
11900         htab->toc_curr = elf_gp (isec->owner);
11901     }
11902
11903   htab->sec_info[isec->id].toc_off = htab->toc_curr;
11904   return TRUE;
11905 }
11906
11907 /* Check that all .init and .fini sections use the same toc, if they
11908    have toc relocs.  */
11909
11910 static bfd_boolean
11911 check_pasted_section (struct bfd_link_info *info, const char *name)
11912 {
11913   asection *o = bfd_get_section_by_name (info->output_bfd, name);
11914
11915   if (o != NULL)
11916     {
11917       struct ppc_link_hash_table *htab = ppc_hash_table (info);
11918       bfd_vma toc_off = 0;
11919       asection *i;
11920
11921       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11922         if (i->has_toc_reloc)
11923           {
11924             if (toc_off == 0)
11925               toc_off = htab->sec_info[i->id].toc_off;
11926             else if (toc_off != htab->sec_info[i->id].toc_off)
11927               return FALSE;
11928           }
11929
11930       if (toc_off == 0)
11931         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11932           if (i->makes_toc_func_call)
11933             {
11934               toc_off = htab->sec_info[i->id].toc_off;
11935               break;
11936             }
11937
11938       /* Make sure the whole pasted function uses the same toc offset.  */
11939       if (toc_off != 0)
11940         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11941           htab->sec_info[i->id].toc_off = toc_off;
11942     }
11943   return TRUE;
11944 }
11945
11946 bfd_boolean
11947 ppc64_elf_check_init_fini (struct bfd_link_info *info)
11948 {
11949   return (check_pasted_section (info, ".init")
11950           & check_pasted_section (info, ".fini"));
11951 }
11952
11953 /* See whether we can group stub sections together.  Grouping stub
11954    sections may result in fewer stubs.  More importantly, we need to
11955    put all .init* and .fini* stubs at the beginning of the .init or
11956    .fini output sections respectively, because glibc splits the
11957    _init and _fini functions into multiple parts.  Putting a stub in
11958    the middle of a function is not a good idea.  */
11959
11960 static bfd_boolean
11961 group_sections (struct bfd_link_info *info,
11962                 bfd_size_type stub_group_size,
11963                 bfd_boolean stubs_always_before_branch)
11964 {
11965   struct ppc_link_hash_table *htab;
11966   asection *osec;
11967   bfd_size_type stub14_group_size;
11968   bfd_boolean suppress_size_errors;
11969
11970   htab = ppc_hash_table (info);
11971   if (htab == NULL)
11972     return FALSE;
11973
11974   suppress_size_errors = FALSE;
11975   stub14_group_size = stub_group_size >> 10;
11976   if (stub_group_size == 1)
11977     {
11978       /* Default values.  */
11979       if (stubs_always_before_branch)
11980         {
11981           stub_group_size = 0x1e00000;
11982           stub14_group_size = 0x7800;
11983         }
11984       else
11985         {
11986           stub_group_size = 0x1c00000;
11987           stub14_group_size = 0x7000;
11988         }
11989       suppress_size_errors = TRUE;
11990     }
11991
11992   for (osec = info->output_bfd->sections; osec != NULL; osec = osec->next)
11993     {
11994       asection *tail;
11995
11996       if (osec->id >= htab->sec_info_arr_size)
11997         continue;
11998
11999       tail = htab->sec_info[osec->id].u.list;
12000       while (tail != NULL)
12001         {
12002           asection *curr;
12003           asection *prev;
12004           bfd_size_type total;
12005           bfd_boolean big_sec;
12006           bfd_vma curr_toc;
12007           struct map_stub *group;
12008
12009           curr = tail;
12010           total = tail->size;
12011           big_sec = total > (ppc64_elf_section_data (tail) != NULL
12012                              && ppc64_elf_section_data (tail)->has_14bit_branch
12013                              ? stub14_group_size : stub_group_size);
12014           if (big_sec && !suppress_size_errors)
12015             (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
12016                                      tail->owner, tail);
12017           curr_toc = htab->sec_info[tail->id].toc_off;
12018
12019           while ((prev = htab->sec_info[curr->id].u.list) != NULL
12020                  && ((total += curr->output_offset - prev->output_offset)
12021                      < (ppc64_elf_section_data (prev) != NULL
12022                         && ppc64_elf_section_data (prev)->has_14bit_branch
12023                         ? stub14_group_size : stub_group_size))
12024                  && htab->sec_info[prev->id].toc_off == curr_toc)
12025             curr = prev;
12026
12027           /* OK, the size from the start of CURR to the end is less
12028              than stub_group_size and thus can be handled by one stub
12029              section.  (or the tail section is itself larger than
12030              stub_group_size, in which case we may be toast.)  We
12031              should really be keeping track of the total size of stubs
12032              added here, as stubs contribute to the final output
12033              section size.  That's a little tricky, and this way will
12034              only break if stubs added make the total size more than
12035              2^25, ie. for the default stub_group_size, if stubs total
12036              more than 2097152 bytes, or nearly 75000 plt call stubs.  */
12037           group = bfd_alloc (curr->owner, sizeof (*group));
12038           if (group == NULL)
12039             return FALSE;
12040           group->link_sec = curr;
12041           group->stub_sec = NULL;
12042           group->needs_save_res = 0;
12043           group->next = htab->group;
12044           htab->group = group;
12045           do
12046             {
12047               prev = htab->sec_info[tail->id].u.list;
12048               /* Set up this stub group.  */
12049               htab->sec_info[tail->id].u.group = group;
12050             }
12051           while (tail != curr && (tail = prev) != NULL);
12052
12053           /* But wait, there's more!  Input sections up to stub_group_size
12054              bytes before the stub section can be handled by it too.
12055              Don't do this if we have a really large section after the
12056              stubs, as adding more stubs increases the chance that
12057              branches may not reach into the stub section.  */
12058           if (!stubs_always_before_branch && !big_sec)
12059             {
12060               total = 0;
12061               while (prev != NULL
12062                      && ((total += tail->output_offset - prev->output_offset)
12063                          < (ppc64_elf_section_data (prev) != NULL
12064                             && ppc64_elf_section_data (prev)->has_14bit_branch
12065                             ? stub14_group_size : stub_group_size))
12066                      && htab->sec_info[prev->id].toc_off == curr_toc)
12067                 {
12068                   tail = prev;
12069                   prev = htab->sec_info[tail->id].u.list;
12070                   htab->sec_info[tail->id].u.group = group;
12071                 }
12072             }
12073           tail = prev;
12074         }
12075     }
12076   return TRUE;
12077 }
12078
12079 static const unsigned char glink_eh_frame_cie[] =
12080 {
12081   0, 0, 0, 16,                          /* length.  */
12082   0, 0, 0, 0,                           /* id.  */
12083   1,                                    /* CIE version.  */
12084   'z', 'R', 0,                          /* Augmentation string.  */
12085   4,                                    /* Code alignment.  */
12086   0x78,                                 /* Data alignment.  */
12087   65,                                   /* RA reg.  */
12088   1,                                    /* Augmentation size.  */
12089   DW_EH_PE_pcrel | DW_EH_PE_sdata4,     /* FDE encoding.  */
12090   DW_CFA_def_cfa, 1, 0,                 /* def_cfa: r1 offset 0.  */
12091   0, 0, 0, 0
12092 };
12093
12094 /* Stripping output sections is normally done before dynamic section
12095    symbols have been allocated.  This function is called later, and
12096    handles cases like htab->brlt which is mapped to its own output
12097    section.  */
12098
12099 static void
12100 maybe_strip_output (struct bfd_link_info *info, asection *isec)
12101 {
12102   if (isec->size == 0
12103       && isec->output_section->size == 0
12104       && !(isec->output_section->flags & SEC_KEEP)
12105       && !bfd_section_removed_from_list (info->output_bfd,
12106                                          isec->output_section)
12107       && elf_section_data (isec->output_section)->dynindx == 0)
12108     {
12109       isec->output_section->flags |= SEC_EXCLUDE;
12110       bfd_section_list_remove (info->output_bfd, isec->output_section);
12111       info->output_bfd->section_count--;
12112     }
12113 }
12114
12115 /* Determine and set the size of the stub section for a final link.
12116
12117    The basic idea here is to examine all the relocations looking for
12118    PC-relative calls to a target that is unreachable with a "bl"
12119    instruction.  */
12120
12121 bfd_boolean
12122 ppc64_elf_size_stubs (struct bfd_link_info *info)
12123 {
12124   bfd_size_type stub_group_size;
12125   bfd_boolean stubs_always_before_branch;
12126   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12127
12128   if (htab == NULL)
12129     return FALSE;
12130
12131   if (htab->params->plt_thread_safe == -1 && !bfd_link_executable (info))
12132     htab->params->plt_thread_safe = 1;
12133   if (!htab->opd_abi)
12134     htab->params->plt_thread_safe = 0;
12135   else if (htab->params->plt_thread_safe == -1)
12136     {
12137       static const char *const thread_starter[] =
12138         {
12139           "pthread_create",
12140           /* libstdc++ */
12141           "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
12142           /* librt */
12143           "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
12144           "mq_notify", "create_timer",
12145           /* libanl */
12146           "getaddrinfo_a",
12147           /* libgomp */
12148           "GOMP_parallel",
12149           "GOMP_parallel_start",
12150           "GOMP_parallel_loop_static",
12151           "GOMP_parallel_loop_static_start",
12152           "GOMP_parallel_loop_dynamic",
12153           "GOMP_parallel_loop_dynamic_start",
12154           "GOMP_parallel_loop_guided",
12155           "GOMP_parallel_loop_guided_start",
12156           "GOMP_parallel_loop_runtime",
12157           "GOMP_parallel_loop_runtime_start",
12158           "GOMP_parallel_sections",
12159           "GOMP_parallel_sections_start",
12160           /* libgo */
12161           "__go_go",
12162         };
12163       unsigned i;
12164
12165       for (i = 0; i < ARRAY_SIZE (thread_starter); i++)
12166         {
12167           struct elf_link_hash_entry *h;
12168           h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
12169                                     FALSE, FALSE, TRUE);
12170           htab->params->plt_thread_safe = h != NULL && h->ref_regular;
12171           if (htab->params->plt_thread_safe)
12172             break;
12173         }
12174     }
12175   stubs_always_before_branch = htab->params->group_size < 0;
12176   if (htab->params->group_size < 0)
12177     stub_group_size = -htab->params->group_size;
12178   else
12179     stub_group_size = htab->params->group_size;
12180
12181   if (!group_sections (info, stub_group_size, stubs_always_before_branch))
12182     return FALSE;
12183
12184   while (1)
12185     {
12186       bfd *input_bfd;
12187       unsigned int bfd_indx;
12188       struct map_stub *group;
12189       asection *stub_sec;
12190
12191       htab->stub_iteration += 1;
12192
12193       for (input_bfd = info->input_bfds, bfd_indx = 0;
12194            input_bfd != NULL;
12195            input_bfd = input_bfd->link.next, bfd_indx++)
12196         {
12197           Elf_Internal_Shdr *symtab_hdr;
12198           asection *section;
12199           Elf_Internal_Sym *local_syms = NULL;
12200
12201           if (!is_ppc64_elf (input_bfd))
12202             continue;
12203
12204           /* We'll need the symbol table in a second.  */
12205           symtab_hdr = &elf_symtab_hdr (input_bfd);
12206           if (symtab_hdr->sh_info == 0)
12207             continue;
12208
12209           /* Walk over each section attached to the input bfd.  */
12210           for (section = input_bfd->sections;
12211                section != NULL;
12212                section = section->next)
12213             {
12214               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
12215
12216               /* If there aren't any relocs, then there's nothing more
12217                  to do.  */
12218               if ((section->flags & SEC_RELOC) == 0
12219                   || (section->flags & SEC_ALLOC) == 0
12220                   || (section->flags & SEC_LOAD) == 0
12221                   || (section->flags & SEC_CODE) == 0
12222                   || section->reloc_count == 0)
12223                 continue;
12224
12225               /* If this section is a link-once section that will be
12226                  discarded, then don't create any stubs.  */
12227               if (section->output_section == NULL
12228                   || section->output_section->owner != info->output_bfd)
12229                 continue;
12230
12231               /* Get the relocs.  */
12232               internal_relocs
12233                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
12234                                              info->keep_memory);
12235               if (internal_relocs == NULL)
12236                 goto error_ret_free_local;
12237
12238               /* Now examine each relocation.  */
12239               irela = internal_relocs;
12240               irelaend = irela + section->reloc_count;
12241               for (; irela < irelaend; irela++)
12242                 {
12243                   enum elf_ppc64_reloc_type r_type;
12244                   unsigned int r_indx;
12245                   enum ppc_stub_type stub_type;
12246                   struct ppc_stub_hash_entry *stub_entry;
12247                   asection *sym_sec, *code_sec;
12248                   bfd_vma sym_value, code_value;
12249                   bfd_vma destination;
12250                   unsigned long local_off;
12251                   bfd_boolean ok_dest;
12252                   struct ppc_link_hash_entry *hash;
12253                   struct ppc_link_hash_entry *fdh;
12254                   struct elf_link_hash_entry *h;
12255                   Elf_Internal_Sym *sym;
12256                   char *stub_name;
12257                   const asection *id_sec;
12258                   struct _opd_sec_data *opd;
12259                   struct plt_entry *plt_ent;
12260
12261                   r_type = ELF64_R_TYPE (irela->r_info);
12262                   r_indx = ELF64_R_SYM (irela->r_info);
12263
12264                   if (r_type >= R_PPC64_max)
12265                     {
12266                       bfd_set_error (bfd_error_bad_value);
12267                       goto error_ret_free_internal;
12268                     }
12269
12270                   /* Only look for stubs on branch instructions.  */
12271                   if (r_type != R_PPC64_REL24
12272                       && r_type != R_PPC64_REL14
12273                       && r_type != R_PPC64_REL14_BRTAKEN
12274                       && r_type != R_PPC64_REL14_BRNTAKEN)
12275                     continue;
12276
12277                   /* Now determine the call target, its name, value,
12278                      section.  */
12279                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12280                                   r_indx, input_bfd))
12281                     goto error_ret_free_internal;
12282                   hash = (struct ppc_link_hash_entry *) h;
12283
12284                   ok_dest = FALSE;
12285                   fdh = NULL;
12286                   sym_value = 0;
12287                   if (hash == NULL)
12288                     {
12289                       sym_value = sym->st_value;
12290                       if (sym_sec != NULL
12291                           && sym_sec->output_section != NULL)
12292                         ok_dest = TRUE;
12293                     }
12294                   else if (hash->elf.root.type == bfd_link_hash_defined
12295                            || hash->elf.root.type == bfd_link_hash_defweak)
12296                     {
12297                       sym_value = hash->elf.root.u.def.value;
12298                       if (sym_sec->output_section != NULL)
12299                         ok_dest = TRUE;
12300                     }
12301                   else if (hash->elf.root.type == bfd_link_hash_undefweak
12302                            || hash->elf.root.type == bfd_link_hash_undefined)
12303                     {
12304                       /* Recognise an old ABI func code entry sym, and
12305                          use the func descriptor sym instead if it is
12306                          defined.  */
12307                       if (hash->elf.root.root.string[0] == '.'
12308                           && (fdh = lookup_fdh (hash, htab)) != NULL)
12309                         {
12310                           if (fdh->elf.root.type == bfd_link_hash_defined
12311                               || fdh->elf.root.type == bfd_link_hash_defweak)
12312                             {
12313                               sym_sec = fdh->elf.root.u.def.section;
12314                               sym_value = fdh->elf.root.u.def.value;
12315                               if (sym_sec->output_section != NULL)
12316                                 ok_dest = TRUE;
12317                             }
12318                           else
12319                             fdh = NULL;
12320                         }
12321                     }
12322                   else
12323                     {
12324                       bfd_set_error (bfd_error_bad_value);
12325                       goto error_ret_free_internal;
12326                     }
12327
12328                   destination = 0;
12329                   local_off = 0;
12330                   if (ok_dest)
12331                     {
12332                       sym_value += irela->r_addend;
12333                       destination = (sym_value
12334                                      + sym_sec->output_offset
12335                                      + sym_sec->output_section->vma);
12336                       local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12337                                                             ? hash->elf.other
12338                                                             : sym->st_other);
12339                     }
12340
12341                   code_sec = sym_sec;
12342                   code_value = sym_value;
12343                   opd = get_opd_info (sym_sec);
12344                   if (opd != NULL)
12345                     {
12346                       bfd_vma dest;
12347
12348                       if (hash == NULL && opd->adjust != NULL)
12349                         {
12350                           long adjust = opd->adjust[OPD_NDX (sym_value)];
12351                           if (adjust == -1)
12352                             continue;
12353                           code_value += adjust;
12354                           sym_value += adjust;
12355                         }
12356                       dest = opd_entry_value (sym_sec, sym_value,
12357                                               &code_sec, &code_value, FALSE);
12358                       if (dest != (bfd_vma) -1)
12359                         {
12360                           destination = dest;
12361                           if (fdh != NULL)
12362                             {
12363                               /* Fixup old ABI sym to point at code
12364                                  entry.  */
12365                               hash->elf.root.type = bfd_link_hash_defweak;
12366                               hash->elf.root.u.def.section = code_sec;
12367                               hash->elf.root.u.def.value = code_value;
12368                             }
12369                         }
12370                     }
12371
12372                   /* Determine what (if any) linker stub is needed.  */
12373                   plt_ent = NULL;
12374                   stub_type = ppc_type_of_stub (section, irela, &hash,
12375                                                 &plt_ent, destination,
12376                                                 local_off);
12377
12378                   if (stub_type != ppc_stub_plt_call)
12379                     {
12380                       /* Check whether we need a TOC adjusting stub.
12381                          Since the linker pastes together pieces from
12382                          different object files when creating the
12383                          _init and _fini functions, it may be that a
12384                          call to what looks like a local sym is in
12385                          fact a call needing a TOC adjustment.  */
12386                       if (code_sec != NULL
12387                           && code_sec->output_section != NULL
12388                           && (htab->sec_info[code_sec->id].toc_off
12389                               != htab->sec_info[section->id].toc_off)
12390                           && (code_sec->has_toc_reloc
12391                               || code_sec->makes_toc_func_call))
12392                         stub_type = ppc_stub_long_branch_r2off;
12393                     }
12394
12395                   if (stub_type == ppc_stub_none)
12396                     continue;
12397
12398                   /* __tls_get_addr calls might be eliminated.  */
12399                   if (stub_type != ppc_stub_plt_call
12400                       && hash != NULL
12401                       && (hash == htab->tls_get_addr
12402                           || hash == htab->tls_get_addr_fd)
12403                       && section->has_tls_reloc
12404                       && irela != internal_relocs)
12405                     {
12406                       /* Get tls info.  */
12407                       unsigned char *tls_mask;
12408
12409                       if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12410                                          irela - 1, input_bfd))
12411                         goto error_ret_free_internal;
12412                       if (*tls_mask != 0)
12413                         continue;
12414                     }
12415
12416                   if (stub_type == ppc_stub_plt_call
12417                       && irela + 1 < irelaend
12418                       && irela[1].r_offset == irela->r_offset + 4
12419                       && ELF64_R_TYPE (irela[1].r_info) == R_PPC64_TOCSAVE)
12420                     {
12421                       if (!tocsave_find (htab, INSERT,
12422                                          &local_syms, irela + 1, input_bfd))
12423                         goto error_ret_free_internal;
12424                     }
12425                   else if (stub_type == ppc_stub_plt_call)
12426                     stub_type = ppc_stub_plt_call_r2save;
12427
12428                   /* Support for grouping stub sections.  */
12429                   id_sec = htab->sec_info[section->id].u.group->link_sec;
12430
12431                   /* Get the name of this stub.  */
12432                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12433                   if (!stub_name)
12434                     goto error_ret_free_internal;
12435
12436                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12437                                                      stub_name, FALSE, FALSE);
12438                   if (stub_entry != NULL)
12439                     {
12440                       /* The proper stub has already been created.  */
12441                       free (stub_name);
12442                       if (stub_type == ppc_stub_plt_call_r2save)
12443                         stub_entry->stub_type = stub_type;
12444                       continue;
12445                     }
12446
12447                   stub_entry = ppc_add_stub (stub_name, section, info);
12448                   if (stub_entry == NULL)
12449                     {
12450                       free (stub_name);
12451                     error_ret_free_internal:
12452                       if (elf_section_data (section)->relocs == NULL)
12453                         free (internal_relocs);
12454                     error_ret_free_local:
12455                       if (local_syms != NULL
12456                           && (symtab_hdr->contents
12457                               != (unsigned char *) local_syms))
12458                         free (local_syms);
12459                       return FALSE;
12460                     }
12461
12462                   stub_entry->stub_type = stub_type;
12463                   if (stub_type != ppc_stub_plt_call
12464                       && stub_type != ppc_stub_plt_call_r2save)
12465                     {
12466                       stub_entry->target_value = code_value;
12467                       stub_entry->target_section = code_sec;
12468                     }
12469                   else
12470                     {
12471                       stub_entry->target_value = sym_value;
12472                       stub_entry->target_section = sym_sec;
12473                     }
12474                   stub_entry->h = hash;
12475                   stub_entry->plt_ent = plt_ent;
12476                   stub_entry->other = hash ? hash->elf.other : sym->st_other;
12477
12478                   if (stub_entry->h != NULL)
12479                     htab->stub_globals += 1;
12480                 }
12481
12482               /* We're done with the internal relocs, free them.  */
12483               if (elf_section_data (section)->relocs != internal_relocs)
12484                 free (internal_relocs);
12485             }
12486
12487           if (local_syms != NULL
12488               && symtab_hdr->contents != (unsigned char *) local_syms)
12489             {
12490               if (!info->keep_memory)
12491                 free (local_syms);
12492               else
12493                 symtab_hdr->contents = (unsigned char *) local_syms;
12494             }
12495         }
12496
12497       /* We may have added some stubs.  Find out the new size of the
12498          stub sections.  */
12499       for (stub_sec = htab->params->stub_bfd->sections;
12500            stub_sec != NULL;
12501            stub_sec = stub_sec->next)
12502         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12503           {
12504             stub_sec->rawsize = stub_sec->size;
12505             stub_sec->size = 0;
12506             stub_sec->reloc_count = 0;
12507             stub_sec->flags &= ~SEC_RELOC;
12508           }
12509
12510       htab->brlt->size = 0;
12511       htab->brlt->reloc_count = 0;
12512       htab->brlt->flags &= ~SEC_RELOC;
12513       if (htab->relbrlt != NULL)
12514         htab->relbrlt->size = 0;
12515
12516       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12517
12518       for (group = htab->group; group != NULL; group = group->next)
12519         if (group->needs_save_res)
12520           group->stub_sec->size += htab->sfpr->size;
12521
12522       if (info->emitrelocations
12523           && htab->glink != NULL && htab->glink->size != 0)
12524         {
12525           htab->glink->reloc_count = 1;
12526           htab->glink->flags |= SEC_RELOC;
12527         }
12528
12529       if (htab->glink_eh_frame != NULL
12530           && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12531           && htab->glink_eh_frame->output_section->size != 0)
12532         {
12533           size_t size = 0, align;
12534
12535           for (stub_sec = htab->params->stub_bfd->sections;
12536                stub_sec != NULL;
12537                stub_sec = stub_sec->next)
12538             if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12539               size += 24;
12540           if (htab->glink != NULL && htab->glink->size != 0)
12541             size += 24;
12542           if (size != 0)
12543             size += sizeof (glink_eh_frame_cie);
12544           align = 1;
12545           align <<= htab->glink_eh_frame->output_section->alignment_power;
12546           align -= 1;
12547           size = (size + align) & ~align;
12548           htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12549           htab->glink_eh_frame->size = size;
12550         }
12551
12552       if (htab->params->plt_stub_align != 0)
12553         for (stub_sec = htab->params->stub_bfd->sections;
12554              stub_sec != NULL;
12555              stub_sec = stub_sec->next)
12556           if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12557             stub_sec->size = ((stub_sec->size
12558                                + (1 << htab->params->plt_stub_align) - 1)
12559                               & -(1 << htab->params->plt_stub_align));
12560
12561       for (stub_sec = htab->params->stub_bfd->sections;
12562            stub_sec != NULL;
12563            stub_sec = stub_sec->next)
12564         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12565             && stub_sec->rawsize != stub_sec->size)
12566           break;
12567
12568       /* Exit from this loop when no stubs have been added, and no stubs
12569          have changed size.  */
12570       if (stub_sec == NULL
12571           && (htab->glink_eh_frame == NULL
12572               || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12573         break;
12574
12575       /* Ask the linker to do its stuff.  */
12576       (*htab->params->layout_sections_again) ();
12577     }
12578
12579   if (htab->glink_eh_frame != NULL
12580       && htab->glink_eh_frame->size != 0)
12581     {
12582       bfd_vma val;
12583       bfd_byte *p, *last_fde;
12584       size_t last_fde_len, size, align, pad;
12585       asection *stub_sec;
12586
12587       p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12588       if (p == NULL)
12589         return FALSE;
12590       htab->glink_eh_frame->contents = p;
12591       last_fde = p;
12592
12593       memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12594       /* CIE length (rewrite in case little-endian).  */
12595       last_fde_len = sizeof (glink_eh_frame_cie) - 4;
12596       bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12597       p += sizeof (glink_eh_frame_cie);
12598
12599       for (stub_sec = htab->params->stub_bfd->sections;
12600            stub_sec != NULL;
12601            stub_sec = stub_sec->next)
12602         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12603           {
12604             last_fde = p;
12605             last_fde_len = 20;
12606             /* FDE length.  */
12607             bfd_put_32 (htab->elf.dynobj, 20, p);
12608             p += 4;
12609             /* CIE pointer.  */
12610             val = p - htab->glink_eh_frame->contents;
12611             bfd_put_32 (htab->elf.dynobj, val, p);
12612             p += 4;
12613             /* Offset to stub section, written later.  */
12614             p += 4;
12615             /* stub section size.  */
12616             bfd_put_32 (htab->elf.dynobj, stub_sec->size, p);
12617             p += 4;
12618             /* Augmentation.  */
12619             p += 1;
12620             /* Pad.  */
12621             p += 7;
12622           }
12623       if (htab->glink != NULL && htab->glink->size != 0)
12624         {
12625           last_fde = p;
12626           last_fde_len = 20;
12627           /* FDE length.  */
12628           bfd_put_32 (htab->elf.dynobj, 20, p);
12629           p += 4;
12630           /* CIE pointer.  */
12631           val = p - htab->glink_eh_frame->contents;
12632           bfd_put_32 (htab->elf.dynobj, val, p);
12633           p += 4;
12634           /* Offset to .glink, written later.  */
12635           p += 4;
12636           /* .glink size.  */
12637           bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12638           p += 4;
12639           /* Augmentation.  */
12640           p += 1;
12641
12642           *p++ = DW_CFA_advance_loc + 1;
12643           *p++ = DW_CFA_register;
12644           *p++ = 65;
12645           *p++ = htab->opd_abi ? 12 : 0;
12646           *p++ = DW_CFA_advance_loc + 4;
12647           *p++ = DW_CFA_restore_extended;
12648           *p++ = 65;
12649         }
12650       /* Subsume any padding into the last FDE if user .eh_frame
12651          sections are aligned more than glink_eh_frame.  Otherwise any
12652          zero padding will be seen as a terminator.  */
12653       size = p - htab->glink_eh_frame->contents;
12654       align = 1;
12655       align <<= htab->glink_eh_frame->output_section->alignment_power;
12656       align -= 1;
12657       pad = ((size + align) & ~align) - size;
12658       htab->glink_eh_frame->size = size + pad;
12659       bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12660     }
12661
12662   maybe_strip_output (info, htab->brlt);
12663   if (htab->glink_eh_frame != NULL)
12664     maybe_strip_output (info, htab->glink_eh_frame);
12665
12666   return TRUE;
12667 }
12668
12669 /* Called after we have determined section placement.  If sections
12670    move, we'll be called again.  Provide a value for TOCstart.  */
12671
12672 bfd_vma
12673 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12674 {
12675   asection *s;
12676   bfd_vma TOCstart, adjust;
12677
12678   if (info != NULL)
12679     {
12680       struct elf_link_hash_entry *h;
12681       struct elf_link_hash_table *htab = elf_hash_table (info);
12682
12683       if (is_elf_hash_table (htab)
12684           && htab->hgot != NULL)
12685         h = htab->hgot;
12686       else
12687         {
12688           h = elf_link_hash_lookup (htab, ".TOC.", FALSE, FALSE, TRUE);
12689           if (is_elf_hash_table (htab))
12690             htab->hgot = h;
12691         }
12692       if (h != NULL
12693           && h->root.type == bfd_link_hash_defined
12694           && !h->root.linker_def
12695           && (!is_elf_hash_table (htab)
12696               || h->def_regular))
12697         {
12698           TOCstart = (h->root.u.def.value - TOC_BASE_OFF
12699                       + h->root.u.def.section->output_offset
12700                       + h->root.u.def.section->output_section->vma);
12701           _bfd_set_gp_value (obfd, TOCstart);
12702           return TOCstart;
12703         }
12704     }
12705
12706   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12707      order.  The TOC starts where the first of these sections starts.  */
12708   s = bfd_get_section_by_name (obfd, ".got");
12709   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12710     s = bfd_get_section_by_name (obfd, ".toc");
12711   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12712     s = bfd_get_section_by_name (obfd, ".tocbss");
12713   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12714     s = bfd_get_section_by_name (obfd, ".plt");
12715   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12716     {
12717       /* This may happen for
12718          o  references to TOC base (SYM@toc / TOC[tc0]) without a
12719          .toc directive
12720          o  bad linker script
12721          o --gc-sections and empty TOC sections
12722
12723          FIXME: Warn user?  */
12724
12725       /* Look for a likely section.  We probably won't even be
12726          using TOCstart.  */
12727       for (s = obfd->sections; s != NULL; s = s->next)
12728         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
12729                          | SEC_EXCLUDE))
12730             == (SEC_ALLOC | SEC_SMALL_DATA))
12731           break;
12732       if (s == NULL)
12733         for (s = obfd->sections; s != NULL; s = s->next)
12734           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
12735               == (SEC_ALLOC | SEC_SMALL_DATA))
12736             break;
12737       if (s == NULL)
12738         for (s = obfd->sections; s != NULL; s = s->next)
12739           if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
12740               == SEC_ALLOC)
12741             break;
12742       if (s == NULL)
12743         for (s = obfd->sections; s != NULL; s = s->next)
12744           if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
12745             break;
12746     }
12747
12748   TOCstart = 0;
12749   if (s != NULL)
12750     TOCstart = s->output_section->vma + s->output_offset;
12751
12752   /* Force alignment.  */
12753   adjust = TOCstart & (TOC_BASE_ALIGN - 1);
12754   TOCstart -= adjust;
12755   _bfd_set_gp_value (obfd, TOCstart);
12756
12757   if (info != NULL && s != NULL)
12758     {
12759       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12760
12761       if (htab != NULL)
12762         {
12763           if (htab->elf.hgot != NULL)
12764             {
12765               htab->elf.hgot->root.u.def.value = TOC_BASE_OFF - adjust;
12766               htab->elf.hgot->root.u.def.section = s;
12767             }
12768         }
12769       else
12770         {
12771           struct bfd_link_hash_entry *bh = NULL;
12772           _bfd_generic_link_add_one_symbol (info, obfd, ".TOC.", BSF_GLOBAL,
12773                                             s, TOC_BASE_OFF - adjust,
12774                                             NULL, FALSE, FALSE, &bh);
12775         }
12776     }
12777   return TOCstart;
12778 }
12779
12780 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
12781    write out any global entry stubs.  */
12782
12783 static bfd_boolean
12784 build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
12785 {
12786   struct bfd_link_info *info;
12787   struct ppc_link_hash_table *htab;
12788   struct plt_entry *pent;
12789   asection *s;
12790
12791   if (h->root.type == bfd_link_hash_indirect)
12792     return TRUE;
12793
12794   if (!h->pointer_equality_needed)
12795     return TRUE;
12796
12797   if (h->def_regular)
12798     return TRUE;
12799
12800   info = inf;
12801   htab = ppc_hash_table (info);
12802   if (htab == NULL)
12803     return FALSE;
12804
12805   s = htab->glink;
12806   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
12807     if (pent->plt.offset != (bfd_vma) -1
12808         && pent->addend == 0)
12809       {
12810         bfd_byte *p;
12811         asection *plt;
12812         bfd_vma off;
12813
12814         p = s->contents + h->root.u.def.value;
12815         plt = htab->elf.splt;
12816         if (!htab->elf.dynamic_sections_created
12817             || h->dynindx == -1)
12818           plt = htab->elf.iplt;
12819         off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
12820         off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
12821
12822         if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
12823           {
12824             info->callbacks->einfo
12825               (_("%P: linkage table error against `%T'\n"),
12826                h->root.root.string);
12827             bfd_set_error (bfd_error_bad_value);
12828             htab->stub_error = TRUE;
12829           }
12830
12831         htab->stub_count[ppc_stub_global_entry - 1] += 1;
12832         if (htab->params->emit_stub_syms)
12833           {
12834             size_t len = strlen (h->root.root.string);
12835             char *name = bfd_malloc (sizeof "12345678.global_entry." + len);
12836
12837             if (name == NULL)
12838               return FALSE;
12839
12840             sprintf (name, "%08x.global_entry.%s", s->id, h->root.root.string);
12841             h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
12842             if (h == NULL)
12843               return FALSE;
12844             if (h->root.type == bfd_link_hash_new)
12845               {
12846                 h->root.type = bfd_link_hash_defined;
12847                 h->root.u.def.section = s;
12848                 h->root.u.def.value = p - s->contents;
12849                 h->ref_regular = 1;
12850                 h->def_regular = 1;
12851                 h->ref_regular_nonweak = 1;
12852                 h->forced_local = 1;
12853                 h->non_elf = 0;
12854                 h->root.linker_def = 1;
12855               }
12856           }
12857
12858         if (PPC_HA (off) != 0)
12859           {
12860             bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
12861             p += 4;
12862           }
12863         bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
12864         p += 4;
12865         bfd_put_32 (s->owner, MTCTR_R12, p);
12866         p += 4;
12867         bfd_put_32 (s->owner, BCTR, p);
12868         break;
12869       }
12870   return TRUE;
12871 }
12872
12873 /* Build all the stubs associated with the current output file.
12874    The stubs are kept in a hash table attached to the main linker
12875    hash table.  This function is called via gldelf64ppc_finish.  */
12876
12877 bfd_boolean
12878 ppc64_elf_build_stubs (struct bfd_link_info *info,
12879                        char **stats)
12880 {
12881   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12882   struct map_stub *group;
12883   asection *stub_sec;
12884   bfd_byte *p;
12885   int stub_sec_count = 0;
12886
12887   if (htab == NULL)
12888     return FALSE;
12889
12890   /* Allocate memory to hold the linker stubs.  */
12891   for (stub_sec = htab->params->stub_bfd->sections;
12892        stub_sec != NULL;
12893        stub_sec = stub_sec->next)
12894     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12895         && stub_sec->size != 0)
12896       {
12897         stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
12898         if (stub_sec->contents == NULL)
12899           return FALSE;
12900         /* We want to check that built size is the same as calculated
12901            size.  rawsize is a convenient location to use.  */
12902         stub_sec->rawsize = stub_sec->size;
12903         stub_sec->size = 0;
12904       }
12905
12906   if (htab->glink != NULL && htab->glink->size != 0)
12907     {
12908       unsigned int indx;
12909       bfd_vma plt0;
12910
12911       /* Build the .glink plt call stub.  */
12912       if (htab->params->emit_stub_syms)
12913         {
12914           struct elf_link_hash_entry *h;
12915           h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
12916                                     TRUE, FALSE, FALSE);
12917           if (h == NULL)
12918             return FALSE;
12919           if (h->root.type == bfd_link_hash_new)
12920             {
12921               h->root.type = bfd_link_hash_defined;
12922               h->root.u.def.section = htab->glink;
12923               h->root.u.def.value = 8;
12924               h->ref_regular = 1;
12925               h->def_regular = 1;
12926               h->ref_regular_nonweak = 1;
12927               h->forced_local = 1;
12928               h->non_elf = 0;
12929               h->root.linker_def = 1;
12930             }
12931         }
12932       plt0 = (htab->elf.splt->output_section->vma
12933               + htab->elf.splt->output_offset
12934               - 16);
12935       if (info->emitrelocations)
12936         {
12937           Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
12938           if (r == NULL)
12939             return FALSE;
12940           r->r_offset = (htab->glink->output_offset
12941                          + htab->glink->output_section->vma);
12942           r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
12943           r->r_addend = plt0;
12944         }
12945       p = htab->glink->contents;
12946       plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
12947       bfd_put_64 (htab->glink->owner, plt0, p);
12948       p += 8;
12949       if (htab->opd_abi)
12950         {
12951           bfd_put_32 (htab->glink->owner, MFLR_R12, p);
12952           p += 4;
12953           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12954           p += 4;
12955           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12956           p += 4;
12957           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12958           p += 4;
12959           bfd_put_32 (htab->glink->owner, MTLR_R12, p);
12960           p += 4;
12961           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12962           p += 4;
12963           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12964           p += 4;
12965           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
12966           p += 4;
12967           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12968           p += 4;
12969           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
12970           p += 4;
12971         }
12972       else
12973         {
12974           bfd_put_32 (htab->glink->owner, MFLR_R0, p);
12975           p += 4;
12976           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12977           p += 4;
12978           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12979           p += 4;
12980           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12981           p += 4;
12982           bfd_put_32 (htab->glink->owner, MTLR_R0, p);
12983           p += 4;
12984           bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
12985           p += 4;
12986           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12987           p += 4;
12988           bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
12989           p += 4;
12990           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12991           p += 4;
12992           bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
12993           p += 4;
12994           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12995           p += 4;
12996           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
12997           p += 4;
12998         }
12999       bfd_put_32 (htab->glink->owner, BCTR, p);
13000       p += 4;
13001       while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
13002         {
13003           bfd_put_32 (htab->glink->owner, NOP, p);
13004           p += 4;
13005         }
13006
13007       /* Build the .glink lazy link call stubs.  */
13008       indx = 0;
13009       while (p < htab->glink->contents + htab->glink->rawsize)
13010         {
13011           if (htab->opd_abi)
13012             {
13013               if (indx < 0x8000)
13014                 {
13015                   bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
13016                   p += 4;
13017                 }
13018               else
13019                 {
13020                   bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
13021                   p += 4;
13022                   bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
13023                               p);
13024                   p += 4;
13025                 }
13026             }
13027           bfd_put_32 (htab->glink->owner,
13028                       B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
13029           indx++;
13030           p += 4;
13031         }
13032
13033       /* Build .glink global entry stubs.  */
13034       if (htab->glink->size > htab->glink->rawsize)
13035         elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
13036     }
13037
13038   if (htab->brlt != NULL && htab->brlt->size != 0)
13039     {
13040       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
13041                                          htab->brlt->size);
13042       if (htab->brlt->contents == NULL)
13043         return FALSE;
13044     }
13045   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
13046     {
13047       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
13048                                             htab->relbrlt->size);
13049       if (htab->relbrlt->contents == NULL)
13050         return FALSE;
13051     }
13052
13053   /* Build the stubs as directed by the stub hash table.  */
13054   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
13055
13056   for (group = htab->group; group != NULL; group = group->next)
13057     if (group->needs_save_res)
13058       {
13059         stub_sec = group->stub_sec;
13060         memcpy (stub_sec->contents + stub_sec->size, htab->sfpr->contents,
13061                 htab->sfpr->size);
13062         if (htab->params->emit_stub_syms)
13063           {
13064             unsigned int i;
13065
13066             for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
13067               if (!sfpr_define (info, &save_res_funcs[i], stub_sec))
13068                 return FALSE;
13069           }
13070         stub_sec->size += htab->sfpr->size;
13071       }
13072
13073   if (htab->relbrlt != NULL)
13074     htab->relbrlt->reloc_count = 0;
13075
13076   if (htab->params->plt_stub_align != 0)
13077     for (stub_sec = htab->params->stub_bfd->sections;
13078          stub_sec != NULL;
13079          stub_sec = stub_sec->next)
13080       if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
13081         stub_sec->size = ((stub_sec->size
13082                            + (1 << htab->params->plt_stub_align) - 1)
13083                           & -(1 << htab->params->plt_stub_align));
13084
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       {
13090         stub_sec_count += 1;
13091         if (stub_sec->rawsize != stub_sec->size)
13092           break;
13093       }
13094
13095   /* Note that the glink_eh_frame check here is not only testing that
13096      the generated size matched the calculated size but also that
13097      bfd_elf_discard_info didn't make any changes to the section.  */
13098   if (stub_sec != NULL
13099       || (htab->glink_eh_frame != NULL
13100           && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
13101     {
13102       htab->stub_error = TRUE;
13103       info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
13104     }
13105
13106   if (htab->stub_error)
13107     return FALSE;
13108
13109   if (stats != NULL)
13110     {
13111       *stats = bfd_malloc (500);
13112       if (*stats == NULL)
13113         return FALSE;
13114
13115       sprintf (*stats, _("linker stubs in %u group%s\n"
13116                          "  branch       %lu\n"
13117                          "  toc adjust   %lu\n"
13118                          "  long branch  %lu\n"
13119                          "  long toc adj %lu\n"
13120                          "  plt call     %lu\n"
13121                          "  plt call toc %lu\n"
13122                          "  global entry %lu"),
13123                stub_sec_count,
13124                stub_sec_count == 1 ? "" : "s",
13125                htab->stub_count[ppc_stub_long_branch - 1],
13126                htab->stub_count[ppc_stub_long_branch_r2off - 1],
13127                htab->stub_count[ppc_stub_plt_branch - 1],
13128                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
13129                htab->stub_count[ppc_stub_plt_call - 1],
13130                htab->stub_count[ppc_stub_plt_call_r2save - 1],
13131                htab->stub_count[ppc_stub_global_entry - 1]);
13132     }
13133   return TRUE;
13134 }
13135
13136 /* This function undoes the changes made by add_symbol_adjust.  */
13137
13138 static bfd_boolean
13139 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
13140 {
13141   struct ppc_link_hash_entry *eh;
13142
13143   if (h->root.type == bfd_link_hash_indirect)
13144     return TRUE;
13145
13146   eh = (struct ppc_link_hash_entry *) h;
13147   if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
13148     return TRUE;
13149
13150   eh->elf.root.type = bfd_link_hash_undefined;
13151   return TRUE;
13152 }
13153
13154 void
13155 ppc64_elf_restore_symbols (struct bfd_link_info *info)
13156 {
13157   struct ppc_link_hash_table *htab = ppc_hash_table (info);
13158
13159   if (htab != NULL)
13160     elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
13161 }
13162
13163 /* What to do when ld finds relocations against symbols defined in
13164    discarded sections.  */
13165
13166 static unsigned int
13167 ppc64_elf_action_discarded (asection *sec)
13168 {
13169   if (strcmp (".opd", sec->name) == 0)
13170     return 0;
13171
13172   if (strcmp (".toc", sec->name) == 0)
13173     return 0;
13174
13175   if (strcmp (".toc1", sec->name) == 0)
13176     return 0;
13177
13178   return _bfd_elf_default_action_discarded (sec);
13179 }
13180
13181 /* The RELOCATE_SECTION function is called by the ELF backend linker
13182    to handle the relocations for a section.
13183
13184    The relocs are always passed as Rela structures; if the section
13185    actually uses Rel structures, the r_addend field will always be
13186    zero.
13187
13188    This function is responsible for adjust the section contents as
13189    necessary, and (if using Rela relocs and generating a
13190    relocatable output file) adjusting the reloc addend as
13191    necessary.
13192
13193    This function does not have to worry about setting the reloc
13194    address or the reloc symbol index.
13195
13196    LOCAL_SYMS is a pointer to the swapped in local symbols.
13197
13198    LOCAL_SECTIONS is an array giving the section in the input file
13199    corresponding to the st_shndx field of each local symbol.
13200
13201    The global hash table entry for the global symbols can be found
13202    via elf_sym_hashes (input_bfd).
13203
13204    When generating relocatable output, this function must handle
13205    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
13206    going to be the section symbol corresponding to the output
13207    section, which means that the addend must be adjusted
13208    accordingly.  */
13209
13210 static bfd_boolean
13211 ppc64_elf_relocate_section (bfd *output_bfd,
13212                             struct bfd_link_info *info,
13213                             bfd *input_bfd,
13214                             asection *input_section,
13215                             bfd_byte *contents,
13216                             Elf_Internal_Rela *relocs,
13217                             Elf_Internal_Sym *local_syms,
13218                             asection **local_sections)
13219 {
13220   struct ppc_link_hash_table *htab;
13221   Elf_Internal_Shdr *symtab_hdr;
13222   struct elf_link_hash_entry **sym_hashes;
13223   Elf_Internal_Rela *rel;
13224   Elf_Internal_Rela *wrel;
13225   Elf_Internal_Rela *relend;
13226   Elf_Internal_Rela outrel;
13227   bfd_byte *loc;
13228   struct got_entry **local_got_ents;
13229   bfd_vma TOCstart;
13230   bfd_boolean ret = TRUE;
13231   bfd_boolean is_opd;
13232   /* Assume 'at' branch hints.  */
13233   bfd_boolean is_isa_v2 = TRUE;
13234   bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
13235
13236   /* Initialize howto table if needed.  */
13237   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
13238     ppc_howto_init ();
13239
13240   htab = ppc_hash_table (info);
13241   if (htab == NULL)
13242     return FALSE;
13243
13244   /* Don't relocate stub sections.  */
13245   if (input_section->owner == htab->params->stub_bfd)
13246     return TRUE;
13247
13248   BFD_ASSERT (is_ppc64_elf (input_bfd));
13249
13250   local_got_ents = elf_local_got_ents (input_bfd);
13251   TOCstart = elf_gp (output_bfd);
13252   symtab_hdr = &elf_symtab_hdr (input_bfd);
13253   sym_hashes = elf_sym_hashes (input_bfd);
13254   is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
13255
13256   rel = wrel = relocs;
13257   relend = relocs + input_section->reloc_count;
13258   for (; rel < relend; wrel++, rel++)
13259     {
13260       enum elf_ppc64_reloc_type r_type;
13261       bfd_vma addend;
13262       bfd_reloc_status_type r;
13263       Elf_Internal_Sym *sym;
13264       asection *sec;
13265       struct elf_link_hash_entry *h_elf;
13266       struct ppc_link_hash_entry *h;
13267       struct ppc_link_hash_entry *fdh;
13268       const char *sym_name;
13269       unsigned long r_symndx, toc_symndx;
13270       bfd_vma toc_addend;
13271       unsigned char tls_mask, tls_gd, tls_type;
13272       unsigned char sym_type;
13273       bfd_vma relocation;
13274       bfd_boolean unresolved_reloc;
13275       bfd_boolean warned;
13276       enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
13277       unsigned int insn;
13278       unsigned int mask;
13279       struct ppc_stub_hash_entry *stub_entry;
13280       bfd_vma max_br_offset;
13281       bfd_vma from;
13282       Elf_Internal_Rela orig_rel;
13283       reloc_howto_type *howto;
13284       struct reloc_howto_struct alt_howto;
13285
13286     again:
13287       orig_rel = *rel;
13288
13289       r_type = ELF64_R_TYPE (rel->r_info);
13290       r_symndx = ELF64_R_SYM (rel->r_info);
13291
13292       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
13293          symbol of the previous ADDR64 reloc.  The symbol gives us the
13294          proper TOC base to use.  */
13295       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
13296           && wrel != relocs
13297           && ELF64_R_TYPE (wrel[-1].r_info) == R_PPC64_ADDR64
13298           && is_opd)
13299         r_symndx = ELF64_R_SYM (wrel[-1].r_info);
13300
13301       sym = NULL;
13302       sec = NULL;
13303       h_elf = NULL;
13304       sym_name = NULL;
13305       unresolved_reloc = FALSE;
13306       warned = FALSE;
13307
13308       if (r_symndx < symtab_hdr->sh_info)
13309         {
13310           /* It's a local symbol.  */
13311           struct _opd_sec_data *opd;
13312
13313           sym = local_syms + r_symndx;
13314           sec = local_sections[r_symndx];
13315           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
13316           sym_type = ELF64_ST_TYPE (sym->st_info);
13317           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
13318           opd = get_opd_info (sec);
13319           if (opd != NULL && opd->adjust != NULL)
13320             {
13321               long adjust = opd->adjust[OPD_NDX (sym->st_value
13322                                                  + rel->r_addend)];
13323               if (adjust == -1)
13324                 relocation = 0;
13325               else
13326                 {
13327                   /* If this is a relocation against the opd section sym
13328                      and we have edited .opd, adjust the reloc addend so
13329                      that ld -r and ld --emit-relocs output is correct.
13330                      If it is a reloc against some other .opd symbol,
13331                      then the symbol value will be adjusted later.  */
13332                   if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
13333                     rel->r_addend += adjust;
13334                   else
13335                     relocation += adjust;
13336                 }
13337             }
13338         }
13339       else
13340         {
13341           bfd_boolean ignored;
13342
13343           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
13344                                    r_symndx, symtab_hdr, sym_hashes,
13345                                    h_elf, sec, relocation,
13346                                    unresolved_reloc, warned, ignored);
13347           sym_name = h_elf->root.root.string;
13348           sym_type = h_elf->type;
13349           if (sec != NULL
13350               && sec->owner == output_bfd
13351               && strcmp (sec->name, ".opd") == 0)
13352             {
13353               /* This is a symbol defined in a linker script.  All
13354                  such are defined in output sections, even those
13355                  defined by simple assignment from a symbol defined in
13356                  an input section.  Transfer the symbol to an
13357                  appropriate input .opd section, so that a branch to
13358                  this symbol will be mapped to the location specified
13359                  by the opd entry.  */
13360               struct bfd_link_order *lo;
13361               for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
13362                 if (lo->type == bfd_indirect_link_order)
13363                   {
13364                     asection *isec = lo->u.indirect.section;
13365                     if (h_elf->root.u.def.value >= isec->output_offset
13366                         && h_elf->root.u.def.value < (isec->output_offset
13367                                                       + isec->size))
13368                       {
13369                         h_elf->root.u.def.value -= isec->output_offset;
13370                         h_elf->root.u.def.section = isec;
13371                         sec = isec;
13372                         break;
13373                       }
13374                   }
13375             }
13376         }
13377       h = (struct ppc_link_hash_entry *) h_elf;
13378
13379       if (sec != NULL && discarded_section (sec))
13380         {
13381           _bfd_clear_contents (ppc64_elf_howto_table[r_type],
13382                                input_bfd, input_section,
13383                                contents + rel->r_offset);
13384           wrel->r_offset = rel->r_offset;
13385           wrel->r_info = 0;
13386           wrel->r_addend = 0;
13387
13388           /* For ld -r, remove relocations in debug sections against
13389              sections defined in discarded sections.  Not done for
13390              non-debug to preserve relocs in .eh_frame which the
13391              eh_frame editing code expects to be present.  */
13392           if (bfd_link_relocatable (info)
13393               && (input_section->flags & SEC_DEBUGGING))
13394             wrel--;
13395
13396           continue;
13397         }
13398
13399       if (bfd_link_relocatable (info))
13400         goto copy_reloc;
13401
13402       if (h != NULL && &h->elf == htab->elf.hgot)
13403         {
13404           relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
13405           sec = bfd_abs_section_ptr;
13406           unresolved_reloc = FALSE;
13407         }
13408
13409       /* TLS optimizations.  Replace instruction sequences and relocs
13410          based on information we collected in tls_optimize.  We edit
13411          RELOCS so that --emit-relocs will output something sensible
13412          for the final instruction stream.  */
13413       tls_mask = 0;
13414       tls_gd = 0;
13415       toc_symndx = 0;
13416       if (h != NULL)
13417         tls_mask = h->tls_mask;
13418       else if (local_got_ents != NULL)
13419         {
13420           struct plt_entry **local_plt = (struct plt_entry **)
13421             (local_got_ents + symtab_hdr->sh_info);
13422           unsigned char *lgot_masks = (unsigned char *)
13423             (local_plt + symtab_hdr->sh_info);
13424           tls_mask = lgot_masks[r_symndx];
13425         }
13426       if (tls_mask == 0
13427           && (r_type == R_PPC64_TLS
13428               || r_type == R_PPC64_TLSGD
13429               || r_type == R_PPC64_TLSLD))
13430         {
13431           /* Check for toc tls entries.  */
13432           unsigned char *toc_tls;
13433
13434           if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13435                              &local_syms, rel, input_bfd))
13436             return FALSE;
13437
13438           if (toc_tls)
13439             tls_mask = *toc_tls;
13440         }
13441
13442       /* Check that tls relocs are used with tls syms, and non-tls
13443          relocs are used with non-tls syms.  */
13444       if (r_symndx != STN_UNDEF
13445           && r_type != R_PPC64_NONE
13446           && (h == NULL
13447               || h->elf.root.type == bfd_link_hash_defined
13448               || h->elf.root.type == bfd_link_hash_defweak)
13449           && (IS_PPC64_TLS_RELOC (r_type)
13450               != (sym_type == STT_TLS
13451                   || (sym_type == STT_SECTION
13452                       && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13453         {
13454           if (tls_mask != 0
13455               && (r_type == R_PPC64_TLS
13456                   || r_type == R_PPC64_TLSGD
13457                   || r_type == R_PPC64_TLSLD))
13458             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
13459             ;
13460           else
13461             info->callbacks->einfo
13462               (!IS_PPC64_TLS_RELOC (r_type)
13463                ? _("%P: %H: %s used with TLS symbol `%T'\n")
13464                : _("%P: %H: %s used with non-TLS symbol `%T'\n"),
13465                input_bfd, input_section, rel->r_offset,
13466                ppc64_elf_howto_table[r_type]->name,
13467                sym_name);
13468         }
13469
13470       /* Ensure reloc mapping code below stays sane.  */
13471       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13472           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13473           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
13474           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13475           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13476           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13477           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
13478           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13479           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13480           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13481         abort ();
13482
13483       switch (r_type)
13484         {
13485         default:
13486           break;
13487
13488         case R_PPC64_LO_DS_OPT:
13489           insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13490           if ((insn & (0x3f << 26)) != 58u << 26)
13491             abort ();
13492           insn += (14u << 26) - (58u << 26);
13493           bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13494           r_type = R_PPC64_TOC16_LO;
13495           rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13496           break;
13497
13498         case R_PPC64_TOC16:
13499         case R_PPC64_TOC16_LO:
13500         case R_PPC64_TOC16_DS:
13501         case R_PPC64_TOC16_LO_DS:
13502           {
13503             /* Check for toc tls entries.  */
13504             unsigned char *toc_tls;
13505             int retval;
13506
13507             retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13508                                    &local_syms, rel, input_bfd);
13509             if (retval == 0)
13510               return FALSE;
13511
13512             if (toc_tls)
13513               {
13514                 tls_mask = *toc_tls;
13515                 if (r_type == R_PPC64_TOC16_DS
13516                     || r_type == R_PPC64_TOC16_LO_DS)
13517                   {
13518                     if (tls_mask != 0
13519                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13520                       goto toctprel;
13521                   }
13522                 else
13523                   {
13524                     /* If we found a GD reloc pair, then we might be
13525                        doing a GD->IE transition.  */
13526                     if (retval == 2)
13527                       {
13528                         tls_gd = TLS_TPRELGD;
13529                         if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13530                           goto tls_ldgd_opt;
13531                       }
13532                     else if (retval == 3)
13533                       {
13534                         if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13535                           goto tls_ldgd_opt;
13536                       }
13537                   }
13538               }
13539           }
13540           break;
13541
13542         case R_PPC64_GOT_TPREL16_HI:
13543         case R_PPC64_GOT_TPREL16_HA:
13544           if (tls_mask != 0
13545               && (tls_mask & TLS_TPREL) == 0)
13546             {
13547               rel->r_offset -= d_offset;
13548               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13549               r_type = R_PPC64_NONE;
13550               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13551             }
13552           break;
13553
13554         case R_PPC64_GOT_TPREL16_DS:
13555         case R_PPC64_GOT_TPREL16_LO_DS:
13556           if (tls_mask != 0
13557               && (tls_mask & TLS_TPREL) == 0)
13558             {
13559             toctprel:
13560               insn = bfd_get_32 (output_bfd,
13561                                  contents + rel->r_offset - d_offset);
13562               insn &= 31 << 21;
13563               insn |= 0x3c0d0000;       /* addis 0,13,0 */
13564               bfd_put_32 (output_bfd, insn,
13565                           contents + rel->r_offset - d_offset);
13566               r_type = R_PPC64_TPREL16_HA;
13567               if (toc_symndx != 0)
13568                 {
13569                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13570                   rel->r_addend = toc_addend;
13571                   /* We changed the symbol.  Start over in order to
13572                      get h, sym, sec etc. right.  */
13573                   goto again;
13574                 }
13575               else
13576                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13577             }
13578           break;
13579
13580         case R_PPC64_TLS:
13581           if (tls_mask != 0
13582               && (tls_mask & TLS_TPREL) == 0)
13583             {
13584               insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
13585               insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13586               if (insn == 0)
13587                 abort ();
13588               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13589               /* Was PPC64_TLS which sits on insn boundary, now
13590                  PPC64_TPREL16_LO which is at low-order half-word.  */
13591               rel->r_offset += d_offset;
13592               r_type = R_PPC64_TPREL16_LO;
13593               if (toc_symndx != 0)
13594                 {
13595                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13596                   rel->r_addend = toc_addend;
13597                   /* We changed the symbol.  Start over in order to
13598                      get h, sym, sec etc. right.  */
13599                   goto again;
13600                 }
13601               else
13602                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13603             }
13604           break;
13605
13606         case R_PPC64_GOT_TLSGD16_HI:
13607         case R_PPC64_GOT_TLSGD16_HA:
13608           tls_gd = TLS_TPRELGD;
13609           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13610             goto tls_gdld_hi;
13611           break;
13612
13613         case R_PPC64_GOT_TLSLD16_HI:
13614         case R_PPC64_GOT_TLSLD16_HA:
13615           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13616             {
13617             tls_gdld_hi:
13618               if ((tls_mask & tls_gd) != 0)
13619                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13620                           + R_PPC64_GOT_TPREL16_DS);
13621               else
13622                 {
13623                   rel->r_offset -= d_offset;
13624                   bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13625                   r_type = R_PPC64_NONE;
13626                 }
13627               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13628             }
13629           break;
13630
13631         case R_PPC64_GOT_TLSGD16:
13632         case R_PPC64_GOT_TLSGD16_LO:
13633           tls_gd = TLS_TPRELGD;
13634           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13635             goto tls_ldgd_opt;
13636           break;
13637
13638         case R_PPC64_GOT_TLSLD16:
13639         case R_PPC64_GOT_TLSLD16_LO:
13640           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13641             {
13642               unsigned int insn1, insn2, insn3;
13643               bfd_vma offset;
13644
13645             tls_ldgd_opt:
13646               offset = (bfd_vma) -1;
13647               /* If not using the newer R_PPC64_TLSGD/LD to mark
13648                  __tls_get_addr calls, we must trust that the call
13649                  stays with its arg setup insns, ie. that the next
13650                  reloc is the __tls_get_addr call associated with
13651                  the current reloc.  Edit both insns.  */
13652               if (input_section->has_tls_get_addr_call
13653                   && rel + 1 < relend
13654                   && branch_reloc_hash_match (input_bfd, rel + 1,
13655                                               htab->tls_get_addr,
13656                                               htab->tls_get_addr_fd))
13657                 offset = rel[1].r_offset;
13658               /* We read the low GOT_TLS (or TOC16) insn because we
13659                  need to keep the destination reg.  It may be
13660                  something other than the usual r3, and moved to r3
13661                  before the call by intervening code.  */
13662               insn1 = bfd_get_32 (output_bfd,
13663                                   contents + rel->r_offset - d_offset);
13664               if ((tls_mask & tls_gd) != 0)
13665                 {
13666                   /* IE */
13667                   insn1 &= (0x1f << 21) | (0x1f << 16);
13668                   insn1 |= 58 << 26;    /* ld */
13669                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13670                   if (offset != (bfd_vma) -1)
13671                     rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13672                   if ((tls_mask & TLS_EXPLICIT) == 0)
13673                     r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13674                               + R_PPC64_GOT_TPREL16_DS);
13675                   else
13676                     r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13677                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13678                 }
13679               else
13680                 {
13681                   /* LE */
13682                   insn1 &= 0x1f << 21;
13683                   insn1 |= 0x3c0d0000;  /* addis r,13,0 */
13684                   insn2 = 0x38630000;   /* addi 3,3,0 */
13685                   if (tls_gd == 0)
13686                     {
13687                       /* Was an LD reloc.  */
13688                       if (toc_symndx)
13689                         sec = local_sections[toc_symndx];
13690                       for (r_symndx = 0;
13691                            r_symndx < symtab_hdr->sh_info;
13692                            r_symndx++)
13693                         if (local_sections[r_symndx] == sec)
13694                           break;
13695                       if (r_symndx >= symtab_hdr->sh_info)
13696                         r_symndx = STN_UNDEF;
13697                       rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13698                       if (r_symndx != STN_UNDEF)
13699                         rel->r_addend -= (local_syms[r_symndx].st_value
13700                                           + sec->output_offset
13701                                           + sec->output_section->vma);
13702                     }
13703                   else if (toc_symndx != 0)
13704                     {
13705                       r_symndx = toc_symndx;
13706                       rel->r_addend = toc_addend;
13707                     }
13708                   r_type = R_PPC64_TPREL16_HA;
13709                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13710                   if (offset != (bfd_vma) -1)
13711                     {
13712                       rel[1].r_info = ELF64_R_INFO (r_symndx,
13713                                                     R_PPC64_TPREL16_LO);
13714                       rel[1].r_offset = offset + d_offset;
13715                       rel[1].r_addend = rel->r_addend;
13716                     }
13717                 }
13718               bfd_put_32 (output_bfd, insn1,
13719                           contents + rel->r_offset - d_offset);
13720               if (offset != (bfd_vma) -1)
13721                 {
13722                   insn3 = bfd_get_32 (output_bfd,
13723                                       contents + offset + 4);
13724                   if (insn3 == NOP
13725                       || insn3 == CROR_151515 || insn3 == CROR_313131)
13726                     {
13727                       rel[1].r_offset += 4;
13728                       bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13729                       insn2 = NOP;
13730                     }
13731                   bfd_put_32 (output_bfd, insn2, contents + offset);
13732                 }
13733               if ((tls_mask & tls_gd) == 0
13734                   && (tls_gd == 0 || toc_symndx != 0))
13735                 {
13736                   /* We changed the symbol.  Start over in order
13737                      to get h, sym, sec etc. right.  */
13738                   goto again;
13739                 }
13740             }
13741           break;
13742
13743         case R_PPC64_TLSGD:
13744           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13745             {
13746               unsigned int insn2, insn3;
13747               bfd_vma offset = rel->r_offset;
13748
13749               if ((tls_mask & TLS_TPRELGD) != 0)
13750                 {
13751                   /* IE */
13752                   r_type = R_PPC64_NONE;
13753                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13754                 }
13755               else
13756                 {
13757                   /* LE */
13758                   if (toc_symndx != 0)
13759                     {
13760                       r_symndx = toc_symndx;
13761                       rel->r_addend = toc_addend;
13762                     }
13763                   r_type = R_PPC64_TPREL16_LO;
13764                   rel->r_offset = offset + d_offset;
13765                   insn2 = 0x38630000;   /* addi 3,3,0 */
13766                 }
13767               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13768               /* Zap the reloc on the _tls_get_addr call too.  */
13769               BFD_ASSERT (offset == rel[1].r_offset);
13770               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13771               insn3 = bfd_get_32 (output_bfd,
13772                                   contents + offset + 4);
13773               if (insn3 == NOP
13774                   || insn3 == CROR_151515 || insn3 == CROR_313131)
13775                 {
13776                   rel->r_offset += 4;
13777                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13778                   insn2 = NOP;
13779                 }
13780               bfd_put_32 (output_bfd, insn2, contents + offset);
13781               if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
13782                 goto again;
13783             }
13784           break;
13785
13786         case R_PPC64_TLSLD:
13787           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13788             {
13789               unsigned int insn2, insn3;
13790               bfd_vma offset = rel->r_offset;
13791
13792               if (toc_symndx)
13793                 sec = local_sections[toc_symndx];
13794               for (r_symndx = 0;
13795                    r_symndx < symtab_hdr->sh_info;
13796                    r_symndx++)
13797                 if (local_sections[r_symndx] == sec)
13798                   break;
13799               if (r_symndx >= symtab_hdr->sh_info)
13800                 r_symndx = STN_UNDEF;
13801               rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13802               if (r_symndx != STN_UNDEF)
13803                 rel->r_addend -= (local_syms[r_symndx].st_value
13804                                   + sec->output_offset
13805                                   + sec->output_section->vma);
13806
13807               r_type = R_PPC64_TPREL16_LO;
13808               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13809               rel->r_offset = offset + d_offset;
13810               /* Zap the reloc on the _tls_get_addr call too.  */
13811               BFD_ASSERT (offset == rel[1].r_offset);
13812               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13813               insn2 = 0x38630000;       /* addi 3,3,0 */
13814               insn3 = bfd_get_32 (output_bfd,
13815                                   contents + offset + 4);
13816               if (insn3 == NOP
13817                   || insn3 == CROR_151515 || insn3 == CROR_313131)
13818                 {
13819                   rel->r_offset += 4;
13820                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13821                   insn2 = NOP;
13822                 }
13823               bfd_put_32 (output_bfd, insn2, contents + offset);
13824               goto again;
13825             }
13826           break;
13827
13828         case R_PPC64_DTPMOD64:
13829           if (rel + 1 < relend
13830               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
13831               && rel[1].r_offset == rel->r_offset + 8)
13832             {
13833               if ((tls_mask & TLS_GD) == 0)
13834                 {
13835                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
13836                   if ((tls_mask & TLS_TPRELGD) != 0)
13837                     r_type = R_PPC64_TPREL64;
13838                   else
13839                     {
13840                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13841                       r_type = R_PPC64_NONE;
13842                     }
13843                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13844                 }
13845             }
13846           else
13847             {
13848               if ((tls_mask & TLS_LD) == 0)
13849                 {
13850                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13851                   r_type = R_PPC64_NONE;
13852                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13853                 }
13854             }
13855           break;
13856
13857         case R_PPC64_TPREL64:
13858           if ((tls_mask & TLS_TPREL) == 0)
13859             {
13860               r_type = R_PPC64_NONE;
13861               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13862             }
13863           break;
13864
13865         case R_PPC64_ENTRY:
13866           relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
13867           if (!bfd_link_pic (info)
13868               && !info->traditional_format
13869               && relocation + 0x80008000 <= 0xffffffff)
13870             {
13871               unsigned int insn1, insn2;
13872
13873               insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
13874               insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
13875               if ((insn1 & ~0xfffc) == LD_R2_0R12
13876                   && insn2 == ADD_R2_R2_R12)
13877                 {
13878                   bfd_put_32 (output_bfd,
13879                               LIS_R2 + PPC_HA (relocation),
13880                               contents + rel->r_offset);
13881                   bfd_put_32 (output_bfd,
13882                               ADDI_R2_R2 + PPC_LO (relocation),
13883                               contents + rel->r_offset + 4);
13884                 }
13885             }
13886           else
13887             {
13888               relocation -= (rel->r_offset
13889                              + input_section->output_offset
13890                              + input_section->output_section->vma);
13891               if (relocation + 0x80008000 <= 0xffffffff)
13892                 {
13893                   unsigned int insn1, insn2;
13894
13895                   insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
13896                   insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
13897                   if ((insn1 & ~0xfffc) == LD_R2_0R12
13898                       && insn2 == ADD_R2_R2_R12)
13899                     {
13900                       bfd_put_32 (output_bfd,
13901                                   ADDIS_R2_R12 + PPC_HA (relocation),
13902                                   contents + rel->r_offset);
13903                       bfd_put_32 (output_bfd,
13904                                   ADDI_R2_R2 + PPC_LO (relocation),
13905                                   contents + rel->r_offset + 4);
13906                     }
13907                 }
13908             }
13909           break;
13910
13911         case R_PPC64_REL16_HA:
13912           /* If we are generating a non-PIC executable, edit
13913              .  0:      addis 2,12,.TOC.-0b@ha
13914              .          addi 2,2,.TOC.-0b@l
13915              used by ELFv2 global entry points to set up r2, to
13916              .          lis 2,.TOC.@ha
13917              .          addi 2,2,.TOC.@l
13918              if .TOC. is in range.  */
13919           if (!bfd_link_pic (info)
13920               && !info->traditional_format
13921               && !htab->opd_abi
13922               && rel->r_addend == d_offset
13923               && h != NULL && &h->elf == htab->elf.hgot
13924               && rel + 1 < relend
13925               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
13926               && rel[1].r_offset == rel->r_offset + 4
13927               && rel[1].r_addend == rel->r_addend + 4
13928               && relocation + 0x80008000 <= 0xffffffff)
13929             {
13930               unsigned int insn1, insn2;
13931               bfd_vma offset = rel->r_offset - d_offset;
13932               insn1 = bfd_get_32 (output_bfd, contents + offset);
13933               insn2 = bfd_get_32 (output_bfd, contents + offset + 4);
13934               if ((insn1 & 0xffff0000) == ADDIS_R2_R12
13935                   && (insn2 & 0xffff0000) == ADDI_R2_R2)
13936                 {
13937                   r_type = R_PPC64_ADDR16_HA;
13938                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13939                   rel->r_addend -= d_offset;
13940                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
13941                   rel[1].r_addend -= d_offset + 4;
13942                   bfd_put_32 (output_bfd, LIS_R2, contents + offset);
13943                 }
13944             }
13945           break;
13946         }
13947
13948       /* Handle other relocations that tweak non-addend part of insn.  */
13949       insn = 0;
13950       max_br_offset = 1 << 25;
13951       addend = rel->r_addend;
13952       reloc_dest = DEST_NORMAL;
13953       switch (r_type)
13954         {
13955         default:
13956           break;
13957
13958         case R_PPC64_TOCSAVE:
13959           if (relocation + addend == (rel->r_offset
13960                                       + input_section->output_offset
13961                                       + input_section->output_section->vma)
13962               && tocsave_find (htab, NO_INSERT,
13963                                &local_syms, rel, input_bfd))
13964             {
13965               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
13966               if (insn == NOP
13967                   || insn == CROR_151515 || insn == CROR_313131)
13968                 bfd_put_32 (input_bfd,
13969                             STD_R2_0R1 + STK_TOC (htab),
13970                             contents + rel->r_offset);
13971             }
13972           break;
13973
13974           /* Branch taken prediction relocations.  */
13975         case R_PPC64_ADDR14_BRTAKEN:
13976         case R_PPC64_REL14_BRTAKEN:
13977           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
13978           /* Fall thru.  */
13979
13980           /* Branch not taken prediction relocations.  */
13981         case R_PPC64_ADDR14_BRNTAKEN:
13982         case R_PPC64_REL14_BRNTAKEN:
13983           insn |= bfd_get_32 (output_bfd,
13984                               contents + rel->r_offset) & ~(0x01 << 21);
13985           /* Fall thru.  */
13986
13987         case R_PPC64_REL14:
13988           max_br_offset = 1 << 15;
13989           /* Fall thru.  */
13990
13991         case R_PPC64_REL24:
13992           /* Calls to functions with a different TOC, such as calls to
13993              shared objects, need to alter the TOC pointer.  This is
13994              done using a linkage stub.  A REL24 branching to these
13995              linkage stubs needs to be followed by a nop, as the nop
13996              will be replaced with an instruction to restore the TOC
13997              base pointer.  */
13998           fdh = h;
13999           if (h != NULL
14000               && h->oh != NULL
14001               && h->oh->is_func_descriptor)
14002             fdh = ppc_follow_link (h->oh);
14003           stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
14004                                            htab);
14005           if (stub_entry != NULL
14006               && (stub_entry->stub_type == ppc_stub_plt_call
14007                   || stub_entry->stub_type == ppc_stub_plt_call_r2save
14008                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
14009                   || stub_entry->stub_type == ppc_stub_long_branch_r2off))
14010             {
14011               bfd_boolean can_plt_call = FALSE;
14012
14013               /* All of these stubs will modify r2, so there must be a
14014                  branch and link followed by a nop.  The nop is
14015                  replaced by an insn to restore r2.  */
14016               if (rel->r_offset + 8 <= input_section->size)
14017                 {
14018                   unsigned long br;
14019
14020                   br = bfd_get_32 (input_bfd,
14021                                    contents + rel->r_offset);
14022                   if ((br & 1) != 0)
14023                     {
14024                       unsigned long nop;
14025
14026                       nop = bfd_get_32 (input_bfd,
14027                                         contents + rel->r_offset + 4);
14028                       if (nop == NOP
14029                           || nop == CROR_151515 || nop == CROR_313131)
14030                         {
14031                           if (h != NULL
14032                               && (h == htab->tls_get_addr_fd
14033                                   || h == htab->tls_get_addr)
14034                               && htab->params->tls_get_addr_opt)
14035                             {
14036                               /* Special stub used, leave nop alone.  */
14037                             }
14038                           else
14039                             bfd_put_32 (input_bfd,
14040                                         LD_R2_0R1 + STK_TOC (htab),
14041                                         contents + rel->r_offset + 4);
14042                           can_plt_call = TRUE;
14043                         }
14044                     }
14045                 }
14046
14047               if (!can_plt_call && h != NULL)
14048                 {
14049                   const char *name = h->elf.root.root.string;
14050
14051                   if (*name == '.')
14052                     ++name;
14053
14054                   if (strncmp (name, "__libc_start_main", 17) == 0
14055                       && (name[17] == 0 || name[17] == '@'))
14056                     {
14057                       /* Allow crt1 branch to go via a toc adjusting
14058                          stub.  Other calls that never return could do
14059                          the same, if we could detect such.  */
14060                       can_plt_call = TRUE;
14061                     }
14062                 }
14063
14064               if (!can_plt_call)
14065                 {
14066                   /* g++ as of 20130507 emits self-calls without a
14067                      following nop.  This is arguably wrong since we
14068                      have conflicting information.  On the one hand a
14069                      global symbol and on the other a local call
14070                      sequence, but don't error for this special case.
14071                      It isn't possible to cheaply verify we have
14072                      exactly such a call.  Allow all calls to the same
14073                      section.  */
14074                   asection *code_sec = sec;
14075
14076                   if (get_opd_info (sec) != NULL)
14077                     {
14078                       bfd_vma off = (relocation + addend
14079                                      - sec->output_section->vma
14080                                      - sec->output_offset);
14081
14082                       opd_entry_value (sec, off, &code_sec, NULL, FALSE);
14083                     }
14084                   if (code_sec == input_section)
14085                     can_plt_call = TRUE;
14086                 }
14087
14088               if (!can_plt_call)
14089                 {
14090                   if (stub_entry->stub_type == ppc_stub_plt_call
14091                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14092                     info->callbacks->einfo
14093                       (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
14094                          "recompile with -fPIC\n"),
14095                        input_bfd, input_section, rel->r_offset, sym_name);
14096                   else
14097                     info->callbacks->einfo
14098                       (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
14099                          "(-mcmodel=small toc adjust stub)\n"),
14100                        input_bfd, input_section, rel->r_offset, sym_name);
14101
14102                   bfd_set_error (bfd_error_bad_value);
14103                   ret = FALSE;
14104                 }
14105
14106               if (can_plt_call
14107                   && (stub_entry->stub_type == ppc_stub_plt_call
14108                       || stub_entry->stub_type == ppc_stub_plt_call_r2save))
14109                 unresolved_reloc = FALSE;
14110             }
14111
14112           if ((stub_entry == NULL
14113                || stub_entry->stub_type == ppc_stub_long_branch
14114                || stub_entry->stub_type == ppc_stub_plt_branch)
14115               && get_opd_info (sec) != NULL)
14116             {
14117               /* The branch destination is the value of the opd entry. */
14118               bfd_vma off = (relocation + addend
14119                              - sec->output_section->vma
14120                              - sec->output_offset);
14121               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
14122               if (dest != (bfd_vma) -1)
14123                 {
14124                   relocation = dest;
14125                   addend = 0;
14126                   reloc_dest = DEST_OPD;
14127                 }
14128             }
14129
14130           /* If the branch is out of reach we ought to have a long
14131              branch stub.  */
14132           from = (rel->r_offset
14133                   + input_section->output_offset
14134                   + input_section->output_section->vma);
14135
14136           relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
14137                                                   ? fdh->elf.other
14138                                                   : sym->st_other);
14139
14140           if (stub_entry != NULL
14141               && (stub_entry->stub_type == ppc_stub_long_branch
14142                   || stub_entry->stub_type == ppc_stub_plt_branch)
14143               && (r_type == R_PPC64_ADDR14_BRTAKEN
14144                   || r_type == R_PPC64_ADDR14_BRNTAKEN
14145                   || (relocation + addend - from + max_br_offset
14146                       < 2 * max_br_offset)))
14147             /* Don't use the stub if this branch is in range.  */
14148             stub_entry = NULL;
14149
14150           if (stub_entry != NULL)
14151             {
14152               /* Munge up the value and addend so that we call the stub
14153                  rather than the procedure directly.  */
14154               asection *stub_sec = stub_entry->group->stub_sec;
14155
14156               if (stub_entry->stub_type == ppc_stub_save_res)
14157                 relocation += (stub_sec->output_offset
14158                                + stub_sec->output_section->vma
14159                                + stub_sec->size - htab->sfpr->size
14160                                - htab->sfpr->output_offset
14161                                - htab->sfpr->output_section->vma);
14162               else
14163                 relocation = (stub_entry->stub_offset
14164                               + stub_sec->output_offset
14165                               + stub_sec->output_section->vma);
14166               addend = 0;
14167               reloc_dest = DEST_STUB;
14168
14169               if ((stub_entry->stub_type == ppc_stub_plt_call
14170                    || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14171                   && (ALWAYS_EMIT_R2SAVE
14172                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14173                   && rel + 1 < relend
14174                   && rel[1].r_offset == rel->r_offset + 4
14175                   && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
14176                 relocation += 4;
14177             }
14178
14179           if (insn != 0)
14180             {
14181               if (is_isa_v2)
14182                 {
14183                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
14184                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
14185                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
14186                   if ((insn & (0x14 << 21)) == (0x04 << 21))
14187                     insn |= 0x02 << 21;
14188                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
14189                     insn |= 0x08 << 21;
14190                   else
14191                     break;
14192                 }
14193               else
14194                 {
14195                   /* Invert 'y' bit if not the default.  */
14196                   if ((bfd_signed_vma) (relocation + addend - from) < 0)
14197                     insn ^= 0x01 << 21;
14198                 }
14199
14200               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
14201             }
14202
14203           /* NOP out calls to undefined weak functions.
14204              We can thus call a weak function without first
14205              checking whether the function is defined.  */
14206           else if (h != NULL
14207                    && h->elf.root.type == bfd_link_hash_undefweak
14208                    && h->elf.dynindx == -1
14209                    && r_type == R_PPC64_REL24
14210                    && relocation == 0
14211                    && addend == 0)
14212             {
14213               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
14214               goto copy_reloc;
14215             }
14216           break;
14217         }
14218
14219       /* Set `addend'.  */
14220       tls_type = 0;
14221       switch (r_type)
14222         {
14223         default:
14224           info->callbacks->einfo
14225             (_("%P: %B: unknown relocation type %d for `%T'\n"),
14226              input_bfd, (int) r_type, sym_name);
14227
14228           bfd_set_error (bfd_error_bad_value);
14229           ret = FALSE;
14230           goto copy_reloc;
14231
14232         case R_PPC64_NONE:
14233         case R_PPC64_TLS:
14234         case R_PPC64_TLSGD:
14235         case R_PPC64_TLSLD:
14236         case R_PPC64_TOCSAVE:
14237         case R_PPC64_GNU_VTINHERIT:
14238         case R_PPC64_GNU_VTENTRY:
14239         case R_PPC64_ENTRY:
14240           goto copy_reloc;
14241
14242           /* GOT16 relocations.  Like an ADDR16 using the symbol's
14243              address in the GOT as relocation value instead of the
14244              symbol's value itself.  Also, create a GOT entry for the
14245              symbol and put the symbol value there.  */
14246         case R_PPC64_GOT_TLSGD16:
14247         case R_PPC64_GOT_TLSGD16_LO:
14248         case R_PPC64_GOT_TLSGD16_HI:
14249         case R_PPC64_GOT_TLSGD16_HA:
14250           tls_type = TLS_TLS | TLS_GD;
14251           goto dogot;
14252
14253         case R_PPC64_GOT_TLSLD16:
14254         case R_PPC64_GOT_TLSLD16_LO:
14255         case R_PPC64_GOT_TLSLD16_HI:
14256         case R_PPC64_GOT_TLSLD16_HA:
14257           tls_type = TLS_TLS | TLS_LD;
14258           goto dogot;
14259
14260         case R_PPC64_GOT_TPREL16_DS:
14261         case R_PPC64_GOT_TPREL16_LO_DS:
14262         case R_PPC64_GOT_TPREL16_HI:
14263         case R_PPC64_GOT_TPREL16_HA:
14264           tls_type = TLS_TLS | TLS_TPREL;
14265           goto dogot;
14266
14267         case R_PPC64_GOT_DTPREL16_DS:
14268         case R_PPC64_GOT_DTPREL16_LO_DS:
14269         case R_PPC64_GOT_DTPREL16_HI:
14270         case R_PPC64_GOT_DTPREL16_HA:
14271           tls_type = TLS_TLS | TLS_DTPREL;
14272           goto dogot;
14273
14274         case R_PPC64_GOT16:
14275         case R_PPC64_GOT16_LO:
14276         case R_PPC64_GOT16_HI:
14277         case R_PPC64_GOT16_HA:
14278         case R_PPC64_GOT16_DS:
14279         case R_PPC64_GOT16_LO_DS:
14280         dogot:
14281           {
14282             /* Relocation is to the entry for this symbol in the global
14283                offset table.  */
14284             asection *got;
14285             bfd_vma *offp;
14286             bfd_vma off;
14287             unsigned long indx = 0;
14288             struct got_entry *ent;
14289
14290             if (tls_type == (TLS_TLS | TLS_LD)
14291                 && (h == NULL
14292                     || !h->elf.def_dynamic))
14293               ent = ppc64_tlsld_got (input_bfd);
14294             else
14295               {
14296
14297                 if (h != NULL)
14298                   {
14299                     bfd_boolean dyn = htab->elf.dynamic_sections_created;
14300                     if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info),
14301                                                           &h->elf)
14302                         || (bfd_link_pic (info)
14303                             && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
14304                       /* This is actually a static link, or it is a
14305                          -Bsymbolic link and the symbol is defined
14306                          locally, or the symbol was forced to be local
14307                          because of a version file.  */
14308                       ;
14309                     else
14310                       {
14311                         BFD_ASSERT (h->elf.dynindx != -1);
14312                         indx = h->elf.dynindx;
14313                         unresolved_reloc = FALSE;
14314                       }
14315                     ent = h->elf.got.glist;
14316                   }
14317                 else
14318                   {
14319                     if (local_got_ents == NULL)
14320                       abort ();
14321                     ent = local_got_ents[r_symndx];
14322                   }
14323
14324                 for (; ent != NULL; ent = ent->next)
14325                   if (ent->addend == orig_rel.r_addend
14326                       && ent->owner == input_bfd
14327                       && ent->tls_type == tls_type)
14328                     break;
14329               }
14330
14331             if (ent == NULL)
14332               abort ();
14333             if (ent->is_indirect)
14334               ent = ent->got.ent;
14335             offp = &ent->got.offset;
14336             got = ppc64_elf_tdata (ent->owner)->got;
14337             if (got == NULL)
14338               abort ();
14339
14340             /* The offset must always be a multiple of 8.  We use the
14341                least significant bit to record whether we have already
14342                processed this entry.  */
14343             off = *offp;
14344             if ((off & 1) != 0)
14345               off &= ~1;
14346             else
14347               {
14348                 /* Generate relocs for the dynamic linker, except in
14349                    the case of TLSLD where we'll use one entry per
14350                    module.  */
14351                 asection *relgot;
14352                 bfd_boolean ifunc;
14353
14354                 *offp = off | 1;
14355                 relgot = NULL;
14356                 ifunc = (h != NULL
14357                          ? h->elf.type == STT_GNU_IFUNC
14358                          : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
14359                 if (ifunc)
14360                   relgot = htab->elf.irelplt;
14361                 else if ((bfd_link_pic (info) || indx != 0)
14362                          && (h == NULL
14363                              || (tls_type == (TLS_TLS | TLS_LD)
14364                                  && !h->elf.def_dynamic)
14365                              || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14366                              || h->elf.root.type != bfd_link_hash_undefweak))
14367                   relgot = ppc64_elf_tdata (ent->owner)->relgot;
14368                 if (relgot != NULL)
14369                   {
14370                     outrel.r_offset = (got->output_section->vma
14371                                        + got->output_offset
14372                                        + off);
14373                     outrel.r_addend = addend;
14374                     if (tls_type & (TLS_LD | TLS_GD))
14375                       {
14376                         outrel.r_addend = 0;
14377                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
14378                         if (tls_type == (TLS_TLS | TLS_GD))
14379                           {
14380                             loc = relgot->contents;
14381                             loc += (relgot->reloc_count++
14382                                     * sizeof (Elf64_External_Rela));
14383                             bfd_elf64_swap_reloca_out (output_bfd,
14384                                                        &outrel, loc);
14385                             outrel.r_offset += 8;
14386                             outrel.r_addend = addend;
14387                             outrel.r_info
14388                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14389                           }
14390                       }
14391                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
14392                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14393                     else if (tls_type == (TLS_TLS | TLS_TPREL))
14394                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
14395                     else if (indx != 0)
14396                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
14397                     else
14398                       {
14399                         if (ifunc)
14400                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14401                         else
14402                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14403
14404                         /* Write the .got section contents for the sake
14405                            of prelink.  */
14406                         loc = got->contents + off;
14407                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
14408                                     loc);
14409                       }
14410
14411                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
14412                       {
14413                         outrel.r_addend += relocation;
14414                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
14415                           {
14416                             if (htab->elf.tls_sec == NULL)
14417                               outrel.r_addend = 0;
14418                             else
14419                               outrel.r_addend -= htab->elf.tls_sec->vma;
14420                           }
14421                       }
14422                     loc = relgot->contents;
14423                     loc += (relgot->reloc_count++
14424                             * sizeof (Elf64_External_Rela));
14425                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14426                   }
14427
14428                 /* Init the .got section contents here if we're not
14429                    emitting a reloc.  */
14430                 else
14431                   {
14432                     relocation += addend;
14433                     if (tls_type == (TLS_TLS | TLS_LD))
14434                       relocation = 1;
14435                     else if (tls_type != 0)
14436                       {
14437                         if (htab->elf.tls_sec == NULL)
14438                           relocation = 0;
14439                         else
14440                           {
14441                             relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
14442                             if (tls_type == (TLS_TLS | TLS_TPREL))
14443                               relocation += DTP_OFFSET - TP_OFFSET;
14444                           }
14445
14446                         if (tls_type == (TLS_TLS | TLS_GD))
14447                           {
14448                             bfd_put_64 (output_bfd, relocation,
14449                                         got->contents + off + 8);
14450                             relocation = 1;
14451                           }
14452                       }
14453
14454                     bfd_put_64 (output_bfd, relocation,
14455                                 got->contents + off);
14456                   }
14457               }
14458
14459             if (off >= (bfd_vma) -2)
14460               abort ();
14461
14462             relocation = got->output_section->vma + got->output_offset + off;
14463             addend = -(TOCstart + htab->sec_info[input_section->id].toc_off);
14464           }
14465           break;
14466
14467         case R_PPC64_PLT16_HA:
14468         case R_PPC64_PLT16_HI:
14469         case R_PPC64_PLT16_LO:
14470         case R_PPC64_PLT32:
14471         case R_PPC64_PLT64:
14472           /* Relocation is to the entry for this symbol in the
14473              procedure linkage table.  */
14474           {
14475             struct plt_entry **plt_list = NULL;
14476             if (h != NULL)
14477               plt_list = &h->elf.plt.plist;
14478             else if (local_got_ents != NULL)
14479               {
14480                 struct plt_entry **local_plt = (struct plt_entry **)
14481                   (local_got_ents + symtab_hdr->sh_info);
14482                 unsigned char *local_got_tls_masks = (unsigned char *)
14483                   (local_plt + symtab_hdr->sh_info);
14484                 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
14485                   plt_list = local_plt + r_symndx;
14486               }
14487             if (plt_list)
14488               {
14489                 struct plt_entry *ent;
14490
14491                 for (ent = *plt_list; ent != NULL; ent = ent->next)
14492                   if (ent->plt.offset != (bfd_vma) -1
14493                       && ent->addend == orig_rel.r_addend)
14494                     {
14495                       asection *plt;
14496
14497                       plt = htab->elf.splt;
14498                       if (!htab->elf.dynamic_sections_created
14499                           || h == NULL
14500                           || h->elf.dynindx == -1)
14501                         plt = htab->elf.iplt;
14502                       relocation = (plt->output_section->vma
14503                                     + plt->output_offset
14504                                     + ent->plt.offset);
14505                       addend = 0;
14506                       unresolved_reloc = FALSE;
14507                       break;
14508                     }
14509               }
14510           }
14511           break;
14512
14513         case R_PPC64_TOC:
14514           /* Relocation value is TOC base.  */
14515           relocation = TOCstart;
14516           if (r_symndx == STN_UNDEF)
14517             relocation += htab->sec_info[input_section->id].toc_off;
14518           else if (unresolved_reloc)
14519             ;
14520           else if (sec != NULL && sec->id < htab->sec_info_arr_size)
14521             relocation += htab->sec_info[sec->id].toc_off;
14522           else
14523             unresolved_reloc = TRUE;
14524           goto dodyn;
14525
14526           /* TOC16 relocs.  We want the offset relative to the TOC base,
14527              which is the address of the start of the TOC plus 0x8000.
14528              The TOC consists of sections .got, .toc, .tocbss, and .plt,
14529              in this order.  */
14530         case R_PPC64_TOC16:
14531         case R_PPC64_TOC16_LO:
14532         case R_PPC64_TOC16_HI:
14533         case R_PPC64_TOC16_DS:
14534         case R_PPC64_TOC16_LO_DS:
14535         case R_PPC64_TOC16_HA:
14536           addend -= TOCstart + htab->sec_info[input_section->id].toc_off;
14537           break;
14538
14539           /* Relocate against the beginning of the section.  */
14540         case R_PPC64_SECTOFF:
14541         case R_PPC64_SECTOFF_LO:
14542         case R_PPC64_SECTOFF_HI:
14543         case R_PPC64_SECTOFF_DS:
14544         case R_PPC64_SECTOFF_LO_DS:
14545         case R_PPC64_SECTOFF_HA:
14546           if (sec != NULL)
14547             addend -= sec->output_section->vma;
14548           break;
14549
14550         case R_PPC64_REL16:
14551         case R_PPC64_REL16_LO:
14552         case R_PPC64_REL16_HI:
14553         case R_PPC64_REL16_HA:
14554         case R_PPC64_REL16DX_HA:
14555           break;
14556
14557         case R_PPC64_REL14:
14558         case R_PPC64_REL14_BRNTAKEN:
14559         case R_PPC64_REL14_BRTAKEN:
14560         case R_PPC64_REL24:
14561           break;
14562
14563         case R_PPC64_TPREL16:
14564         case R_PPC64_TPREL16_LO:
14565         case R_PPC64_TPREL16_HI:
14566         case R_PPC64_TPREL16_HA:
14567         case R_PPC64_TPREL16_DS:
14568         case R_PPC64_TPREL16_LO_DS:
14569         case R_PPC64_TPREL16_HIGH:
14570         case R_PPC64_TPREL16_HIGHA:
14571         case R_PPC64_TPREL16_HIGHER:
14572         case R_PPC64_TPREL16_HIGHERA:
14573         case R_PPC64_TPREL16_HIGHEST:
14574         case R_PPC64_TPREL16_HIGHESTA:
14575           if (h != NULL
14576               && h->elf.root.type == bfd_link_hash_undefweak
14577               && h->elf.dynindx == -1)
14578             {
14579               /* Make this relocation against an undefined weak symbol
14580                  resolve to zero.  This is really just a tweak, since
14581                  code using weak externs ought to check that they are
14582                  defined before using them.  */
14583               bfd_byte *p = contents + rel->r_offset - d_offset;
14584
14585               insn = bfd_get_32 (output_bfd, p);
14586               insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14587               if (insn != 0)
14588                 bfd_put_32 (output_bfd, insn, p);
14589               break;
14590             }
14591           if (htab->elf.tls_sec != NULL)
14592             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14593           if (bfd_link_pic (info))
14594             /* The TPREL16 relocs shouldn't really be used in shared
14595                libs as they will result in DT_TEXTREL being set, but
14596                support them anyway.  */
14597             goto dodyn;
14598           break;
14599
14600         case R_PPC64_DTPREL16:
14601         case R_PPC64_DTPREL16_LO:
14602         case R_PPC64_DTPREL16_HI:
14603         case R_PPC64_DTPREL16_HA:
14604         case R_PPC64_DTPREL16_DS:
14605         case R_PPC64_DTPREL16_LO_DS:
14606         case R_PPC64_DTPREL16_HIGH:
14607         case R_PPC64_DTPREL16_HIGHA:
14608         case R_PPC64_DTPREL16_HIGHER:
14609         case R_PPC64_DTPREL16_HIGHERA:
14610         case R_PPC64_DTPREL16_HIGHEST:
14611         case R_PPC64_DTPREL16_HIGHESTA:
14612           if (htab->elf.tls_sec != NULL)
14613             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14614           break;
14615
14616         case R_PPC64_ADDR64_LOCAL:
14617           addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
14618                                               ? h->elf.other
14619                                               : sym->st_other);
14620           break;
14621
14622         case R_PPC64_DTPMOD64:
14623           relocation = 1;
14624           addend = 0;
14625           goto dodyn;
14626
14627         case R_PPC64_TPREL64:
14628           if (htab->elf.tls_sec != NULL)
14629             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14630           goto dodyn;
14631
14632         case R_PPC64_DTPREL64:
14633           if (htab->elf.tls_sec != NULL)
14634             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14635           /* Fall thru */
14636
14637           /* Relocations that may need to be propagated if this is a
14638              dynamic object.  */
14639         case R_PPC64_REL30:
14640         case R_PPC64_REL32:
14641         case R_PPC64_REL64:
14642         case R_PPC64_ADDR14:
14643         case R_PPC64_ADDR14_BRNTAKEN:
14644         case R_PPC64_ADDR14_BRTAKEN:
14645         case R_PPC64_ADDR16:
14646         case R_PPC64_ADDR16_DS:
14647         case R_PPC64_ADDR16_HA:
14648         case R_PPC64_ADDR16_HI:
14649         case R_PPC64_ADDR16_HIGH:
14650         case R_PPC64_ADDR16_HIGHA:
14651         case R_PPC64_ADDR16_HIGHER:
14652         case R_PPC64_ADDR16_HIGHERA:
14653         case R_PPC64_ADDR16_HIGHEST:
14654         case R_PPC64_ADDR16_HIGHESTA:
14655         case R_PPC64_ADDR16_LO:
14656         case R_PPC64_ADDR16_LO_DS:
14657         case R_PPC64_ADDR24:
14658         case R_PPC64_ADDR32:
14659         case R_PPC64_ADDR64:
14660         case R_PPC64_UADDR16:
14661         case R_PPC64_UADDR32:
14662         case R_PPC64_UADDR64:
14663         dodyn:
14664           if ((input_section->flags & SEC_ALLOC) == 0)
14665             break;
14666
14667           if (NO_OPD_RELOCS && is_opd)
14668             break;
14669
14670           if ((bfd_link_pic (info)
14671                && (h == NULL
14672                    || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14673                    || h->elf.root.type != bfd_link_hash_undefweak)
14674                && (must_be_dyn_reloc (info, r_type)
14675                    || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
14676               || (ELIMINATE_COPY_RELOCS
14677                   && !bfd_link_pic (info)
14678                   && h != NULL
14679                   && h->elf.dynindx != -1
14680                   && !h->elf.non_got_ref
14681                   && !h->elf.def_regular)
14682               || (!bfd_link_pic (info)
14683                   && (h != NULL
14684                       ? h->elf.type == STT_GNU_IFUNC
14685                       : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)))
14686             {
14687               bfd_boolean skip, relocate;
14688               asection *sreloc;
14689               bfd_vma out_off;
14690
14691               /* When generating a dynamic object, these relocations
14692                  are copied into the output file to be resolved at run
14693                  time.  */
14694
14695               skip = FALSE;
14696               relocate = FALSE;
14697
14698               out_off = _bfd_elf_section_offset (output_bfd, info,
14699                                                  input_section, rel->r_offset);
14700               if (out_off == (bfd_vma) -1)
14701                 skip = TRUE;
14702               else if (out_off == (bfd_vma) -2)
14703                 skip = TRUE, relocate = TRUE;
14704               out_off += (input_section->output_section->vma
14705                           + input_section->output_offset);
14706               outrel.r_offset = out_off;
14707               outrel.r_addend = rel->r_addend;
14708
14709               /* Optimize unaligned reloc use.  */
14710               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14711                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14712                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14713               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14714                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
14715                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
14716               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
14717                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
14718                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
14719
14720               if (skip)
14721                 memset (&outrel, 0, sizeof outrel);
14722               else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14723                        && !is_opd
14724                        && r_type != R_PPC64_TOC)
14725                 {
14726                   BFD_ASSERT (h->elf.dynindx != -1);
14727                   outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
14728                 }
14729               else
14730                 {
14731                   /* This symbol is local, or marked to become local,
14732                      or this is an opd section reloc which must point
14733                      at a local function.  */
14734                   outrel.r_addend += relocation;
14735                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
14736                     {
14737                       if (is_opd && h != NULL)
14738                         {
14739                           /* Lie about opd entries.  This case occurs
14740                              when building shared libraries and we
14741                              reference a function in another shared
14742                              lib.  The same thing happens for a weak
14743                              definition in an application that's
14744                              overridden by a strong definition in a
14745                              shared lib.  (I believe this is a generic
14746                              bug in binutils handling of weak syms.)
14747                              In these cases we won't use the opd
14748                              entry in this lib.  */
14749                           unresolved_reloc = FALSE;
14750                         }
14751                       if (!is_opd
14752                           && r_type == R_PPC64_ADDR64
14753                           && (h != NULL
14754                               ? h->elf.type == STT_GNU_IFUNC
14755                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14756                         outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14757                       else
14758                         {
14759                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14760
14761                           /* We need to relocate .opd contents for ld.so.
14762                              Prelink also wants simple and consistent rules
14763                              for relocs.  This make all RELATIVE relocs have
14764                              *r_offset equal to r_addend.  */
14765                           relocate = TRUE;
14766                         }
14767                     }
14768                   else
14769                     {
14770                       long indx = 0;
14771
14772                       if (h != NULL
14773                           ? h->elf.type == STT_GNU_IFUNC
14774                           : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14775                         {
14776                           info->callbacks->einfo
14777                             (_("%P: %H: %s for indirect "
14778                                "function `%T' unsupported\n"),
14779                              input_bfd, input_section, rel->r_offset,
14780                              ppc64_elf_howto_table[r_type]->name,
14781                              sym_name);
14782                           ret = FALSE;
14783                         }
14784                       else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
14785                         ;
14786                       else if (sec == NULL || sec->owner == NULL)
14787                         {
14788                           bfd_set_error (bfd_error_bad_value);
14789                           return FALSE;
14790                         }
14791                       else
14792                         {
14793                           asection *osec;
14794
14795                           osec = sec->output_section;
14796                           indx = elf_section_data (osec)->dynindx;
14797
14798                           if (indx == 0)
14799                             {
14800                               if ((osec->flags & SEC_READONLY) == 0
14801                                   && htab->elf.data_index_section != NULL)
14802                                 osec = htab->elf.data_index_section;
14803                               else
14804                                 osec = htab->elf.text_index_section;
14805                               indx = elf_section_data (osec)->dynindx;
14806                             }
14807                           BFD_ASSERT (indx != 0);
14808
14809                           /* We are turning this relocation into one
14810                              against a section symbol, so subtract out
14811                              the output section's address but not the
14812                              offset of the input section in the output
14813                              section.  */
14814                           outrel.r_addend -= osec->vma;
14815                         }
14816
14817                       outrel.r_info = ELF64_R_INFO (indx, r_type);
14818                     }
14819                 }
14820
14821               sreloc = elf_section_data (input_section)->sreloc;
14822               if (h != NULL
14823                   ? h->elf.type == STT_GNU_IFUNC
14824                   : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14825                 sreloc = htab->elf.irelplt;
14826               if (sreloc == NULL)
14827                 abort ();
14828
14829               if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
14830                   >= sreloc->size)
14831                 abort ();
14832               loc = sreloc->contents;
14833               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
14834               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14835
14836               /* If this reloc is against an external symbol, it will
14837                  be computed at runtime, so there's no need to do
14838                  anything now.  However, for the sake of prelink ensure
14839                  that the section contents are a known value.  */
14840               if (! relocate)
14841                 {
14842                   unresolved_reloc = FALSE;
14843                   /* The value chosen here is quite arbitrary as ld.so
14844                      ignores section contents except for the special
14845                      case of .opd where the contents might be accessed
14846                      before relocation.  Choose zero, as that won't
14847                      cause reloc overflow.  */
14848                   relocation = 0;
14849                   addend = 0;
14850                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
14851                      to improve backward compatibility with older
14852                      versions of ld.  */
14853                   if (r_type == R_PPC64_ADDR64)
14854                     addend = outrel.r_addend;
14855                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
14856                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
14857                     addend = (input_section->output_section->vma
14858                               + input_section->output_offset
14859                               + rel->r_offset);
14860                 }
14861             }
14862           break;
14863
14864         case R_PPC64_COPY:
14865         case R_PPC64_GLOB_DAT:
14866         case R_PPC64_JMP_SLOT:
14867         case R_PPC64_JMP_IREL:
14868         case R_PPC64_RELATIVE:
14869           /* We shouldn't ever see these dynamic relocs in relocatable
14870              files.  */
14871           /* Fall through.  */
14872
14873         case R_PPC64_PLTGOT16:
14874         case R_PPC64_PLTGOT16_DS:
14875         case R_PPC64_PLTGOT16_HA:
14876         case R_PPC64_PLTGOT16_HI:
14877         case R_PPC64_PLTGOT16_LO:
14878         case R_PPC64_PLTGOT16_LO_DS:
14879         case R_PPC64_PLTREL32:
14880         case R_PPC64_PLTREL64:
14881           /* These ones haven't been implemented yet.  */
14882
14883           info->callbacks->einfo
14884             (_("%P: %B: %s is not supported for `%T'\n"),
14885              input_bfd,
14886              ppc64_elf_howto_table[r_type]->name, sym_name);
14887
14888           bfd_set_error (bfd_error_invalid_operation);
14889           ret = FALSE;
14890           goto copy_reloc;
14891         }
14892
14893       /* Multi-instruction sequences that access the TOC can be
14894          optimized, eg. addis ra,r2,0; addi rb,ra,x;
14895          to             nop;           addi rb,r2,x;  */
14896       switch (r_type)
14897         {
14898         default:
14899           break;
14900
14901         case R_PPC64_GOT_TLSLD16_HI:
14902         case R_PPC64_GOT_TLSGD16_HI:
14903         case R_PPC64_GOT_TPREL16_HI:
14904         case R_PPC64_GOT_DTPREL16_HI:
14905         case R_PPC64_GOT16_HI:
14906         case R_PPC64_TOC16_HI:
14907           /* These relocs would only be useful if building up an
14908              offset to later add to r2, perhaps in an indexed
14909              addressing mode instruction.  Don't try to optimize.
14910              Unfortunately, the possibility of someone building up an
14911              offset like this or even with the HA relocs, means that
14912              we need to check the high insn when optimizing the low
14913              insn.  */
14914           break;
14915
14916         case R_PPC64_GOT_TLSLD16_HA:
14917         case R_PPC64_GOT_TLSGD16_HA:
14918         case R_PPC64_GOT_TPREL16_HA:
14919         case R_PPC64_GOT_DTPREL16_HA:
14920         case R_PPC64_GOT16_HA:
14921         case R_PPC64_TOC16_HA:
14922           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14923               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14924             {
14925               bfd_byte *p = contents + (rel->r_offset & ~3);
14926               bfd_put_32 (input_bfd, NOP, p);
14927             }
14928           break;
14929
14930         case R_PPC64_GOT_TLSLD16_LO:
14931         case R_PPC64_GOT_TLSGD16_LO:
14932         case R_PPC64_GOT_TPREL16_LO_DS:
14933         case R_PPC64_GOT_DTPREL16_LO_DS:
14934         case R_PPC64_GOT16_LO:
14935         case R_PPC64_GOT16_LO_DS:
14936         case R_PPC64_TOC16_LO:
14937         case R_PPC64_TOC16_LO_DS:
14938           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14939               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14940             {
14941               bfd_byte *p = contents + (rel->r_offset & ~3);
14942               insn = bfd_get_32 (input_bfd, p);
14943               if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
14944                 {
14945                   /* Transform addic to addi when we change reg.  */
14946                   insn &= ~((0x3f << 26) | (0x1f << 16));
14947                   insn |= (14u << 26) | (2 << 16);
14948                 }
14949               else
14950                 {
14951                   insn &= ~(0x1f << 16);
14952                   insn |= 2 << 16;
14953                 }
14954               bfd_put_32 (input_bfd, insn, p);
14955             }
14956           break;
14957         }
14958
14959       /* Do any further special processing.  */
14960       howto = ppc64_elf_howto_table[(int) r_type];
14961       switch (r_type)
14962         {
14963         default:
14964           break;
14965
14966         case R_PPC64_REL16_HA:
14967         case R_PPC64_REL16DX_HA:
14968         case R_PPC64_ADDR16_HA:
14969         case R_PPC64_ADDR16_HIGHA:
14970         case R_PPC64_ADDR16_HIGHERA:
14971         case R_PPC64_ADDR16_HIGHESTA:
14972         case R_PPC64_TOC16_HA:
14973         case R_PPC64_SECTOFF_HA:
14974         case R_PPC64_TPREL16_HA:
14975         case R_PPC64_TPREL16_HIGHA:
14976         case R_PPC64_TPREL16_HIGHERA:
14977         case R_PPC64_TPREL16_HIGHESTA:
14978         case R_PPC64_DTPREL16_HA:
14979         case R_PPC64_DTPREL16_HIGHA:
14980         case R_PPC64_DTPREL16_HIGHERA:
14981         case R_PPC64_DTPREL16_HIGHESTA:
14982           /* It's just possible that this symbol is a weak symbol
14983              that's not actually defined anywhere. In that case,
14984              'sec' would be NULL, and we should leave the symbol
14985              alone (it will be set to zero elsewhere in the link).  */
14986           if (sec == NULL)
14987             break;
14988           /* Fall thru */
14989
14990         case R_PPC64_GOT16_HA:
14991         case R_PPC64_PLTGOT16_HA:
14992         case R_PPC64_PLT16_HA:
14993         case R_PPC64_GOT_TLSGD16_HA:
14994         case R_PPC64_GOT_TLSLD16_HA:
14995         case R_PPC64_GOT_TPREL16_HA:
14996         case R_PPC64_GOT_DTPREL16_HA:
14997           /* Add 0x10000 if sign bit in 0:15 is set.
14998              Bits 0:15 are not used.  */
14999           addend += 0x8000;
15000           break;
15001
15002         case R_PPC64_ADDR16_DS:
15003         case R_PPC64_ADDR16_LO_DS:
15004         case R_PPC64_GOT16_DS:
15005         case R_PPC64_GOT16_LO_DS:
15006         case R_PPC64_PLT16_LO_DS:
15007         case R_PPC64_SECTOFF_DS:
15008         case R_PPC64_SECTOFF_LO_DS:
15009         case R_PPC64_TOC16_DS:
15010         case R_PPC64_TOC16_LO_DS:
15011         case R_PPC64_PLTGOT16_DS:
15012         case R_PPC64_PLTGOT16_LO_DS:
15013         case R_PPC64_GOT_TPREL16_DS:
15014         case R_PPC64_GOT_TPREL16_LO_DS:
15015         case R_PPC64_GOT_DTPREL16_DS:
15016         case R_PPC64_GOT_DTPREL16_LO_DS:
15017         case R_PPC64_TPREL16_DS:
15018         case R_PPC64_TPREL16_LO_DS:
15019         case R_PPC64_DTPREL16_DS:
15020         case R_PPC64_DTPREL16_LO_DS:
15021           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15022           mask = 3;
15023           /* If this reloc is against an lq, lxv, or stxv insn, then
15024              the value must be a multiple of 16.  This is somewhat of
15025              a hack, but the "correct" way to do this by defining _DQ
15026              forms of all the _DS relocs bloats all reloc switches in
15027              this file.  It doesn't make much sense to use these
15028              relocs in data, so testing the insn should be safe.  */
15029           if ((insn & (0x3f << 26)) == (56u << 26)
15030               || ((insn & (0x3f << 26)) == (61u << 26) && (insn & 3) == 1))
15031             mask = 15;
15032           relocation += addend;
15033           addend = insn & (mask ^ 3);
15034           if ((relocation & mask) != 0)
15035             {
15036               relocation ^= relocation & mask;
15037               info->callbacks->einfo
15038                 (_("%P: %H: error: %s not a multiple of %u\n"),
15039                  input_bfd, input_section, rel->r_offset,
15040                  howto->name,
15041                  mask + 1);
15042               bfd_set_error (bfd_error_bad_value);
15043               ret = FALSE;
15044               goto copy_reloc;
15045             }
15046           break;
15047         }
15048
15049       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
15050          because such sections are not SEC_ALLOC and thus ld.so will
15051          not process them.  */
15052       if (unresolved_reloc
15053           && !((input_section->flags & SEC_DEBUGGING) != 0
15054                && h->elf.def_dynamic)
15055           && _bfd_elf_section_offset (output_bfd, info, input_section,
15056                                       rel->r_offset) != (bfd_vma) -1)
15057         {
15058           info->callbacks->einfo
15059             (_("%P: %H: unresolvable %s against `%T'\n"),
15060              input_bfd, input_section, rel->r_offset,
15061              howto->name,
15062              h->elf.root.root.string);
15063           ret = FALSE;
15064         }
15065
15066       /* 16-bit fields in insns mostly have signed values, but a
15067          few insns have 16-bit unsigned values.  Really, we should
15068          have different reloc types.  */
15069       if (howto->complain_on_overflow != complain_overflow_dont
15070           && howto->dst_mask == 0xffff
15071           && (input_section->flags & SEC_CODE) != 0)
15072         {
15073           enum complain_overflow complain = complain_overflow_signed;
15074
15075           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15076           if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
15077             complain = complain_overflow_bitfield;
15078           else if (howto->rightshift == 0
15079                    ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
15080                       || (insn & (0x3f << 26)) == 24u << 26 /* ori */
15081                       || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
15082                    : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
15083                       || (insn & (0x3f << 26)) == 25u << 26 /* oris */
15084                       || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
15085             complain = complain_overflow_unsigned;
15086           if (howto->complain_on_overflow != complain)
15087             {
15088               alt_howto = *howto;
15089               alt_howto.complain_on_overflow = complain;
15090               howto = &alt_howto;
15091             }
15092         }
15093
15094       if (r_type == R_PPC64_REL16DX_HA)
15095         {
15096           /* Split field reloc isn't handled by _bfd_final_link_relocate.  */
15097           if (rel->r_offset + 4 > input_section->size)
15098             r = bfd_reloc_outofrange;
15099           else
15100             {
15101               relocation += addend;
15102               relocation -= (rel->r_offset
15103                              + input_section->output_offset
15104                              + input_section->output_section->vma);
15105               relocation = (bfd_signed_vma) relocation >> 16;
15106               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
15107               insn &= ~0x1fffc1;
15108               insn |= (relocation & 0xffc1) | ((relocation & 0x3e) << 15);
15109               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
15110               r = bfd_reloc_ok;
15111               if (relocation + 0x8000 > 0xffff)
15112                 r = bfd_reloc_overflow;
15113             }
15114         }
15115       else
15116         r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
15117                                       rel->r_offset, relocation, addend);
15118
15119       if (r != bfd_reloc_ok)
15120         {
15121           char *more_info = NULL;
15122           const char *reloc_name = howto->name;
15123
15124           if (reloc_dest != DEST_NORMAL)
15125             {
15126               more_info = bfd_malloc (strlen (reloc_name) + 8);
15127               if (more_info != NULL)
15128                 {
15129                   strcpy (more_info, reloc_name);
15130                   strcat (more_info, (reloc_dest == DEST_OPD
15131                                       ? " (OPD)" : " (stub)"));
15132                   reloc_name = more_info;
15133                 }
15134             }
15135
15136           if (r == bfd_reloc_overflow)
15137             {
15138               /* On code like "if (foo) foo();" don't report overflow
15139                  on a branch to zero when foo is undefined.  */
15140               if (!warned
15141                   && (reloc_dest == DEST_STUB
15142                       || !(h != NULL
15143                            && (h->elf.root.type == bfd_link_hash_undefweak
15144                                || h->elf.root.type == bfd_link_hash_undefined)
15145                            && is_branch_reloc (r_type))))
15146                 {
15147                   if (!((*info->callbacks->reloc_overflow)
15148                         (info, &h->elf.root, sym_name,
15149                          reloc_name, orig_rel.r_addend,
15150                          input_bfd, input_section, rel->r_offset)))
15151                     return FALSE;
15152                 }
15153             }
15154           else
15155             {
15156               info->callbacks->einfo
15157                 (_("%P: %H: %s against `%T': error %d\n"),
15158                  input_bfd, input_section, rel->r_offset,
15159                  reloc_name, sym_name, (int) r);
15160               ret = FALSE;
15161             }
15162           if (more_info != NULL)
15163             free (more_info);
15164         }
15165     copy_reloc:
15166       if (wrel != rel)
15167         *wrel = *rel;
15168     }
15169
15170   if (wrel != rel)
15171     {
15172       Elf_Internal_Shdr *rel_hdr;
15173       size_t deleted = rel - wrel;
15174
15175       rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
15176       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15177       if (rel_hdr->sh_size == 0)
15178         {
15179           /* It is too late to remove an empty reloc section.  Leave
15180              one NONE reloc.
15181              ??? What is wrong with an empty section???  */
15182           rel_hdr->sh_size = rel_hdr->sh_entsize;
15183           deleted -= 1;
15184         }
15185       rel_hdr = _bfd_elf_single_rel_hdr (input_section);
15186       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15187       input_section->reloc_count -= deleted;
15188     }
15189
15190   /* If we're emitting relocations, then shortly after this function
15191      returns, reloc offsets and addends for this section will be
15192      adjusted.  Worse, reloc symbol indices will be for the output
15193      file rather than the input.  Save a copy of the relocs for
15194      opd_entry_value.  */
15195   if (is_opd && (info->emitrelocations || bfd_link_relocatable (info)))
15196     {
15197       bfd_size_type amt;
15198       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
15199       rel = bfd_alloc (input_bfd, amt);
15200       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
15201       ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
15202       if (rel == NULL)
15203         return FALSE;
15204       memcpy (rel, relocs, amt);
15205     }
15206   return ret;
15207 }
15208
15209 /* Adjust the value of any local symbols in opd sections.  */
15210
15211 static int
15212 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
15213                               const char *name ATTRIBUTE_UNUSED,
15214                               Elf_Internal_Sym *elfsym,
15215                               asection *input_sec,
15216                               struct elf_link_hash_entry *h)
15217 {
15218   struct _opd_sec_data *opd;
15219   long adjust;
15220   bfd_vma value;
15221
15222   if (h != NULL)
15223     return 1;
15224
15225   opd = get_opd_info (input_sec);
15226   if (opd == NULL || opd->adjust == NULL)
15227     return 1;
15228
15229   value = elfsym->st_value - input_sec->output_offset;
15230   if (!bfd_link_relocatable (info))
15231     value -= input_sec->output_section->vma;
15232
15233   adjust = opd->adjust[OPD_NDX (value)];
15234   if (adjust == -1)
15235     return 2;
15236
15237   elfsym->st_value += adjust;
15238   return 1;
15239 }
15240
15241 /* Finish up dynamic symbol handling.  We set the contents of various
15242    dynamic sections here.  */
15243
15244 static bfd_boolean
15245 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
15246                                  struct bfd_link_info *info,
15247                                  struct elf_link_hash_entry *h,
15248                                  Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
15249 {
15250   struct ppc_link_hash_table *htab;
15251   struct plt_entry *ent;
15252   Elf_Internal_Rela rela;
15253   bfd_byte *loc;
15254
15255   htab = ppc_hash_table (info);
15256   if (htab == NULL)
15257     return FALSE;
15258
15259   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
15260     if (ent->plt.offset != (bfd_vma) -1)
15261       {
15262         /* This symbol has an entry in the procedure linkage
15263            table.  Set it up.  */
15264         if (!htab->elf.dynamic_sections_created
15265             || h->dynindx == -1)
15266           {
15267             BFD_ASSERT (h->type == STT_GNU_IFUNC
15268                         && h->def_regular
15269                         && (h->root.type == bfd_link_hash_defined
15270                             || h->root.type == bfd_link_hash_defweak));
15271             rela.r_offset = (htab->elf.iplt->output_section->vma
15272                              + htab->elf.iplt->output_offset
15273                              + ent->plt.offset);
15274             if (htab->opd_abi)
15275               rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
15276             else
15277               rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15278             rela.r_addend = (h->root.u.def.value
15279                              + h->root.u.def.section->output_offset
15280                              + h->root.u.def.section->output_section->vma
15281                              + ent->addend);
15282             loc = (htab->elf.irelplt->contents
15283                    + (htab->elf.irelplt->reloc_count++
15284                       * sizeof (Elf64_External_Rela)));
15285           }
15286         else
15287           {
15288             rela.r_offset = (htab->elf.splt->output_section->vma
15289                              + htab->elf.splt->output_offset
15290                              + ent->plt.offset);
15291             rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
15292             rela.r_addend = ent->addend;
15293             loc = (htab->elf.srelplt->contents
15294                    + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
15295                       / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
15296           }
15297         bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15298
15299         if (!htab->opd_abi)
15300           {
15301             if (!h->def_regular)
15302               {
15303                 /* Mark the symbol as undefined, rather than as
15304                    defined in glink.  Leave the value if there were
15305                    any relocations where pointer equality matters
15306                    (this is a clue for the dynamic linker, to make
15307                    function pointer comparisons work between an
15308                    application and shared library), otherwise set it
15309                    to zero.  */
15310                 sym->st_shndx = SHN_UNDEF;
15311                 if (!h->pointer_equality_needed)
15312                   sym->st_value = 0;
15313                 else if (!h->ref_regular_nonweak)
15314                   {
15315                     /* This breaks function pointer comparisons, but
15316                        that is better than breaking tests for a NULL
15317                        function pointer.  */
15318                     sym->st_value = 0;
15319                   }
15320               }
15321           }
15322       }
15323
15324   if (h->needs_copy)
15325     {
15326       /* This symbol needs a copy reloc.  Set it up.  */
15327
15328       if (h->dynindx == -1
15329           || (h->root.type != bfd_link_hash_defined
15330               && h->root.type != bfd_link_hash_defweak)
15331           || htab->relbss == NULL)
15332         abort ();
15333
15334       rela.r_offset = (h->root.u.def.value
15335                        + h->root.u.def.section->output_section->vma
15336                        + h->root.u.def.section->output_offset);
15337       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
15338       rela.r_addend = 0;
15339       loc = htab->relbss->contents;
15340       loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
15341       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15342     }
15343
15344   return TRUE;
15345 }
15346
15347 /* Used to decide how to sort relocs in an optimal manner for the
15348    dynamic linker, before writing them out.  */
15349
15350 static enum elf_reloc_type_class
15351 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
15352                             const asection *rel_sec,
15353                             const Elf_Internal_Rela *rela)
15354 {
15355   enum elf_ppc64_reloc_type r_type;
15356   struct ppc_link_hash_table *htab = ppc_hash_table (info);
15357
15358   if (rel_sec == htab->elf.irelplt)
15359     return reloc_class_ifunc;
15360
15361   r_type = ELF64_R_TYPE (rela->r_info);
15362   switch (r_type)
15363     {
15364     case R_PPC64_RELATIVE:
15365       return reloc_class_relative;
15366     case R_PPC64_JMP_SLOT:
15367       return reloc_class_plt;
15368     case R_PPC64_COPY:
15369       return reloc_class_copy;
15370     default:
15371       return reloc_class_normal;
15372     }
15373 }
15374
15375 /* Finish up the dynamic sections.  */
15376
15377 static bfd_boolean
15378 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
15379                                    struct bfd_link_info *info)
15380 {
15381   struct ppc_link_hash_table *htab;
15382   bfd *dynobj;
15383   asection *sdyn;
15384
15385   htab = ppc_hash_table (info);
15386   if (htab == NULL)
15387     return FALSE;
15388
15389   dynobj = htab->elf.dynobj;
15390   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
15391
15392   if (htab->elf.dynamic_sections_created)
15393     {
15394       Elf64_External_Dyn *dyncon, *dynconend;
15395
15396       if (sdyn == NULL || htab->elf.sgot == NULL)
15397         abort ();
15398
15399       dyncon = (Elf64_External_Dyn *) sdyn->contents;
15400       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
15401       for (; dyncon < dynconend; dyncon++)
15402         {
15403           Elf_Internal_Dyn dyn;
15404           asection *s;
15405
15406           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
15407
15408           switch (dyn.d_tag)
15409             {
15410             default:
15411               continue;
15412
15413             case DT_PPC64_GLINK:
15414               s = htab->glink;
15415               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15416               /* We stupidly defined DT_PPC64_GLINK to be the start
15417                  of glink rather than the first entry point, which is
15418                  what ld.so needs, and now have a bigger stub to
15419                  support automatic multiple TOCs.  */
15420               dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
15421               break;
15422
15423             case DT_PPC64_OPD:
15424               s = bfd_get_section_by_name (output_bfd, ".opd");
15425               if (s == NULL)
15426                 continue;
15427               dyn.d_un.d_ptr = s->vma;
15428               break;
15429
15430             case DT_PPC64_OPT:
15431               if (htab->do_multi_toc && htab->multi_toc_needed)
15432                 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
15433               break;
15434
15435             case DT_PPC64_OPDSZ:
15436               s = bfd_get_section_by_name (output_bfd, ".opd");
15437               if (s == NULL)
15438                 continue;
15439               dyn.d_un.d_val = s->size;
15440               break;
15441
15442             case DT_PLTGOT:
15443               s = htab->elf.splt;
15444               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15445               break;
15446
15447             case DT_JMPREL:
15448               s = htab->elf.srelplt;
15449               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15450               break;
15451
15452             case DT_PLTRELSZ:
15453               dyn.d_un.d_val = htab->elf.srelplt->size;
15454               break;
15455
15456             case DT_RELASZ:
15457               /* Don't count procedure linkage table relocs in the
15458                  overall reloc count.  */
15459               s = htab->elf.srelplt;
15460               if (s == NULL)
15461                 continue;
15462               dyn.d_un.d_val -= s->size;
15463               break;
15464
15465             case DT_RELA:
15466               /* We may not be using the standard ELF linker script.
15467                  If .rela.plt is the first .rela section, we adjust
15468                  DT_RELA to not include it.  */
15469               s = htab->elf.srelplt;
15470               if (s == NULL)
15471                 continue;
15472               if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
15473                 continue;
15474               dyn.d_un.d_ptr += s->size;
15475               break;
15476             }
15477
15478           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
15479         }
15480     }
15481
15482   if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0)
15483     {
15484       /* Fill in the first entry in the global offset table.
15485          We use it to hold the link-time TOCbase.  */
15486       bfd_put_64 (output_bfd,
15487                   elf_gp (output_bfd) + TOC_BASE_OFF,
15488                   htab->elf.sgot->contents);
15489
15490       /* Set .got entry size.  */
15491       elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
15492     }
15493
15494   if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
15495     {
15496       /* Set .plt entry size.  */
15497       elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
15498         = PLT_ENTRY_SIZE (htab);
15499     }
15500
15501   /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
15502      brlt ourselves if emitrelocations.  */
15503   if (htab->brlt != NULL
15504       && htab->brlt->reloc_count != 0
15505       && !_bfd_elf_link_output_relocs (output_bfd,
15506                                        htab->brlt,
15507                                        elf_section_data (htab->brlt)->rela.hdr,
15508                                        elf_section_data (htab->brlt)->relocs,
15509                                        NULL))
15510     return FALSE;
15511
15512   if (htab->glink != NULL
15513       && htab->glink->reloc_count != 0
15514       && !_bfd_elf_link_output_relocs (output_bfd,
15515                                        htab->glink,
15516                                        elf_section_data (htab->glink)->rela.hdr,
15517                                        elf_section_data (htab->glink)->relocs,
15518                                        NULL))
15519     return FALSE;
15520
15521   if (htab->glink_eh_frame != NULL
15522       && htab->glink_eh_frame->size != 0)
15523     {
15524       bfd_vma val;
15525       bfd_byte *p;
15526       asection *stub_sec;
15527
15528       p = htab->glink_eh_frame->contents + sizeof (glink_eh_frame_cie);
15529       for (stub_sec = htab->params->stub_bfd->sections;
15530            stub_sec != NULL;
15531            stub_sec = stub_sec->next)
15532         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
15533           {
15534             /* FDE length.  */
15535             p += 4;
15536             /* CIE pointer.  */
15537             p += 4;
15538             /* Offset to stub section.  */
15539             val = (stub_sec->output_section->vma
15540                    + stub_sec->output_offset);
15541             val -= (htab->glink_eh_frame->output_section->vma
15542                     + htab->glink_eh_frame->output_offset
15543                     + (p - htab->glink_eh_frame->contents));
15544             if (val + 0x80000000 > 0xffffffff)
15545               {
15546                 info->callbacks->einfo
15547                   (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15548                    stub_sec->name);
15549                 return FALSE;
15550               }
15551             bfd_put_32 (dynobj, val, p);
15552             p += 4;
15553             /* stub section size.  */
15554             p += 4;
15555             /* Augmentation.  */
15556             p += 1;
15557             /* Pad.  */
15558             p += 7;
15559           }
15560       if (htab->glink != NULL && htab->glink->size != 0)
15561         {
15562           /* FDE length.  */
15563           p += 4;
15564           /* CIE pointer.  */
15565           p += 4;
15566           /* Offset to .glink.  */
15567           val = (htab->glink->output_section->vma
15568                  + htab->glink->output_offset
15569                  + 8);
15570           val -= (htab->glink_eh_frame->output_section->vma
15571                   + htab->glink_eh_frame->output_offset
15572                   + (p - htab->glink_eh_frame->contents));
15573           if (val + 0x80000000 > 0xffffffff)
15574             {
15575               info->callbacks->einfo
15576                 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15577                  htab->glink->name);
15578               return FALSE;
15579             }
15580           bfd_put_32 (dynobj, val, p);
15581           p += 4;
15582           /* .glink size.  */
15583           p += 4;
15584           /* Augmentation.  */
15585           p += 1;
15586           /* Ops.  */
15587           p += 7;
15588         }
15589
15590       if (htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
15591           && !_bfd_elf_write_section_eh_frame (output_bfd, info,
15592                                                htab->glink_eh_frame,
15593                                                htab->glink_eh_frame->contents))
15594         return FALSE;
15595     }
15596
15597   /* We need to handle writing out multiple GOT sections ourselves,
15598      since we didn't add them to DYNOBJ.  We know dynobj is the first
15599      bfd.  */
15600   while ((dynobj = dynobj->link.next) != NULL)
15601     {
15602       asection *s;
15603
15604       if (!is_ppc64_elf (dynobj))
15605         continue;
15606
15607       s = ppc64_elf_tdata (dynobj)->got;
15608       if (s != NULL
15609           && s->size != 0
15610           && s->output_section != bfd_abs_section_ptr
15611           && !bfd_set_section_contents (output_bfd, s->output_section,
15612                                         s->contents, s->output_offset,
15613                                         s->size))
15614         return FALSE;
15615       s = ppc64_elf_tdata (dynobj)->relgot;
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     }
15624
15625   return TRUE;
15626 }
15627
15628 #include "elf64-target.h"
15629
15630 /* FreeBSD support */
15631
15632 #undef  TARGET_LITTLE_SYM
15633 #undef  TARGET_LITTLE_NAME
15634
15635 #undef  TARGET_BIG_SYM
15636 #define TARGET_BIG_SYM  powerpc_elf64_fbsd_vec
15637 #undef  TARGET_BIG_NAME
15638 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15639
15640 #undef  ELF_OSABI
15641 #define ELF_OSABI       ELFOSABI_FREEBSD
15642
15643 #undef  elf64_bed
15644 #define elf64_bed       elf64_powerpc_fbsd_bed
15645
15646 #include "elf64-target.h"
15647