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