bfd/elf64-ppc.c

   1 /* PowerPC64-specific support for 64-bit ELF.
   2    Copyright (C) 1999-2016 Free Software Foundation, Inc.
   3    Written by Linus Nordberg, Swox AB <info@swox.com>,
   4    based on elf32-ppc.c by Ian Lance Taylor.
   5    Largely rewritten by Alan Modra.
   6
   7    This file is part of BFD, the Binary File Descriptor library.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License along
  20    with this program; if not, write to the Free Software Foundation, Inc.,
  21    51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
  22
  23
  24 /* The 64-bit PowerPC ELF ABI may be found at
  25    http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and
  26    http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html  */
  27
  28 #include "sysdep.h"
  29 #include <stdarg.h>
  30 #include "bfd.h"
  31 #include "bfdlink.h"
  32 #include "libbfd.h"
  33 #include "elf-bfd.h"
  34 #include "elf/ppc64.h"
  35 #include "elf64-ppc.h"
  36 #include "dwarf2.h"
  37
  38 static bfd_reloc_status_type ppc64_elf_ha_reloc
  39   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  40 static bfd_reloc_status_type ppc64_elf_branch_reloc
  41   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  42 static bfd_reloc_status_type ppc64_elf_brtaken_reloc
  43   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  44 static bfd_reloc_status_type ppc64_elf_sectoff_reloc
  45   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  46 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
  47   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  48 static bfd_reloc_status_type ppc64_elf_toc_reloc
  49   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  50 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
  51   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  52 static bfd_reloc_status_type ppc64_elf_toc64_reloc
  53   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  54 static bfd_reloc_status_type ppc64_elf_unhandled_reloc
  55   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  56 static bfd_vma opd_entry_value
  57   (asection *, bfd_vma, asection **, bfd_vma *, bfd_boolean);
  58
  59 #define TARGET_LITTLE_SYM       powerpc_elf64_le_vec
  60 #define TARGET_LITTLE_NAME      "elf64-powerpcle"
  61 #define TARGET_BIG_SYM          powerpc_elf64_vec
  62 #define TARGET_BIG_NAME         "elf64-powerpc"
  63 #define ELF_ARCH                bfd_arch_powerpc
  64 #define ELF_TARGET_ID           PPC64_ELF_DATA
  65 #define ELF_MACHINE_CODE        EM_PPC64
  66 #define ELF_MAXPAGESIZE         0x10000
  67 #define ELF_COMMONPAGESIZE      0x10000
  68 #define elf_info_to_howto       ppc64_elf_info_to_howto
  69
  70 #define elf_backend_want_got_sym 0
  71 #define elf_backend_want_plt_sym 0
  72 #define elf_backend_plt_alignment 3
  73 #define elf_backend_plt_not_loaded 1
  74 #define elf_backend_got_header_size 8
  75 #define elf_backend_can_gc_sections 1
  76 #define elf_backend_can_refcount 1
  77 #define elf_backend_rela_normal 1
  78 #define elf_backend_default_execstack 0
  79
  80 #define bfd_elf64_mkobject                    ppc64_elf_mkobject
  81 #define bfd_elf64_bfd_reloc_type_lookup       ppc64_elf_reloc_type_lookup
  82 #define bfd_elf64_bfd_reloc_name_lookup       ppc64_elf_reloc_name_lookup
  83 #define bfd_elf64_bfd_merge_private_bfd_data  ppc64_elf_merge_private_bfd_data
  84 #define bfd_elf64_bfd_print_private_bfd_data  ppc64_elf_print_private_bfd_data
  85 #define bfd_elf64_new_section_hook            ppc64_elf_new_section_hook
  86 #define bfd_elf64_bfd_link_hash_table_create  ppc64_elf_link_hash_table_create
  87 #define bfd_elf64_get_synthetic_symtab        ppc64_elf_get_synthetic_symtab
  88 #define bfd_elf64_bfd_link_just_syms          ppc64_elf_link_just_syms
  89
  90 #define elf_backend_object_p                  ppc64_elf_object_p
  91 #define elf_backend_grok_prstatus             ppc64_elf_grok_prstatus
  92 #define elf_backend_grok_psinfo               ppc64_elf_grok_psinfo
  93 #define elf_backend_write_core_note           ppc64_elf_write_core_note
  94 #define elf_backend_create_dynamic_sections   ppc64_elf_create_dynamic_sections
  95 #define elf_backend_copy_indirect_symbol      ppc64_elf_copy_indirect_symbol
  96 #define elf_backend_add_symbol_hook           ppc64_elf_add_symbol_hook
  97 #define elf_backend_check_directives          ppc64_elf_before_check_relocs
  98 #define elf_backend_notice_as_needed          ppc64_elf_notice_as_needed
  99 #define elf_backend_archive_symbol_lookup     ppc64_elf_archive_symbol_lookup
 100 #define elf_backend_check_relocs              ppc64_elf_check_relocs
 101 #define elf_backend_gc_keep                   ppc64_elf_gc_keep
 102 #define elf_backend_gc_mark_dynamic_ref       ppc64_elf_gc_mark_dynamic_ref
 103 #define elf_backend_gc_mark_hook              ppc64_elf_gc_mark_hook
 104 #define elf_backend_gc_sweep_hook             ppc64_elf_gc_sweep_hook
 105 #define elf_backend_adjust_dynamic_symbol     ppc64_elf_adjust_dynamic_symbol
 106 #define elf_backend_hide_symbol               ppc64_elf_hide_symbol
 107 #define elf_backend_maybe_function_sym        ppc64_elf_maybe_function_sym
 108 #define elf_backend_always_size_sections      ppc64_elf_func_desc_adjust
 109 #define elf_backend_size_dynamic_sections     ppc64_elf_size_dynamic_sections
 110 #define elf_backend_hash_symbol               ppc64_elf_hash_symbol
 111 #define elf_backend_init_index_section        _bfd_elf_init_2_index_sections
 112 #define elf_backend_action_discarded          ppc64_elf_action_discarded
 113 #define elf_backend_relocate_section          ppc64_elf_relocate_section
 114 #define elf_backend_finish_dynamic_symbol     ppc64_elf_finish_dynamic_symbol
 115 #define elf_backend_reloc_type_class          ppc64_elf_reloc_type_class
 116 #define elf_backend_finish_dynamic_sections   ppc64_elf_finish_dynamic_sections
 117 #define elf_backend_link_output_symbol_hook   ppc64_elf_output_symbol_hook
 118 #define elf_backend_special_sections          ppc64_elf_special_sections
 119 #define elf_backend_merge_symbol_attribute    ppc64_elf_merge_symbol_attribute
 120
 121 /* The name of the dynamic interpreter.  This is put in the .interp
 122    section.  */
 123 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
 124
 125 /* The size in bytes of an entry in the procedure linkage table.  */
 126 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
 127
 128 /* The initial size of the plt reserved for the dynamic linker.  */
 129 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
 130
 131 /* Offsets to some stack save slots.  */
 132 #define STK_LR 16
 133 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
 134 /* This one is dodgy.  ELFv2 does not have a linker word, so use the
 135    CR save slot.  Used only by optimised __tls_get_addr call stub,
 136    relying on __tls_get_addr_opt not saving CR..  */
 137 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
 138
 139 /* TOC base pointers offset from start of TOC.  */
 140 #define TOC_BASE_OFF    0x8000
 141 /* TOC base alignment.  */
 142 #define TOC_BASE_ALIGN  256
 143
 144 /* Offset of tp and dtp pointers from start of TLS block.  */
 145 #define TP_OFFSET       0x7000
 146 #define DTP_OFFSET      0x8000
 147
 148 /* .plt call stub instructions.  The normal stub is like this, but
 149    sometimes the .plt entry crosses a 64k boundary and we need to
 150    insert an addi to adjust r11.  */
 151 #define STD_R2_0R1      0xf8410000      /* std   %r2,0+40(%r1)       */
 152 #define ADDIS_R11_R2    0x3d620000      /* addis %r11,%r2,xxx@ha     */
 153 #define LD_R12_0R11     0xe98b0000      /* ld    %r12,xxx+0@l(%r11)  */
 154 #define MTCTR_R12       0x7d8903a6      /* mtctr %r12                */
 155 #define LD_R2_0R11      0xe84b0000      /* ld    %r2,xxx+8@l(%r11)   */
 156 #define LD_R11_0R11     0xe96b0000      /* ld    %r11,xxx+16@l(%r11) */
 157 #define BCTR            0x4e800420      /* bctr                      */
 158
 159 #define ADDI_R11_R11    0x396b0000      /* addi %r11,%r11,off@l  */
 160 #define ADDIS_R2_R2     0x3c420000      /* addis %r2,%r2,off@ha  */
 161 #define ADDI_R2_R2      0x38420000      /* addi  %r2,%r2,off@l   */
 162
 163 #define XOR_R2_R12_R12  0x7d826278      /* xor   %r2,%r12,%r12   */
 164 #define ADD_R11_R11_R2  0x7d6b1214      /* add   %r11,%r11,%r2   */
 165 #define XOR_R11_R12_R12 0x7d8b6278      /* xor   %r11,%r12,%r12  */
 166 #define ADD_R2_R2_R11   0x7c425a14      /* add   %r2,%r2,%r11    */
 167 #define CMPLDI_R2_0     0x28220000      /* cmpldi %r2,0          */
 168 #define BNECTR          0x4ca20420      /* bnectr+               */
 169 #define BNECTR_P4       0x4ce20420      /* bnectr+               */
 170
 171 #define LD_R12_0R2      0xe9820000      /* ld    %r12,xxx+0(%r2) */
 172 #define LD_R11_0R2      0xe9620000      /* ld    %r11,xxx+0(%r2) */
 173 #define LD_R2_0R2       0xe8420000      /* ld    %r2,xxx+0(%r2)  */
 174
 175 #define LD_R2_0R1       0xe8410000      /* ld    %r2,0(%r1)      */
 176 #define LD_R2_0R12      0xe84c0000      /* ld    %r2,0(%r12)     */
 177 #define ADD_R2_R2_R12   0x7c426214      /* add   %r2,%r2,%r12    */
 178
 179 #define LIS_R2          0x3c400000      /* lis %r2,xxx@ha         */
 180 #define ADDIS_R2_R12    0x3c4c0000      /* addis %r2,%r12,xxx@ha  */
 181 #define ADDIS_R12_R2    0x3d820000      /* addis %r12,%r2,xxx@ha  */
 182 #define ADDIS_R12_R12   0x3d8c0000      /* addis %r12,%r12,xxx@ha */
 183 #define LD_R12_0R12     0xe98c0000      /* ld    %r12,xxx@l(%r12) */
 184
 185 /* glink call stub instructions.  We enter with the index in R0.  */
 186 #define GLINK_CALL_STUB_SIZE (16*4)
 187                                         /* 0:                           */
 188                                         /*  .quad plt0-1f               */
 189                                         /* __glink:                     */
 190 #define MFLR_R12        0x7d8802a6      /*  mflr %12                    */
 191 #define BCL_20_31       0x429f0005      /*  bcl 20,31,1f                */
 192                                         /* 1:                           */
 193 #define MFLR_R11        0x7d6802a6      /*  mflr %11                    */
 194                                         /*  ld %2,(0b-1b)(%11)          */
 195 #define MTLR_R12        0x7d8803a6      /*  mtlr %12                    */
 196 #define ADD_R11_R2_R11  0x7d625a14      /*  add %11,%2,%11              */
 197                                         /*  ld %12,0(%11)               */
 198                                         /*  ld %2,8(%11)                */
 199                                         /*  mtctr %12                   */
 200                                         /*  ld %11,16(%11)              */
 201                                         /*  bctr                        */
 202 #define MFLR_R0         0x7c0802a6      /*  mflr %r0                    */
 203 #define MTLR_R0         0x7c0803a6      /*  mtlr %r0                    */
 204 #define SUB_R12_R12_R11 0x7d8b6050      /*  subf %r12,%r11,%r12         */
 205 #define ADDI_R0_R12     0x380c0000      /*  addi %r0,%r12,0             */
 206 #define SRDI_R0_R0_2    0x7800f082      /*  rldicl %r0,%r0,62,2         */
 207
 208 /* Pad with this.  */
 209 #define NOP             0x60000000
 210
 211 /* Some other nops.  */
 212 #define CROR_151515     0x4def7b82
 213 #define CROR_313131     0x4ffffb82
 214
 215 /* .glink entries for the first 32k functions are two instructions.  */
 216 #define LI_R0_0         0x38000000      /* li    %r0,0          */
 217 #define B_DOT           0x48000000      /* b     .              */
 218
 219 /* After that, we need two instructions to load the index, followed by
 220    a branch.  */
 221 #define LIS_R0_0        0x3c000000      /* lis   %r0,0          */
 222 #define ORI_R0_R0_0     0x60000000      /* ori   %r0,%r0,0      */
 223
 224 /* Instructions used by the save and restore reg functions.  */
 225 #define STD_R0_0R1      0xf8010000      /* std   %r0,0(%r1)     */
 226 #define STD_R0_0R12     0xf80c0000      /* std   %r0,0(%r12)    */
 227 #define LD_R0_0R1       0xe8010000      /* ld    %r0,0(%r1)     */
 228 #define LD_R0_0R12      0xe80c0000      /* ld    %r0,0(%r12)    */
 229 #define STFD_FR0_0R1    0xd8010000      /* stfd  %fr0,0(%r1)    */
 230 #define LFD_FR0_0R1     0xc8010000      /* lfd   %fr0,0(%r1)    */
 231 #define LI_R12_0        0x39800000      /* li    %r12,0         */
 232 #define STVX_VR0_R12_R0 0x7c0c01ce      /* stvx  %v0,%r12,%r0   */
 233 #define LVX_VR0_R12_R0  0x7c0c00ce      /* lvx   %v0,%r12,%r0   */
 234 #define MTLR_R0         0x7c0803a6      /* mtlr  %r0            */
 235 #define BLR             0x4e800020      /* blr                  */
 236
 237 /* Since .opd is an array of descriptors and each entry will end up
 238    with identical R_PPC64_RELATIVE relocs, there is really no need to
 239    propagate .opd relocs;  The dynamic linker should be taught to
 240    relocate .opd without reloc entries.  */
 241 #ifndef NO_OPD_RELOCS
 242 #define NO_OPD_RELOCS 0
 243 #endif
 244
 245 #ifndef ARRAY_SIZE
 246 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
 247 #endif
 248
 249 static inline int
 250 abiversion (bfd *abfd)
 251 {
 252   return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
 253 }
 254
 255 static inline void
 256 set_abiversion (bfd *abfd, int ver)
 257 {
 258   elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
 259   elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
 260 }
 261 \f
 262 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
 263
 264 /* Relocation HOWTO's.  */
 265 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
 266
 267 static reloc_howto_type ppc64_elf_howto_raw[] = {
 268   /* This reloc does nothing.  */
 269   HOWTO (R_PPC64_NONE,          /* type */
 270          0,                     /* rightshift */
 271          3,                     /* size (0 = byte, 1 = short, 2 = long) */
 272          0,                     /* bitsize */
 273          FALSE,                 /* pc_relative */
 274          0,                     /* bitpos */
 275          complain_overflow_dont, /* complain_on_overflow */
 276          bfd_elf_generic_reloc, /* special_function */
 277          "R_PPC64_NONE",        /* name */
 278          FALSE,                 /* partial_inplace */
 279          0,                     /* src_mask */
 280          0,                     /* dst_mask */
 281          FALSE),                /* pcrel_offset */
 282
 283   /* A standard 32 bit relocation.  */
 284   HOWTO (R_PPC64_ADDR32,        /* type */
 285          0,                     /* rightshift */
 286          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 287          32,                    /* bitsize */
 288          FALSE,                 /* pc_relative */
 289          0,                     /* bitpos */
 290          complain_overflow_bitfield, /* complain_on_overflow */
 291          bfd_elf_generic_reloc, /* special_function */
 292          "R_PPC64_ADDR32",      /* name */
 293          FALSE,                 /* partial_inplace */
 294          0,                     /* src_mask */
 295          0xffffffff,            /* dst_mask */
 296          FALSE),                /* pcrel_offset */
 297
 298   /* An absolute 26 bit branch; the lower two bits must be zero.
 299      FIXME: we don't check that, we just clear them.  */
 300   HOWTO (R_PPC64_ADDR24,        /* type */
 301          0,                     /* rightshift */
 302          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 303          26,                    /* bitsize */
 304          FALSE,                 /* pc_relative */
 305          0,                     /* bitpos */
 306          complain_overflow_bitfield, /* complain_on_overflow */
 307          bfd_elf_generic_reloc, /* special_function */
 308          "R_PPC64_ADDR24",      /* name */
 309          FALSE,                 /* partial_inplace */
 310          0,                     /* src_mask */
 311          0x03fffffc,            /* dst_mask */
 312          FALSE),                /* pcrel_offset */
 313
 314   /* A standard 16 bit relocation.  */
 315   HOWTO (R_PPC64_ADDR16,        /* type */
 316          0,                     /* rightshift */
 317          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 318          16,                    /* bitsize */
 319          FALSE,                 /* pc_relative */
 320          0,                     /* bitpos */
 321          complain_overflow_bitfield, /* complain_on_overflow */
 322          bfd_elf_generic_reloc, /* special_function */
 323          "R_PPC64_ADDR16",      /* name */
 324          FALSE,                 /* partial_inplace */
 325          0,                     /* src_mask */
 326          0xffff,                /* dst_mask */
 327          FALSE),                /* pcrel_offset */
 328
 329   /* A 16 bit relocation without overflow.  */
 330   HOWTO (R_PPC64_ADDR16_LO,     /* type */
 331          0,                     /* rightshift */
 332          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 333          16,                    /* bitsize */
 334          FALSE,                 /* pc_relative */
 335          0,                     /* bitpos */
 336          complain_overflow_dont,/* complain_on_overflow */
 337          bfd_elf_generic_reloc, /* special_function */
 338          "R_PPC64_ADDR16_LO",   /* name */
 339          FALSE,                 /* partial_inplace */
 340          0,                     /* src_mask */
 341          0xffff,                /* dst_mask */
 342          FALSE),                /* pcrel_offset */
 343
 344   /* Bits 16-31 of an address.  */
 345   HOWTO (R_PPC64_ADDR16_HI,     /* type */
 346          16,                    /* rightshift */
 347          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 348          16,                    /* bitsize */
 349          FALSE,                 /* pc_relative */
 350          0,                     /* bitpos */
 351          complain_overflow_signed, /* complain_on_overflow */
 352          bfd_elf_generic_reloc, /* special_function */
 353          "R_PPC64_ADDR16_HI",   /* name */
 354          FALSE,                 /* partial_inplace */
 355          0,                     /* src_mask */
 356          0xffff,                /* dst_mask */
 357          FALSE),                /* pcrel_offset */
 358
 359   /* Bits 16-31 of an address, plus 1 if the contents of the low 16
 360      bits, treated as a signed number, is negative.  */
 361   HOWTO (R_PPC64_ADDR16_HA,     /* type */
 362          16,                    /* rightshift */
 363          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 364          16,                    /* bitsize */
 365          FALSE,                 /* pc_relative */
 366          0,                     /* bitpos */
 367          complain_overflow_signed, /* complain_on_overflow */
 368          ppc64_elf_ha_reloc,    /* special_function */
 369          "R_PPC64_ADDR16_HA",   /* name */
 370          FALSE,                 /* partial_inplace */
 371          0,                     /* src_mask */
 372          0xffff,                /* dst_mask */
 373          FALSE),                /* pcrel_offset */
 374
 375   /* An absolute 16 bit branch; the lower two bits must be zero.
 376      FIXME: we don't check that, we just clear them.  */
 377   HOWTO (R_PPC64_ADDR14,        /* type */
 378          0,                     /* rightshift */
 379          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 380          16,                    /* bitsize */
 381          FALSE,                 /* pc_relative */
 382          0,                     /* bitpos */
 383          complain_overflow_signed, /* complain_on_overflow */
 384          ppc64_elf_branch_reloc, /* special_function */
 385          "R_PPC64_ADDR14",      /* name */
 386          FALSE,                 /* partial_inplace */
 387          0,                     /* src_mask */
 388          0x0000fffc,            /* dst_mask */
 389          FALSE),                /* pcrel_offset */
 390
 391   /* An absolute 16 bit branch, for which bit 10 should be set to
 392      indicate that the branch is expected to be taken.  The lower two
 393      bits must be zero.  */
 394   HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
 395          0,                     /* rightshift */
 396          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 397          16,                    /* bitsize */
 398          FALSE,                 /* pc_relative */
 399          0,                     /* bitpos */
 400          complain_overflow_signed, /* complain_on_overflow */
 401          ppc64_elf_brtaken_reloc, /* special_function */
 402          "R_PPC64_ADDR14_BRTAKEN",/* name */
 403          FALSE,                 /* partial_inplace */
 404          0,                     /* src_mask */
 405          0x0000fffc,            /* dst_mask */
 406          FALSE),                /* pcrel_offset */
 407
 408   /* An absolute 16 bit branch, for which bit 10 should be set to
 409      indicate that the branch is not expected to be taken.  The lower
 410      two bits must be zero.  */
 411   HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
 412          0,                     /* rightshift */
 413          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 414          16,                    /* bitsize */
 415          FALSE,                 /* pc_relative */
 416          0,                     /* bitpos */
 417          complain_overflow_signed, /* complain_on_overflow */
 418          ppc64_elf_brtaken_reloc, /* special_function */
 419          "R_PPC64_ADDR14_BRNTAKEN",/* name */
 420          FALSE,                 /* partial_inplace */
 421          0,                     /* src_mask */
 422          0x0000fffc,            /* dst_mask */
 423          FALSE),                /* pcrel_offset */
 424
 425   /* A relative 26 bit branch; the lower two bits must be zero.  */
 426   HOWTO (R_PPC64_REL24,         /* type */
 427          0,                     /* rightshift */
 428          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 429          26,                    /* bitsize */
 430          TRUE,                  /* pc_relative */
 431          0,                     /* bitpos */
 432          complain_overflow_signed, /* complain_on_overflow */
 433          ppc64_elf_branch_reloc, /* special_function */
 434          "R_PPC64_REL24",       /* name */
 435          FALSE,                 /* partial_inplace */
 436          0,                     /* src_mask */
 437          0x03fffffc,            /* dst_mask */
 438          TRUE),                 /* pcrel_offset */
 439
 440   /* A relative 16 bit branch; the lower two bits must be zero.  */
 441   HOWTO (R_PPC64_REL14,         /* type */
 442          0,                     /* rightshift */
 443          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 444          16,                    /* bitsize */
 445          TRUE,                  /* pc_relative */
 446          0,                     /* bitpos */
 447          complain_overflow_signed, /* complain_on_overflow */
 448          ppc64_elf_branch_reloc, /* special_function */
 449          "R_PPC64_REL14",       /* name */
 450          FALSE,                 /* partial_inplace */
 451          0,                     /* src_mask */
 452          0x0000fffc,            /* dst_mask */
 453          TRUE),                 /* pcrel_offset */
 454
 455   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 456      the branch is expected to be taken.  The lower two bits must be
 457      zero.  */
 458   HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
 459          0,                     /* rightshift */
 460          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 461          16,                    /* bitsize */
 462          TRUE,                  /* pc_relative */
 463          0,                     /* bitpos */
 464          complain_overflow_signed, /* complain_on_overflow */
 465          ppc64_elf_brtaken_reloc, /* special_function */
 466          "R_PPC64_REL14_BRTAKEN", /* name */
 467          FALSE,                 /* partial_inplace */
 468          0,                     /* src_mask */
 469          0x0000fffc,            /* dst_mask */
 470          TRUE),                 /* pcrel_offset */
 471
 472   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 473      the branch is not expected to be taken.  The lower two bits must
 474      be zero.  */
 475   HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
 476          0,                     /* rightshift */
 477          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 478          16,                    /* bitsize */
 479          TRUE,                  /* pc_relative */
 480          0,                     /* bitpos */
 481          complain_overflow_signed, /* complain_on_overflow */
 482          ppc64_elf_brtaken_reloc, /* special_function */
 483          "R_PPC64_REL14_BRNTAKEN",/* name */
 484          FALSE,                 /* partial_inplace */
 485          0,                     /* src_mask */
 486          0x0000fffc,            /* dst_mask */
 487          TRUE),                 /* pcrel_offset */
 488
 489   /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
 490      symbol.  */
 491   HOWTO (R_PPC64_GOT16,         /* type */
 492          0,                     /* rightshift */
 493          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 494          16,                    /* bitsize */
 495          FALSE,                 /* pc_relative */
 496          0,                     /* bitpos */
 497          complain_overflow_signed, /* complain_on_overflow */
 498          ppc64_elf_unhandled_reloc, /* special_function */
 499          "R_PPC64_GOT16",       /* name */
 500          FALSE,                 /* partial_inplace */
 501          0,                     /* src_mask */
 502          0xffff,                /* dst_mask */
 503          FALSE),                /* pcrel_offset */
 504
 505   /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
 506      the symbol.  */
 507   HOWTO (R_PPC64_GOT16_LO,      /* type */
 508          0,                     /* rightshift */
 509          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 510          16,                    /* bitsize */
 511          FALSE,                 /* pc_relative */
 512          0,                     /* bitpos */
 513          complain_overflow_dont, /* complain_on_overflow */
 514          ppc64_elf_unhandled_reloc, /* special_function */
 515          "R_PPC64_GOT16_LO",    /* name */
 516          FALSE,                 /* partial_inplace */
 517          0,                     /* src_mask */
 518          0xffff,                /* dst_mask */
 519          FALSE),                /* pcrel_offset */
 520
 521   /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
 522      the symbol.  */
 523   HOWTO (R_PPC64_GOT16_HI,      /* type */
 524          16,                    /* rightshift */
 525          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 526          16,                    /* bitsize */
 527          FALSE,                 /* pc_relative */
 528          0,                     /* bitpos */
 529          complain_overflow_signed,/* complain_on_overflow */
 530          ppc64_elf_unhandled_reloc, /* special_function */
 531          "R_PPC64_GOT16_HI",    /* name */
 532          FALSE,                 /* partial_inplace */
 533          0,                     /* src_mask */
 534          0xffff,                /* dst_mask */
 535          FALSE),                /* pcrel_offset */
 536
 537   /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
 538      the symbol.  */
 539   HOWTO (R_PPC64_GOT16_HA,      /* type */
 540          16,                    /* rightshift */
 541          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 542          16,                    /* bitsize */
 543          FALSE,                 /* pc_relative */
 544          0,                     /* bitpos */
 545          complain_overflow_signed,/* complain_on_overflow */
 546          ppc64_elf_unhandled_reloc, /* special_function */
 547          "R_PPC64_GOT16_HA",    /* name */
 548          FALSE,                 /* partial_inplace */
 549          0,                     /* src_mask */
 550          0xffff,                /* dst_mask */
 551          FALSE),                /* pcrel_offset */
 552
 553   /* This is used only by the dynamic linker.  The symbol should exist
 554      both in the object being run and in some shared library.  The
 555      dynamic linker copies the data addressed by the symbol from the
 556      shared library into the object, because the object being
 557      run has to have the data at some particular address.  */
 558   HOWTO (R_PPC64_COPY,          /* type */
 559          0,                     /* rightshift */
 560          0,                     /* this one is variable size */
 561          0,                     /* bitsize */
 562          FALSE,                 /* pc_relative */
 563          0,                     /* bitpos */
 564          complain_overflow_dont, /* complain_on_overflow */
 565          ppc64_elf_unhandled_reloc, /* special_function */
 566          "R_PPC64_COPY",        /* name */
 567          FALSE,                 /* partial_inplace */
 568          0,                     /* src_mask */
 569          0,                     /* dst_mask */
 570          FALSE),                /* pcrel_offset */
 571
 572   /* Like R_PPC64_ADDR64, but used when setting global offset table
 573      entries.  */
 574   HOWTO (R_PPC64_GLOB_DAT,      /* type */
 575          0,                     /* rightshift */
 576          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 577          64,                    /* bitsize */
 578          FALSE,                 /* pc_relative */
 579          0,                     /* bitpos */
 580          complain_overflow_dont, /* complain_on_overflow */
 581          ppc64_elf_unhandled_reloc,  /* special_function */
 582          "R_PPC64_GLOB_DAT",    /* name */
 583          FALSE,                 /* partial_inplace */
 584          0,                     /* src_mask */
 585          ONES (64),             /* dst_mask */
 586          FALSE),                /* pcrel_offset */
 587
 588   /* Created by the link editor.  Marks a procedure linkage table
 589      entry for a symbol.  */
 590   HOWTO (R_PPC64_JMP_SLOT,      /* type */
 591          0,                     /* rightshift */
 592          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 593          0,                     /* bitsize */
 594          FALSE,                 /* pc_relative */
 595          0,                     /* bitpos */
 596          complain_overflow_dont, /* complain_on_overflow */
 597          ppc64_elf_unhandled_reloc, /* special_function */
 598          "R_PPC64_JMP_SLOT",    /* name */
 599          FALSE,                 /* partial_inplace */
 600          0,                     /* src_mask */
 601          0,                     /* dst_mask */
 602          FALSE),                /* pcrel_offset */
 603
 604   /* Used only by the dynamic linker.  When the object is run, this
 605      doubleword64 is set to the load address of the object, plus the
 606      addend.  */
 607   HOWTO (R_PPC64_RELATIVE,      /* type */
 608          0,                     /* rightshift */
 609          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 610          64,                    /* bitsize */
 611          FALSE,                 /* pc_relative */
 612          0,                     /* bitpos */
 613          complain_overflow_dont, /* complain_on_overflow */
 614          bfd_elf_generic_reloc, /* special_function */
 615          "R_PPC64_RELATIVE",    /* name */
 616          FALSE,                 /* partial_inplace */
 617          0,                     /* src_mask */
 618          ONES (64),             /* dst_mask */
 619          FALSE),                /* pcrel_offset */
 620
 621   /* Like R_PPC64_ADDR32, but may be unaligned.  */
 622   HOWTO (R_PPC64_UADDR32,       /* type */
 623          0,                     /* rightshift */
 624          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 625          32,                    /* bitsize */
 626          FALSE,                 /* pc_relative */
 627          0,                     /* bitpos */
 628          complain_overflow_bitfield, /* complain_on_overflow */
 629          bfd_elf_generic_reloc, /* special_function */
 630          "R_PPC64_UADDR32",     /* name */
 631          FALSE,                 /* partial_inplace */
 632          0,                     /* src_mask */
 633          0xffffffff,            /* dst_mask */
 634          FALSE),                /* pcrel_offset */
 635
 636   /* Like R_PPC64_ADDR16, but may be unaligned.  */
 637   HOWTO (R_PPC64_UADDR16,       /* type */
 638          0,                     /* rightshift */
 639          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 640          16,                    /* bitsize */
 641          FALSE,                 /* pc_relative */
 642          0,                     /* bitpos */
 643          complain_overflow_bitfield, /* complain_on_overflow */
 644          bfd_elf_generic_reloc, /* special_function */
 645          "R_PPC64_UADDR16",     /* name */
 646          FALSE,                 /* partial_inplace */
 647          0,                     /* src_mask */
 648          0xffff,                /* dst_mask */
 649          FALSE),                /* pcrel_offset */
 650
 651   /* 32-bit PC relative.  */
 652   HOWTO (R_PPC64_REL32,         /* type */
 653          0,                     /* rightshift */
 654          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 655          32,                    /* bitsize */
 656          TRUE,                  /* pc_relative */
 657          0,                     /* bitpos */
 658          complain_overflow_signed, /* complain_on_overflow */
 659          bfd_elf_generic_reloc, /* special_function */
 660          "R_PPC64_REL32",       /* name */
 661          FALSE,                 /* partial_inplace */
 662          0,                     /* src_mask */
 663          0xffffffff,            /* dst_mask */
 664          TRUE),                 /* pcrel_offset */
 665
 666   /* 32-bit relocation to the symbol's procedure linkage table.  */
 667   HOWTO (R_PPC64_PLT32,         /* type */
 668          0,                     /* rightshift */
 669          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 670          32,                    /* bitsize */
 671          FALSE,                 /* pc_relative */
 672          0,                     /* bitpos */
 673          complain_overflow_bitfield, /* complain_on_overflow */
 674          ppc64_elf_unhandled_reloc, /* special_function */
 675          "R_PPC64_PLT32",       /* name */
 676          FALSE,                 /* partial_inplace */
 677          0,                     /* src_mask */
 678          0xffffffff,            /* dst_mask */
 679          FALSE),                /* pcrel_offset */
 680
 681   /* 32-bit PC relative relocation to the symbol's procedure linkage table.
 682      FIXME: R_PPC64_PLTREL32 not supported.  */
 683   HOWTO (R_PPC64_PLTREL32,      /* type */
 684          0,                     /* rightshift */
 685          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 686          32,                    /* bitsize */
 687          TRUE,                  /* pc_relative */
 688          0,                     /* bitpos */
 689          complain_overflow_signed, /* complain_on_overflow */
 690          ppc64_elf_unhandled_reloc, /* special_function */
 691          "R_PPC64_PLTREL32",    /* name */
 692          FALSE,                 /* partial_inplace */
 693          0,                     /* src_mask */
 694          0xffffffff,            /* dst_mask */
 695          TRUE),                 /* pcrel_offset */
 696
 697   /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
 698      the symbol.  */
 699   HOWTO (R_PPC64_PLT16_LO,      /* type */
 700          0,                     /* rightshift */
 701          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 702          16,                    /* bitsize */
 703          FALSE,                 /* pc_relative */
 704          0,                     /* bitpos */
 705          complain_overflow_dont, /* complain_on_overflow */
 706          ppc64_elf_unhandled_reloc, /* special_function */
 707          "R_PPC64_PLT16_LO",    /* name */
 708          FALSE,                 /* partial_inplace */
 709          0,                     /* src_mask */
 710          0xffff,                /* dst_mask */
 711          FALSE),                /* pcrel_offset */
 712
 713   /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
 714      the symbol.  */
 715   HOWTO (R_PPC64_PLT16_HI,      /* type */
 716          16,                    /* rightshift */
 717          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 718          16,                    /* bitsize */
 719          FALSE,                 /* pc_relative */
 720          0,                     /* bitpos */
 721          complain_overflow_signed, /* complain_on_overflow */
 722          ppc64_elf_unhandled_reloc, /* special_function */
 723          "R_PPC64_PLT16_HI",    /* name */
 724          FALSE,                 /* partial_inplace */
 725          0,                     /* src_mask */
 726          0xffff,                /* dst_mask */
 727          FALSE),                /* pcrel_offset */
 728
 729   /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
 730      the symbol.  */
 731   HOWTO (R_PPC64_PLT16_HA,      /* type */
 732          16,                    /* rightshift */
 733          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 734          16,                    /* bitsize */
 735          FALSE,                 /* pc_relative */
 736          0,                     /* bitpos */
 737          complain_overflow_signed, /* complain_on_overflow */
 738          ppc64_elf_unhandled_reloc, /* special_function */
 739          "R_PPC64_PLT16_HA",    /* name */
 740          FALSE,                 /* partial_inplace */
 741          0,                     /* src_mask */
 742          0xffff,                /* dst_mask */
 743          FALSE),                /* pcrel_offset */
 744
 745   /* 16-bit section relative relocation.  */
 746   HOWTO (R_PPC64_SECTOFF,       /* type */
 747          0,                     /* rightshift */
 748          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 749          16,                    /* bitsize */
 750          FALSE,                 /* pc_relative */
 751          0,                     /* bitpos */
 752          complain_overflow_signed, /* complain_on_overflow */
 753          ppc64_elf_sectoff_reloc, /* special_function */
 754          "R_PPC64_SECTOFF",     /* name */
 755          FALSE,                 /* partial_inplace */
 756          0,                     /* src_mask */
 757          0xffff,                /* dst_mask */
 758          FALSE),                /* pcrel_offset */
 759
 760   /* Like R_PPC64_SECTOFF, but no overflow warning.  */
 761   HOWTO (R_PPC64_SECTOFF_LO,    /* type */
 762          0,                     /* rightshift */
 763          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 764          16,                    /* bitsize */
 765          FALSE,                 /* pc_relative */
 766          0,                     /* bitpos */
 767          complain_overflow_dont, /* complain_on_overflow */
 768          ppc64_elf_sectoff_reloc, /* special_function */
 769          "R_PPC64_SECTOFF_LO",  /* name */
 770          FALSE,                 /* partial_inplace */
 771          0,                     /* src_mask */
 772          0xffff,                /* dst_mask */
 773          FALSE),                /* pcrel_offset */
 774
 775   /* 16-bit upper half section relative relocation.  */
 776   HOWTO (R_PPC64_SECTOFF_HI,    /* type */
 777          16,                    /* rightshift */
 778          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 779          16,                    /* bitsize */
 780          FALSE,                 /* pc_relative */
 781          0,                     /* bitpos */
 782          complain_overflow_signed, /* complain_on_overflow */
 783          ppc64_elf_sectoff_reloc, /* special_function */
 784          "R_PPC64_SECTOFF_HI",  /* name */
 785          FALSE,                 /* partial_inplace */
 786          0,                     /* src_mask */
 787          0xffff,                /* dst_mask */
 788          FALSE),                /* pcrel_offset */
 789
 790   /* 16-bit upper half adjusted section relative relocation.  */
 791   HOWTO (R_PPC64_SECTOFF_HA,    /* type */
 792          16,                    /* rightshift */
 793          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 794          16,                    /* bitsize */
 795          FALSE,                 /* pc_relative */
 796          0,                     /* bitpos */
 797          complain_overflow_signed, /* complain_on_overflow */
 798          ppc64_elf_sectoff_ha_reloc, /* special_function */
 799          "R_PPC64_SECTOFF_HA",  /* name */
 800          FALSE,                 /* partial_inplace */
 801          0,                     /* src_mask */
 802          0xffff,                /* dst_mask */
 803          FALSE),                /* pcrel_offset */
 804
 805   /* Like R_PPC64_REL24 without touching the two least significant bits.  */
 806   HOWTO (R_PPC64_REL30,         /* type */
 807          2,                     /* rightshift */
 808          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 809          30,                    /* bitsize */
 810          TRUE,                  /* pc_relative */
 811          0,                     /* bitpos */
 812          complain_overflow_dont, /* complain_on_overflow */
 813          bfd_elf_generic_reloc, /* special_function */
 814          "R_PPC64_REL30",       /* name */
 815          FALSE,                 /* partial_inplace */
 816          0,                     /* src_mask */
 817          0xfffffffc,            /* dst_mask */
 818          TRUE),                 /* pcrel_offset */
 819
 820   /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI.  */
 821
 822   /* A standard 64-bit relocation.  */
 823   HOWTO (R_PPC64_ADDR64,        /* type */
 824          0,                     /* rightshift */
 825          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 826          64,                    /* bitsize */
 827          FALSE,                 /* pc_relative */
 828          0,                     /* bitpos */
 829          complain_overflow_dont, /* complain_on_overflow */
 830          bfd_elf_generic_reloc, /* special_function */
 831          "R_PPC64_ADDR64",      /* name */
 832          FALSE,                 /* partial_inplace */
 833          0,                     /* src_mask */
 834          ONES (64),             /* dst_mask */
 835          FALSE),                /* pcrel_offset */
 836
 837   /* The bits 32-47 of an address.  */
 838   HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
 839          32,                    /* rightshift */
 840          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 841          16,                    /* bitsize */
 842          FALSE,                 /* pc_relative */
 843          0,                     /* bitpos */
 844          complain_overflow_dont, /* complain_on_overflow */
 845          bfd_elf_generic_reloc, /* special_function */
 846          "R_PPC64_ADDR16_HIGHER", /* name */
 847          FALSE,                 /* partial_inplace */
 848          0,                     /* src_mask */
 849          0xffff,                /* dst_mask */
 850          FALSE),                /* pcrel_offset */
 851
 852   /* The bits 32-47 of an address, plus 1 if the contents of the low
 853      16 bits, treated as a signed number, is negative.  */
 854   HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
 855          32,                    /* rightshift */
 856          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 857          16,                    /* bitsize */
 858          FALSE,                 /* pc_relative */
 859          0,                     /* bitpos */
 860          complain_overflow_dont, /* complain_on_overflow */
 861          ppc64_elf_ha_reloc,    /* special_function */
 862          "R_PPC64_ADDR16_HIGHERA", /* name */
 863          FALSE,                 /* partial_inplace */
 864          0,                     /* src_mask */
 865          0xffff,                /* dst_mask */
 866          FALSE),                /* pcrel_offset */
 867
 868   /* The bits 48-63 of an address.  */
 869   HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
 870          48,                    /* rightshift */
 871          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 872          16,                    /* bitsize */
 873          FALSE,                 /* pc_relative */
 874          0,                     /* bitpos */
 875          complain_overflow_dont, /* complain_on_overflow */
 876          bfd_elf_generic_reloc, /* special_function */
 877          "R_PPC64_ADDR16_HIGHEST", /* name */
 878          FALSE,                 /* partial_inplace */
 879          0,                     /* src_mask */
 880          0xffff,                /* dst_mask */
 881          FALSE),                /* pcrel_offset */
 882
 883   /* The bits 48-63 of an address, plus 1 if the contents of the low
 884      16 bits, treated as a signed number, is negative.  */
 885   HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
 886          48,                    /* rightshift */
 887          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 888          16,                    /* bitsize */
 889          FALSE,                 /* pc_relative */
 890          0,                     /* bitpos */
 891          complain_overflow_dont, /* complain_on_overflow */
 892          ppc64_elf_ha_reloc,    /* special_function */
 893          "R_PPC64_ADDR16_HIGHESTA", /* name */
 894          FALSE,                 /* partial_inplace */
 895          0,                     /* src_mask */
 896          0xffff,                /* dst_mask */
 897          FALSE),                /* pcrel_offset */
 898
 899   /* Like ADDR64, but may be unaligned.  */
 900   HOWTO (R_PPC64_UADDR64,       /* type */
 901          0,                     /* rightshift */
 902          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 903          64,                    /* bitsize */
 904          FALSE,                 /* pc_relative */
 905          0,                     /* bitpos */
 906          complain_overflow_dont, /* complain_on_overflow */
 907          bfd_elf_generic_reloc, /* special_function */
 908          "R_PPC64_UADDR64",     /* name */
 909          FALSE,                 /* partial_inplace */
 910          0,                     /* src_mask */
 911          ONES (64),             /* dst_mask */
 912          FALSE),                /* pcrel_offset */
 913
 914   /* 64-bit relative relocation.  */
 915   HOWTO (R_PPC64_REL64,         /* type */
 916          0,                     /* rightshift */
 917          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 918          64,                    /* bitsize */
 919          TRUE,                  /* pc_relative */
 920          0,                     /* bitpos */
 921          complain_overflow_dont, /* complain_on_overflow */
 922          bfd_elf_generic_reloc, /* special_function */
 923          "R_PPC64_REL64",       /* name */
 924          FALSE,                 /* partial_inplace */
 925          0,                     /* src_mask */
 926          ONES (64),             /* dst_mask */
 927          TRUE),                 /* pcrel_offset */
 928
 929   /* 64-bit relocation to the symbol's procedure linkage table.  */
 930   HOWTO (R_PPC64_PLT64,         /* type */
 931          0,                     /* rightshift */
 932          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 933          64,                    /* bitsize */
 934          FALSE,                 /* pc_relative */
 935          0,                     /* bitpos */
 936          complain_overflow_dont, /* complain_on_overflow */
 937          ppc64_elf_unhandled_reloc, /* special_function */
 938          "R_PPC64_PLT64",       /* name */
 939          FALSE,                 /* partial_inplace */
 940          0,                     /* src_mask */
 941          ONES (64),             /* dst_mask */
 942          FALSE),                /* pcrel_offset */
 943
 944   /* 64-bit PC relative relocation to the symbol's procedure linkage
 945      table.  */
 946   /* FIXME: R_PPC64_PLTREL64 not supported.  */
 947   HOWTO (R_PPC64_PLTREL64,      /* type */
 948          0,                     /* rightshift */
 949          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 950          64,                    /* bitsize */
 951          TRUE,                  /* pc_relative */
 952          0,                     /* bitpos */
 953          complain_overflow_dont, /* complain_on_overflow */
 954          ppc64_elf_unhandled_reloc, /* special_function */
 955          "R_PPC64_PLTREL64",    /* name */
 956          FALSE,                 /* partial_inplace */
 957          0,                     /* src_mask */
 958          ONES (64),             /* dst_mask */
 959          TRUE),                 /* pcrel_offset */
 960
 961   /* 16 bit TOC-relative relocation.  */
 962
 963   /* R_PPC64_TOC16        47       half16*      S + A - .TOC.  */
 964   HOWTO (R_PPC64_TOC16,         /* type */
 965          0,                     /* rightshift */
 966          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 967          16,                    /* bitsize */
 968          FALSE,                 /* pc_relative */
 969          0,                     /* bitpos */
 970          complain_overflow_signed, /* complain_on_overflow */
 971          ppc64_elf_toc_reloc,   /* special_function */
 972          "R_PPC64_TOC16",       /* name */
 973          FALSE,                 /* partial_inplace */
 974          0,                     /* src_mask */
 975          0xffff,                /* dst_mask */
 976          FALSE),                /* pcrel_offset */
 977
 978   /* 16 bit TOC-relative relocation without overflow.  */
 979
 980   /* R_PPC64_TOC16_LO     48       half16        #lo (S + A - .TOC.)  */
 981   HOWTO (R_PPC64_TOC16_LO,      /* type */
 982          0,                     /* rightshift */
 983          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 984          16,                    /* bitsize */
 985          FALSE,                 /* pc_relative */
 986          0,                     /* bitpos */
 987          complain_overflow_dont, /* complain_on_overflow */
 988          ppc64_elf_toc_reloc,   /* special_function */
 989          "R_PPC64_TOC16_LO",    /* name */
 990          FALSE,                 /* partial_inplace */
 991          0,                     /* src_mask */
 992          0xffff,                /* dst_mask */
 993          FALSE),                /* pcrel_offset */
 994
 995   /* 16 bit TOC-relative relocation, high 16 bits.  */
 996
 997   /* R_PPC64_TOC16_HI     49       half16        #hi (S + A - .TOC.)  */
 998   HOWTO (R_PPC64_TOC16_HI,      /* type */
 999          16,                    /* rightshift */
1000          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1001          16,                    /* bitsize */
1002          FALSE,                 /* pc_relative */
1003          0,                     /* bitpos */
1004          complain_overflow_signed, /* complain_on_overflow */
1005          ppc64_elf_toc_reloc,   /* special_function */
1006          "R_PPC64_TOC16_HI",    /* name */
1007          FALSE,                 /* partial_inplace */
1008          0,                     /* src_mask */
1009          0xffff,                /* dst_mask */
1010          FALSE),                /* pcrel_offset */
1011
1012   /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
1013      contents of the low 16 bits, treated as a signed number, is
1014      negative.  */
1015
1016   /* R_PPC64_TOC16_HA     50       half16        #ha (S + A - .TOC.)  */
1017   HOWTO (R_PPC64_TOC16_HA,      /* type */
1018          16,                    /* rightshift */
1019          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1020          16,                    /* bitsize */
1021          FALSE,                 /* pc_relative */
1022          0,                     /* bitpos */
1023          complain_overflow_signed, /* complain_on_overflow */
1024          ppc64_elf_toc_ha_reloc, /* special_function */
1025          "R_PPC64_TOC16_HA",    /* name */
1026          FALSE,                 /* partial_inplace */
1027          0,                     /* src_mask */
1028          0xffff,                /* dst_mask */
1029          FALSE),                /* pcrel_offset */
1030
1031   /* 64-bit relocation; insert value of TOC base (.TOC.).  */
1032
1033   /* R_PPC64_TOC                  51       doubleword64  .TOC.  */
1034   HOWTO (R_PPC64_TOC,           /* type */
1035          0,                     /* rightshift */
1036          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1037          64,                    /* bitsize */
1038          FALSE,                 /* pc_relative */
1039          0,                     /* bitpos */
1040          complain_overflow_dont, /* complain_on_overflow */
1041          ppc64_elf_toc64_reloc, /* special_function */
1042          "R_PPC64_TOC",         /* name */
1043          FALSE,                 /* partial_inplace */
1044          0,                     /* src_mask */
1045          ONES (64),             /* dst_mask */
1046          FALSE),                /* pcrel_offset */
1047
1048   /* Like R_PPC64_GOT16, but also informs the link editor that the
1049      value to relocate may (!) refer to a PLT entry which the link
1050      editor (a) may replace with the symbol value.  If the link editor
1051      is unable to fully resolve the symbol, it may (b) create a PLT
1052      entry and store the address to the new PLT entry in the GOT.
1053      This permits lazy resolution of function symbols at run time.
1054      The link editor may also skip all of this and just (c) emit a
1055      R_PPC64_GLOB_DAT to tie the symbol to the GOT entry.  */
1056   /* FIXME: R_PPC64_PLTGOT16 not implemented.  */
1057     HOWTO (R_PPC64_PLTGOT16,    /* type */
1058          0,                     /* rightshift */
1059          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1060          16,                    /* bitsize */
1061          FALSE,                 /* pc_relative */
1062          0,                     /* bitpos */
1063          complain_overflow_signed, /* complain_on_overflow */
1064          ppc64_elf_unhandled_reloc, /* special_function */
1065          "R_PPC64_PLTGOT16",    /* name */
1066          FALSE,                 /* partial_inplace */
1067          0,                     /* src_mask */
1068          0xffff,                /* dst_mask */
1069          FALSE),                /* pcrel_offset */
1070
1071   /* Like R_PPC64_PLTGOT16, but without overflow.  */
1072   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1073   HOWTO (R_PPC64_PLTGOT16_LO,   /* type */
1074          0,                     /* rightshift */
1075          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1076          16,                    /* bitsize */
1077          FALSE,                 /* pc_relative */
1078          0,                     /* bitpos */
1079          complain_overflow_dont, /* complain_on_overflow */
1080          ppc64_elf_unhandled_reloc, /* special_function */
1081          "R_PPC64_PLTGOT16_LO", /* name */
1082          FALSE,                 /* partial_inplace */
1083          0,                     /* src_mask */
1084          0xffff,                /* dst_mask */
1085          FALSE),                /* pcrel_offset */
1086
1087   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address.  */
1088   /* FIXME: R_PPC64_PLTGOT16_HI not implemented.  */
1089   HOWTO (R_PPC64_PLTGOT16_HI,   /* type */
1090          16,                    /* rightshift */
1091          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1092          16,                    /* bitsize */
1093          FALSE,                 /* pc_relative */
1094          0,                     /* bitpos */
1095          complain_overflow_signed, /* complain_on_overflow */
1096          ppc64_elf_unhandled_reloc, /* special_function */
1097          "R_PPC64_PLTGOT16_HI", /* name */
1098          FALSE,                 /* partial_inplace */
1099          0,                     /* src_mask */
1100          0xffff,                /* dst_mask */
1101          FALSE),                /* pcrel_offset */
1102
1103   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1104      1 if the contents of the low 16 bits, treated as a signed number,
1105      is negative.  */
1106   /* FIXME: R_PPC64_PLTGOT16_HA not implemented.  */
1107   HOWTO (R_PPC64_PLTGOT16_HA,   /* type */
1108          16,                    /* rightshift */
1109          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1110          16,                    /* bitsize */
1111          FALSE,                 /* pc_relative */
1112          0,                     /* bitpos */
1113          complain_overflow_signed, /* complain_on_overflow */
1114          ppc64_elf_unhandled_reloc, /* special_function */
1115          "R_PPC64_PLTGOT16_HA", /* name */
1116          FALSE,                 /* partial_inplace */
1117          0,                     /* src_mask */
1118          0xffff,                /* dst_mask */
1119          FALSE),                /* pcrel_offset */
1120
1121   /* Like R_PPC64_ADDR16, but for instructions with a DS field.  */
1122   HOWTO (R_PPC64_ADDR16_DS,     /* type */
1123          0,                     /* rightshift */
1124          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1125          16,                    /* bitsize */
1126          FALSE,                 /* pc_relative */
1127          0,                     /* bitpos */
1128          complain_overflow_signed, /* complain_on_overflow */
1129          bfd_elf_generic_reloc, /* special_function */
1130          "R_PPC64_ADDR16_DS",   /* name */
1131          FALSE,                 /* partial_inplace */
1132          0,                     /* src_mask */
1133          0xfffc,                /* dst_mask */
1134          FALSE),                /* pcrel_offset */
1135
1136   /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field.  */
1137   HOWTO (R_PPC64_ADDR16_LO_DS,  /* type */
1138          0,                     /* rightshift */
1139          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1140          16,                    /* bitsize */
1141          FALSE,                 /* pc_relative */
1142          0,                     /* bitpos */
1143          complain_overflow_dont,/* complain_on_overflow */
1144          bfd_elf_generic_reloc, /* special_function */
1145          "R_PPC64_ADDR16_LO_DS",/* name */
1146          FALSE,                 /* partial_inplace */
1147          0,                     /* src_mask */
1148          0xfffc,                /* dst_mask */
1149          FALSE),                /* pcrel_offset */
1150
1151   /* Like R_PPC64_GOT16, but for instructions with a DS field.  */
1152   HOWTO (R_PPC64_GOT16_DS,      /* type */
1153          0,                     /* rightshift */
1154          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1155          16,                    /* bitsize */
1156          FALSE,                 /* pc_relative */
1157          0,                     /* bitpos */
1158          complain_overflow_signed, /* complain_on_overflow */
1159          ppc64_elf_unhandled_reloc, /* special_function */
1160          "R_PPC64_GOT16_DS",    /* name */
1161          FALSE,                 /* partial_inplace */
1162          0,                     /* src_mask */
1163          0xfffc,                /* dst_mask */
1164          FALSE),                /* pcrel_offset */
1165
1166   /* Like R_PPC64_GOT16_LO, but for instructions with a DS field.  */
1167   HOWTO (R_PPC64_GOT16_LO_DS,   /* type */
1168          0,                     /* rightshift */
1169          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1170          16,                    /* bitsize */
1171          FALSE,                 /* pc_relative */
1172          0,                     /* bitpos */
1173          complain_overflow_dont, /* complain_on_overflow */
1174          ppc64_elf_unhandled_reloc, /* special_function */
1175          "R_PPC64_GOT16_LO_DS", /* name */
1176          FALSE,                 /* partial_inplace */
1177          0,                     /* src_mask */
1178          0xfffc,                /* dst_mask */
1179          FALSE),                /* pcrel_offset */
1180
1181   /* Like R_PPC64_PLT16_LO, but for instructions with a DS field.  */
1182   HOWTO (R_PPC64_PLT16_LO_DS,   /* type */
1183          0,                     /* rightshift */
1184          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1185          16,                    /* bitsize */
1186          FALSE,                 /* pc_relative */
1187          0,                     /* bitpos */
1188          complain_overflow_dont, /* complain_on_overflow */
1189          ppc64_elf_unhandled_reloc, /* special_function */
1190          "R_PPC64_PLT16_LO_DS", /* name */
1191          FALSE,                 /* partial_inplace */
1192          0,                     /* src_mask */
1193          0xfffc,                /* dst_mask */
1194          FALSE),                /* pcrel_offset */
1195
1196   /* Like R_PPC64_SECTOFF, but for instructions with a DS field.  */
1197   HOWTO (R_PPC64_SECTOFF_DS,    /* type */
1198          0,                     /* rightshift */
1199          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1200          16,                    /* bitsize */
1201          FALSE,                 /* pc_relative */
1202          0,                     /* bitpos */
1203          complain_overflow_signed, /* complain_on_overflow */
1204          ppc64_elf_sectoff_reloc, /* special_function */
1205          "R_PPC64_SECTOFF_DS",  /* name */
1206          FALSE,                 /* partial_inplace */
1207          0,                     /* src_mask */
1208          0xfffc,                /* dst_mask */
1209          FALSE),                /* pcrel_offset */
1210
1211   /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field.  */
1212   HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1213          0,                     /* rightshift */
1214          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1215          16,                    /* bitsize */
1216          FALSE,                 /* pc_relative */
1217          0,                     /* bitpos */
1218          complain_overflow_dont, /* complain_on_overflow */
1219          ppc64_elf_sectoff_reloc, /* special_function */
1220          "R_PPC64_SECTOFF_LO_DS",/* name */
1221          FALSE,                 /* partial_inplace */
1222          0,                     /* src_mask */
1223          0xfffc,                /* dst_mask */
1224          FALSE),                /* pcrel_offset */
1225
1226   /* Like R_PPC64_TOC16, but for instructions with a DS field.  */
1227   HOWTO (R_PPC64_TOC16_DS,      /* type */
1228          0,                     /* rightshift */
1229          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1230          16,                    /* bitsize */
1231          FALSE,                 /* pc_relative */
1232          0,                     /* bitpos */
1233          complain_overflow_signed, /* complain_on_overflow */
1234          ppc64_elf_toc_reloc,   /* special_function */
1235          "R_PPC64_TOC16_DS",    /* name */
1236          FALSE,                 /* partial_inplace */
1237          0,                     /* src_mask */
1238          0xfffc,                /* dst_mask */
1239          FALSE),                /* pcrel_offset */
1240
1241   /* Like R_PPC64_TOC16_LO, but for instructions with a DS field.  */
1242   HOWTO (R_PPC64_TOC16_LO_DS,   /* type */
1243          0,                     /* rightshift */
1244          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1245          16,                    /* bitsize */
1246          FALSE,                 /* pc_relative */
1247          0,                     /* bitpos */
1248          complain_overflow_dont, /* complain_on_overflow */
1249          ppc64_elf_toc_reloc,   /* special_function */
1250          "R_PPC64_TOC16_LO_DS", /* name */
1251          FALSE,                 /* partial_inplace */
1252          0,                     /* src_mask */
1253          0xfffc,                /* dst_mask */
1254          FALSE),                /* pcrel_offset */
1255
1256   /* Like R_PPC64_PLTGOT16, but for instructions with a DS field.  */
1257   /* FIXME: R_PPC64_PLTGOT16_DS not implemented.  */
1258   HOWTO (R_PPC64_PLTGOT16_DS,   /* type */
1259          0,                     /* rightshift */
1260          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1261          16,                    /* bitsize */
1262          FALSE,                 /* pc_relative */
1263          0,                     /* bitpos */
1264          complain_overflow_signed, /* complain_on_overflow */
1265          ppc64_elf_unhandled_reloc, /* special_function */
1266          "R_PPC64_PLTGOT16_DS", /* name */
1267          FALSE,                 /* partial_inplace */
1268          0,                     /* src_mask */
1269          0xfffc,                /* dst_mask */
1270          FALSE),                /* pcrel_offset */
1271
1272   /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field.  */
1273   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1274   HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1275          0,                     /* rightshift */
1276          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1277          16,                    /* bitsize */
1278          FALSE,                 /* pc_relative */
1279          0,                     /* bitpos */
1280          complain_overflow_dont, /* complain_on_overflow */
1281          ppc64_elf_unhandled_reloc, /* special_function */
1282          "R_PPC64_PLTGOT16_LO_DS",/* name */
1283          FALSE,                 /* partial_inplace */
1284          0,                     /* src_mask */
1285          0xfffc,                /* dst_mask */
1286          FALSE),                /* pcrel_offset */
1287
1288   /* Marker relocs for TLS.  */
1289   HOWTO (R_PPC64_TLS,
1290          0,                     /* rightshift */
1291          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1292          32,                    /* bitsize */
1293          FALSE,                 /* pc_relative */
1294          0,                     /* bitpos */
1295          complain_overflow_dont, /* complain_on_overflow */
1296          bfd_elf_generic_reloc, /* special_function */
1297          "R_PPC64_TLS",         /* name */
1298          FALSE,                 /* partial_inplace */
1299          0,                     /* src_mask */
1300          0,                     /* dst_mask */
1301          FALSE),                /* pcrel_offset */
1302
1303   HOWTO (R_PPC64_TLSGD,
1304          0,                     /* rightshift */
1305          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1306          32,                    /* bitsize */
1307          FALSE,                 /* pc_relative */
1308          0,                     /* bitpos */
1309          complain_overflow_dont, /* complain_on_overflow */
1310          bfd_elf_generic_reloc, /* special_function */
1311          "R_PPC64_TLSGD",       /* name */
1312          FALSE,                 /* partial_inplace */
1313          0,                     /* src_mask */
1314          0,                     /* dst_mask */
1315          FALSE),                /* pcrel_offset */
1316
1317   HOWTO (R_PPC64_TLSLD,
1318          0,                     /* rightshift */
1319          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1320          32,                    /* bitsize */
1321          FALSE,                 /* pc_relative */
1322          0,                     /* bitpos */
1323          complain_overflow_dont, /* complain_on_overflow */
1324          bfd_elf_generic_reloc, /* special_function */
1325          "R_PPC64_TLSLD",       /* name */
1326          FALSE,                 /* partial_inplace */
1327          0,                     /* src_mask */
1328          0,                     /* dst_mask */
1329          FALSE),                /* pcrel_offset */
1330
1331   HOWTO (R_PPC64_TOCSAVE,
1332          0,                     /* rightshift */
1333          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1334          32,                    /* bitsize */
1335          FALSE,                 /* pc_relative */
1336          0,                     /* bitpos */
1337          complain_overflow_dont, /* complain_on_overflow */
1338          bfd_elf_generic_reloc, /* special_function */
1339          "R_PPC64_TOCSAVE",     /* name */
1340          FALSE,                 /* partial_inplace */
1341          0,                     /* src_mask */
1342          0,                     /* dst_mask */
1343          FALSE),                /* pcrel_offset */
1344
1345   /* Computes the load module index of the load module that contains the
1346      definition of its TLS sym.  */
1347   HOWTO (R_PPC64_DTPMOD64,
1348          0,                     /* rightshift */
1349          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1350          64,                    /* bitsize */
1351          FALSE,                 /* pc_relative */
1352          0,                     /* bitpos */
1353          complain_overflow_dont, /* complain_on_overflow */
1354          ppc64_elf_unhandled_reloc, /* special_function */
1355          "R_PPC64_DTPMOD64",    /* name */
1356          FALSE,                 /* partial_inplace */
1357          0,                     /* src_mask */
1358          ONES (64),             /* dst_mask */
1359          FALSE),                /* pcrel_offset */
1360
1361   /* Computes a dtv-relative displacement, the difference between the value
1362      of sym+add and the base address of the thread-local storage block that
1363      contains the definition of sym, minus 0x8000.  */
1364   HOWTO (R_PPC64_DTPREL64,
1365          0,                     /* rightshift */
1366          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1367          64,                    /* bitsize */
1368          FALSE,                 /* pc_relative */
1369          0,                     /* bitpos */
1370          complain_overflow_dont, /* complain_on_overflow */
1371          ppc64_elf_unhandled_reloc, /* special_function */
1372          "R_PPC64_DTPREL64",    /* name */
1373          FALSE,                 /* partial_inplace */
1374          0,                     /* src_mask */
1375          ONES (64),             /* dst_mask */
1376          FALSE),                /* pcrel_offset */
1377
1378   /* A 16 bit dtprel reloc.  */
1379   HOWTO (R_PPC64_DTPREL16,
1380          0,                     /* rightshift */
1381          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1382          16,                    /* bitsize */
1383          FALSE,                 /* pc_relative */
1384          0,                     /* bitpos */
1385          complain_overflow_signed, /* complain_on_overflow */
1386          ppc64_elf_unhandled_reloc, /* special_function */
1387          "R_PPC64_DTPREL16",    /* name */
1388          FALSE,                 /* partial_inplace */
1389          0,                     /* src_mask */
1390          0xffff,                /* dst_mask */
1391          FALSE),                /* pcrel_offset */
1392
1393   /* Like DTPREL16, but no overflow.  */
1394   HOWTO (R_PPC64_DTPREL16_LO,
1395          0,                     /* rightshift */
1396          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1397          16,                    /* bitsize */
1398          FALSE,                 /* pc_relative */
1399          0,                     /* bitpos */
1400          complain_overflow_dont, /* complain_on_overflow */
1401          ppc64_elf_unhandled_reloc, /* special_function */
1402          "R_PPC64_DTPREL16_LO", /* name */
1403          FALSE,                 /* partial_inplace */
1404          0,                     /* src_mask */
1405          0xffff,                /* dst_mask */
1406          FALSE),                /* pcrel_offset */
1407
1408   /* Like DTPREL16_LO, but next higher group of 16 bits.  */
1409   HOWTO (R_PPC64_DTPREL16_HI,
1410          16,                    /* rightshift */
1411          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1412          16,                    /* bitsize */
1413          FALSE,                 /* pc_relative */
1414          0,                     /* bitpos */
1415          complain_overflow_signed, /* complain_on_overflow */
1416          ppc64_elf_unhandled_reloc, /* special_function */
1417          "R_PPC64_DTPREL16_HI", /* name */
1418          FALSE,                 /* partial_inplace */
1419          0,                     /* src_mask */
1420          0xffff,                /* dst_mask */
1421          FALSE),                /* pcrel_offset */
1422
1423   /* Like DTPREL16_HI, but adjust for low 16 bits.  */
1424   HOWTO (R_PPC64_DTPREL16_HA,
1425          16,                    /* rightshift */
1426          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1427          16,                    /* bitsize */
1428          FALSE,                 /* pc_relative */
1429          0,                     /* bitpos */
1430          complain_overflow_signed, /* complain_on_overflow */
1431          ppc64_elf_unhandled_reloc, /* special_function */
1432          "R_PPC64_DTPREL16_HA", /* name */
1433          FALSE,                 /* partial_inplace */
1434          0,                     /* src_mask */
1435          0xffff,                /* dst_mask */
1436          FALSE),                /* pcrel_offset */
1437
1438   /* Like DTPREL16_HI, but next higher group of 16 bits.  */
1439   HOWTO (R_PPC64_DTPREL16_HIGHER,
1440          32,                    /* rightshift */
1441          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1442          16,                    /* bitsize */
1443          FALSE,                 /* pc_relative */
1444          0,                     /* bitpos */
1445          complain_overflow_dont, /* complain_on_overflow */
1446          ppc64_elf_unhandled_reloc, /* special_function */
1447          "R_PPC64_DTPREL16_HIGHER", /* name */
1448          FALSE,                 /* partial_inplace */
1449          0,                     /* src_mask */
1450          0xffff,                /* dst_mask */
1451          FALSE),                /* pcrel_offset */
1452
1453   /* Like DTPREL16_HIGHER, but adjust for low 16 bits.  */
1454   HOWTO (R_PPC64_DTPREL16_HIGHERA,
1455          32,                    /* rightshift */
1456          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1457          16,                    /* bitsize */
1458          FALSE,                 /* pc_relative */
1459          0,                     /* bitpos */
1460          complain_overflow_dont, /* complain_on_overflow */
1461          ppc64_elf_unhandled_reloc, /* special_function */
1462          "R_PPC64_DTPREL16_HIGHERA", /* name */
1463          FALSE,                 /* partial_inplace */
1464          0,                     /* src_mask */
1465          0xffff,                /* dst_mask */
1466          FALSE),                /* pcrel_offset */
1467
1468   /* Like DTPREL16_HIGHER, but next higher group of 16 bits.  */
1469   HOWTO (R_PPC64_DTPREL16_HIGHEST,
1470          48,                    /* rightshift */
1471          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1472          16,                    /* bitsize */
1473          FALSE,                 /* pc_relative */
1474          0,                     /* bitpos */
1475          complain_overflow_dont, /* complain_on_overflow */
1476          ppc64_elf_unhandled_reloc, /* special_function */
1477          "R_PPC64_DTPREL16_HIGHEST", /* name */
1478          FALSE,                 /* partial_inplace */
1479          0,                     /* src_mask */
1480          0xffff,                /* dst_mask */
1481          FALSE),                /* pcrel_offset */
1482
1483   /* Like DTPREL16_HIGHEST, but adjust for low 16 bits.  */
1484   HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1485          48,                    /* rightshift */
1486          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1487          16,                    /* bitsize */
1488          FALSE,                 /* pc_relative */
1489          0,                     /* bitpos */
1490          complain_overflow_dont, /* complain_on_overflow */
1491          ppc64_elf_unhandled_reloc, /* special_function */
1492          "R_PPC64_DTPREL16_HIGHESTA", /* name */
1493          FALSE,                 /* partial_inplace */
1494          0,                     /* src_mask */
1495          0xffff,                /* dst_mask */
1496          FALSE),                /* pcrel_offset */
1497
1498   /* Like DTPREL16, but for insns with a DS field.  */
1499   HOWTO (R_PPC64_DTPREL16_DS,
1500          0,                     /* rightshift */
1501          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1502          16,                    /* bitsize */
1503          FALSE,                 /* pc_relative */
1504          0,                     /* bitpos */
1505          complain_overflow_signed, /* complain_on_overflow */
1506          ppc64_elf_unhandled_reloc, /* special_function */
1507          "R_PPC64_DTPREL16_DS", /* name */
1508          FALSE,                 /* partial_inplace */
1509          0,                     /* src_mask */
1510          0xfffc,                /* dst_mask */
1511          FALSE),                /* pcrel_offset */
1512
1513   /* Like DTPREL16_DS, but no overflow.  */
1514   HOWTO (R_PPC64_DTPREL16_LO_DS,
1515          0,                     /* rightshift */
1516          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1517          16,                    /* bitsize */
1518          FALSE,                 /* pc_relative */
1519          0,                     /* bitpos */
1520          complain_overflow_dont, /* complain_on_overflow */
1521          ppc64_elf_unhandled_reloc, /* special_function */
1522          "R_PPC64_DTPREL16_LO_DS", /* name */
1523          FALSE,                 /* partial_inplace */
1524          0,                     /* src_mask */
1525          0xfffc,                /* dst_mask */
1526          FALSE),                /* pcrel_offset */
1527
1528   /* Computes a tp-relative displacement, the difference between the value of
1529      sym+add and the value of the thread pointer (r13).  */
1530   HOWTO (R_PPC64_TPREL64,
1531          0,                     /* rightshift */
1532          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1533          64,                    /* bitsize */
1534          FALSE,                 /* pc_relative */
1535          0,                     /* bitpos */
1536          complain_overflow_dont, /* complain_on_overflow */
1537          ppc64_elf_unhandled_reloc, /* special_function */
1538          "R_PPC64_TPREL64",     /* name */
1539          FALSE,                 /* partial_inplace */
1540          0,                     /* src_mask */
1541          ONES (64),             /* dst_mask */
1542          FALSE),                /* pcrel_offset */
1543
1544   /* A 16 bit tprel reloc.  */
1545   HOWTO (R_PPC64_TPREL16,
1546          0,                     /* rightshift */
1547          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1548          16,                    /* bitsize */
1549          FALSE,                 /* pc_relative */
1550          0,                     /* bitpos */
1551          complain_overflow_signed, /* complain_on_overflow */
1552          ppc64_elf_unhandled_reloc, /* special_function */
1553          "R_PPC64_TPREL16",     /* name */
1554          FALSE,                 /* partial_inplace */
1555          0,                     /* src_mask */
1556          0xffff,                /* dst_mask */
1557          FALSE),                /* pcrel_offset */
1558
1559   /* Like TPREL16, but no overflow.  */
1560   HOWTO (R_PPC64_TPREL16_LO,
1561          0,                     /* rightshift */
1562          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1563          16,                    /* bitsize */
1564          FALSE,                 /* pc_relative */
1565          0,                     /* bitpos */
1566          complain_overflow_dont, /* complain_on_overflow */
1567          ppc64_elf_unhandled_reloc, /* special_function */
1568          "R_PPC64_TPREL16_LO",  /* name */
1569          FALSE,                 /* partial_inplace */
1570          0,                     /* src_mask */
1571          0xffff,                /* dst_mask */
1572          FALSE),                /* pcrel_offset */
1573
1574   /* Like TPREL16_LO, but next higher group of 16 bits.  */
1575   HOWTO (R_PPC64_TPREL16_HI,
1576          16,                    /* rightshift */
1577          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1578          16,                    /* bitsize */
1579          FALSE,                 /* pc_relative */
1580          0,                     /* bitpos */
1581          complain_overflow_signed, /* complain_on_overflow */
1582          ppc64_elf_unhandled_reloc, /* special_function */
1583          "R_PPC64_TPREL16_HI",  /* name */
1584          FALSE,                 /* partial_inplace */
1585          0,                     /* src_mask */
1586          0xffff,                /* dst_mask */
1587          FALSE),                /* pcrel_offset */
1588
1589   /* Like TPREL16_HI, but adjust for low 16 bits.  */
1590   HOWTO (R_PPC64_TPREL16_HA,
1591          16,                    /* rightshift */
1592          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1593          16,                    /* bitsize */
1594          FALSE,                 /* pc_relative */
1595          0,                     /* bitpos */
1596          complain_overflow_signed, /* complain_on_overflow */
1597          ppc64_elf_unhandled_reloc, /* special_function */
1598          "R_PPC64_TPREL16_HA",  /* name */
1599          FALSE,                 /* partial_inplace */
1600          0,                     /* src_mask */
1601          0xffff,                /* dst_mask */
1602          FALSE),                /* pcrel_offset */
1603
1604   /* Like TPREL16_HI, but next higher group of 16 bits.  */
1605   HOWTO (R_PPC64_TPREL16_HIGHER,
1606          32,                    /* rightshift */
1607          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1608          16,                    /* bitsize */
1609          FALSE,                 /* pc_relative */
1610          0,                     /* bitpos */
1611          complain_overflow_dont, /* complain_on_overflow */
1612          ppc64_elf_unhandled_reloc, /* special_function */
1613          "R_PPC64_TPREL16_HIGHER",      /* name */
1614          FALSE,                 /* partial_inplace */
1615          0,                     /* src_mask */
1616          0xffff,                /* dst_mask */
1617          FALSE),                /* pcrel_offset */
1618
1619   /* Like TPREL16_HIGHER, but adjust for low 16 bits.  */
1620   HOWTO (R_PPC64_TPREL16_HIGHERA,
1621          32,                    /* rightshift */
1622          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1623          16,                    /* bitsize */
1624          FALSE,                 /* pc_relative */
1625          0,                     /* bitpos */
1626          complain_overflow_dont, /* complain_on_overflow */
1627          ppc64_elf_unhandled_reloc, /* special_function */
1628          "R_PPC64_TPREL16_HIGHERA", /* name */
1629          FALSE,                 /* partial_inplace */
1630          0,                     /* src_mask */
1631          0xffff,                /* dst_mask */
1632          FALSE),                /* pcrel_offset */
1633
1634   /* Like TPREL16_HIGHER, but next higher group of 16 bits.  */
1635   HOWTO (R_PPC64_TPREL16_HIGHEST,
1636          48,                    /* rightshift */
1637          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1638          16,                    /* bitsize */
1639          FALSE,                 /* pc_relative */
1640          0,                     /* bitpos */
1641          complain_overflow_dont, /* complain_on_overflow */
1642          ppc64_elf_unhandled_reloc, /* special_function */
1643          "R_PPC64_TPREL16_HIGHEST", /* name */
1644          FALSE,                 /* partial_inplace */
1645          0,                     /* src_mask */
1646          0xffff,                /* dst_mask */
1647          FALSE),                /* pcrel_offset */
1648
1649   /* Like TPREL16_HIGHEST, but adjust for low 16 bits.  */
1650   HOWTO (R_PPC64_TPREL16_HIGHESTA,
1651          48,                    /* rightshift */
1652          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1653          16,                    /* bitsize */
1654          FALSE,                 /* pc_relative */
1655          0,                     /* bitpos */
1656          complain_overflow_dont, /* complain_on_overflow */
1657          ppc64_elf_unhandled_reloc, /* special_function */
1658          "R_PPC64_TPREL16_HIGHESTA", /* name */
1659          FALSE,                 /* partial_inplace */
1660          0,                     /* src_mask */
1661          0xffff,                /* dst_mask */
1662          FALSE),                /* pcrel_offset */
1663
1664   /* Like TPREL16, but for insns with a DS field.  */
1665   HOWTO (R_PPC64_TPREL16_DS,
1666          0,                     /* rightshift */
1667          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1668          16,                    /* bitsize */
1669          FALSE,                 /* pc_relative */
1670          0,                     /* bitpos */
1671          complain_overflow_signed, /* complain_on_overflow */
1672          ppc64_elf_unhandled_reloc, /* special_function */
1673          "R_PPC64_TPREL16_DS",  /* name */
1674          FALSE,                 /* partial_inplace */
1675          0,                     /* src_mask */
1676          0xfffc,                /* dst_mask */
1677          FALSE),                /* pcrel_offset */
1678
1679   /* Like TPREL16_DS, but no overflow.  */
1680   HOWTO (R_PPC64_TPREL16_LO_DS,
1681          0,                     /* rightshift */
1682          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1683          16,                    /* bitsize */
1684          FALSE,                 /* pc_relative */
1685          0,                     /* bitpos */
1686          complain_overflow_dont, /* complain_on_overflow */
1687          ppc64_elf_unhandled_reloc, /* special_function */
1688          "R_PPC64_TPREL16_LO_DS", /* name */
1689          FALSE,                 /* partial_inplace */
1690          0,                     /* src_mask */
1691          0xfffc,                /* dst_mask */
1692          FALSE),                /* pcrel_offset */
1693
1694   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1695      with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1696      to the first entry relative to the TOC base (r2).  */
1697   HOWTO (R_PPC64_GOT_TLSGD16,
1698          0,                     /* rightshift */
1699          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1700          16,                    /* bitsize */
1701          FALSE,                 /* pc_relative */
1702          0,                     /* bitpos */
1703          complain_overflow_signed, /* complain_on_overflow */
1704          ppc64_elf_unhandled_reloc, /* special_function */
1705          "R_PPC64_GOT_TLSGD16", /* name */
1706          FALSE,                 /* partial_inplace */
1707          0,                     /* src_mask */
1708          0xffff,                /* dst_mask */
1709          FALSE),                /* pcrel_offset */
1710
1711   /* Like GOT_TLSGD16, but no overflow.  */
1712   HOWTO (R_PPC64_GOT_TLSGD16_LO,
1713          0,                     /* rightshift */
1714          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1715          16,                    /* bitsize */
1716          FALSE,                 /* pc_relative */
1717          0,                     /* bitpos */
1718          complain_overflow_dont, /* complain_on_overflow */
1719          ppc64_elf_unhandled_reloc, /* special_function */
1720          "R_PPC64_GOT_TLSGD16_LO", /* name */
1721          FALSE,                 /* partial_inplace */
1722          0,                     /* src_mask */
1723          0xffff,                /* dst_mask */
1724          FALSE),                /* pcrel_offset */
1725
1726   /* Like GOT_TLSGD16_LO, but next higher group of 16 bits.  */
1727   HOWTO (R_PPC64_GOT_TLSGD16_HI,
1728          16,                    /* rightshift */
1729          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1730          16,                    /* bitsize */
1731          FALSE,                 /* pc_relative */
1732          0,                     /* bitpos */
1733          complain_overflow_signed, /* complain_on_overflow */
1734          ppc64_elf_unhandled_reloc, /* special_function */
1735          "R_PPC64_GOT_TLSGD16_HI", /* name */
1736          FALSE,                 /* partial_inplace */
1737          0,                     /* src_mask */
1738          0xffff,                /* dst_mask */
1739          FALSE),                /* pcrel_offset */
1740
1741   /* Like GOT_TLSGD16_HI, but adjust for low 16 bits.  */
1742   HOWTO (R_PPC64_GOT_TLSGD16_HA,
1743          16,                    /* rightshift */
1744          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1745          16,                    /* bitsize */
1746          FALSE,                 /* pc_relative */
1747          0,                     /* bitpos */
1748          complain_overflow_signed, /* complain_on_overflow */
1749          ppc64_elf_unhandled_reloc, /* special_function */
1750          "R_PPC64_GOT_TLSGD16_HA", /* name */
1751          FALSE,                 /* partial_inplace */
1752          0,                     /* src_mask */
1753          0xffff,                /* dst_mask */
1754          FALSE),                /* pcrel_offset */
1755
1756   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1757      with values (sym+add)@dtpmod and zero, and computes the offset to the
1758      first entry relative to the TOC base (r2).  */
1759   HOWTO (R_PPC64_GOT_TLSLD16,
1760          0,                     /* rightshift */
1761          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1762          16,                    /* bitsize */
1763          FALSE,                 /* pc_relative */
1764          0,                     /* bitpos */
1765          complain_overflow_signed, /* complain_on_overflow */
1766          ppc64_elf_unhandled_reloc, /* special_function */
1767          "R_PPC64_GOT_TLSLD16", /* name */
1768          FALSE,                 /* partial_inplace */
1769          0,                     /* src_mask */
1770          0xffff,                /* dst_mask */
1771          FALSE),                /* pcrel_offset */
1772
1773   /* Like GOT_TLSLD16, but no overflow.  */
1774   HOWTO (R_PPC64_GOT_TLSLD16_LO,
1775          0,                     /* rightshift */
1776          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1777          16,                    /* bitsize */
1778          FALSE,                 /* pc_relative */
1779          0,                     /* bitpos */
1780          complain_overflow_dont, /* complain_on_overflow */
1781          ppc64_elf_unhandled_reloc, /* special_function */
1782          "R_PPC64_GOT_TLSLD16_LO", /* name */
1783          FALSE,                 /* partial_inplace */
1784          0,                     /* src_mask */
1785          0xffff,                /* dst_mask */
1786          FALSE),                /* pcrel_offset */
1787
1788   /* Like GOT_TLSLD16_LO, but next higher group of 16 bits.  */
1789   HOWTO (R_PPC64_GOT_TLSLD16_HI,
1790          16,                    /* rightshift */
1791          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1792          16,                    /* bitsize */
1793          FALSE,                 /* pc_relative */
1794          0,                     /* bitpos */
1795          complain_overflow_signed, /* complain_on_overflow */
1796          ppc64_elf_unhandled_reloc, /* special_function */
1797          "R_PPC64_GOT_TLSLD16_HI", /* name */
1798          FALSE,                 /* partial_inplace */
1799          0,                     /* src_mask */
1800          0xffff,                /* dst_mask */
1801          FALSE),                /* pcrel_offset */
1802
1803   /* Like GOT_TLSLD16_HI, but adjust for low 16 bits.  */
1804   HOWTO (R_PPC64_GOT_TLSLD16_HA,
1805          16,                    /* rightshift */
1806          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1807          16,                    /* bitsize */
1808          FALSE,                 /* pc_relative */
1809          0,                     /* bitpos */
1810          complain_overflow_signed, /* complain_on_overflow */
1811          ppc64_elf_unhandled_reloc, /* special_function */
1812          "R_PPC64_GOT_TLSLD16_HA", /* name */
1813          FALSE,                 /* partial_inplace */
1814          0,                     /* src_mask */
1815          0xffff,                /* dst_mask */
1816          FALSE),                /* pcrel_offset */
1817
1818   /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1819      the offset to the entry relative to the TOC base (r2).  */
1820   HOWTO (R_PPC64_GOT_DTPREL16_DS,
1821          0,                     /* rightshift */
1822          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1823          16,                    /* bitsize */
1824          FALSE,                 /* pc_relative */
1825          0,                     /* bitpos */
1826          complain_overflow_signed, /* complain_on_overflow */
1827          ppc64_elf_unhandled_reloc, /* special_function */
1828          "R_PPC64_GOT_DTPREL16_DS", /* name */
1829          FALSE,                 /* partial_inplace */
1830          0,                     /* src_mask */
1831          0xfffc,                /* dst_mask */
1832          FALSE),                /* pcrel_offset */
1833
1834   /* Like GOT_DTPREL16_DS, but no overflow.  */
1835   HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1836          0,                     /* rightshift */
1837          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1838          16,                    /* bitsize */
1839          FALSE,                 /* pc_relative */
1840          0,                     /* bitpos */
1841          complain_overflow_dont, /* complain_on_overflow */
1842          ppc64_elf_unhandled_reloc, /* special_function */
1843          "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1844          FALSE,                 /* partial_inplace */
1845          0,                     /* src_mask */
1846          0xfffc,                /* dst_mask */
1847          FALSE),                /* pcrel_offset */
1848
1849   /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits.  */
1850   HOWTO (R_PPC64_GOT_DTPREL16_HI,
1851          16,                    /* rightshift */
1852          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1853          16,                    /* bitsize */
1854          FALSE,                 /* pc_relative */
1855          0,                     /* bitpos */
1856          complain_overflow_signed, /* complain_on_overflow */
1857          ppc64_elf_unhandled_reloc, /* special_function */
1858          "R_PPC64_GOT_DTPREL16_HI", /* name */
1859          FALSE,                 /* partial_inplace */
1860          0,                     /* src_mask */
1861          0xffff,                /* dst_mask */
1862          FALSE),                /* pcrel_offset */
1863
1864   /* Like GOT_DTPREL16_HI, but adjust for low 16 bits.  */
1865   HOWTO (R_PPC64_GOT_DTPREL16_HA,
1866          16,                    /* rightshift */
1867          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1868          16,                    /* bitsize */
1869          FALSE,                 /* pc_relative */
1870          0,                     /* bitpos */
1871          complain_overflow_signed, /* complain_on_overflow */
1872          ppc64_elf_unhandled_reloc, /* special_function */
1873          "R_PPC64_GOT_DTPREL16_HA", /* name */
1874          FALSE,                 /* partial_inplace */
1875          0,                     /* src_mask */
1876          0xffff,                /* dst_mask */
1877          FALSE),                /* pcrel_offset */
1878
1879   /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1880      offset to the entry relative to the TOC base (r2).  */
1881   HOWTO (R_PPC64_GOT_TPREL16_DS,
1882          0,                     /* rightshift */
1883          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1884          16,                    /* bitsize */
1885          FALSE,                 /* pc_relative */
1886          0,                     /* bitpos */
1887          complain_overflow_signed, /* complain_on_overflow */
1888          ppc64_elf_unhandled_reloc, /* special_function */
1889          "R_PPC64_GOT_TPREL16_DS", /* name */
1890          FALSE,                 /* partial_inplace */
1891          0,                     /* src_mask */
1892          0xfffc,                /* dst_mask */
1893          FALSE),                /* pcrel_offset */
1894
1895   /* Like GOT_TPREL16_DS, but no overflow.  */
1896   HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1897          0,                     /* rightshift */
1898          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1899          16,                    /* bitsize */
1900          FALSE,                 /* pc_relative */
1901          0,                     /* bitpos */
1902          complain_overflow_dont, /* complain_on_overflow */
1903          ppc64_elf_unhandled_reloc, /* special_function */
1904          "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1905          FALSE,                 /* partial_inplace */
1906          0,                     /* src_mask */
1907          0xfffc,                /* dst_mask */
1908          FALSE),                /* pcrel_offset */
1909
1910   /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits.  */
1911   HOWTO (R_PPC64_GOT_TPREL16_HI,
1912          16,                    /* rightshift */
1913          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1914          16,                    /* bitsize */
1915          FALSE,                 /* pc_relative */
1916          0,                     /* bitpos */
1917          complain_overflow_signed, /* complain_on_overflow */
1918          ppc64_elf_unhandled_reloc, /* special_function */
1919          "R_PPC64_GOT_TPREL16_HI", /* name */
1920          FALSE,                 /* partial_inplace */
1921          0,                     /* src_mask */
1922          0xffff,                /* dst_mask */
1923          FALSE),                /* pcrel_offset */
1924
1925   /* Like GOT_TPREL16_HI, but adjust for low 16 bits.  */
1926   HOWTO (R_PPC64_GOT_TPREL16_HA,
1927          16,                    /* rightshift */
1928          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1929          16,                    /* bitsize */
1930          FALSE,                 /* pc_relative */
1931          0,                     /* bitpos */
1932          complain_overflow_signed, /* complain_on_overflow */
1933          ppc64_elf_unhandled_reloc, /* special_function */
1934          "R_PPC64_GOT_TPREL16_HA", /* name */
1935          FALSE,                 /* partial_inplace */
1936          0,                     /* src_mask */
1937          0xffff,                /* dst_mask */
1938          FALSE),                /* pcrel_offset */
1939
1940   HOWTO (R_PPC64_JMP_IREL,      /* type */
1941          0,                     /* rightshift */
1942          0,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1943          0,                     /* bitsize */
1944          FALSE,                 /* pc_relative */
1945          0,                     /* bitpos */
1946          complain_overflow_dont, /* complain_on_overflow */
1947          ppc64_elf_unhandled_reloc, /* special_function */
1948          "R_PPC64_JMP_IREL",    /* name */
1949          FALSE,                 /* partial_inplace */
1950          0,                     /* src_mask */
1951          0,                     /* dst_mask */
1952          FALSE),                /* pcrel_offset */
1953
1954   HOWTO (R_PPC64_IRELATIVE,     /* type */
1955          0,                     /* rightshift */
1956          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1957          64,                    /* bitsize */
1958          FALSE,                 /* pc_relative */
1959          0,                     /* bitpos */
1960          complain_overflow_dont, /* complain_on_overflow */
1961          bfd_elf_generic_reloc, /* special_function */
1962          "R_PPC64_IRELATIVE",   /* name */
1963          FALSE,                 /* partial_inplace */
1964          0,                     /* src_mask */
1965          ONES (64),             /* dst_mask */
1966          FALSE),                /* pcrel_offset */
1967
1968   /* A 16 bit relative relocation.  */
1969   HOWTO (R_PPC64_REL16,         /* type */
1970          0,                     /* rightshift */
1971          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1972          16,                    /* bitsize */
1973          TRUE,                  /* pc_relative */
1974          0,                     /* bitpos */
1975          complain_overflow_signed, /* complain_on_overflow */
1976          bfd_elf_generic_reloc, /* special_function */
1977          "R_PPC64_REL16",       /* name */
1978          FALSE,                 /* partial_inplace */
1979          0,                     /* src_mask */
1980          0xffff,                /* dst_mask */
1981          TRUE),                 /* pcrel_offset */
1982
1983   /* A 16 bit relative relocation without overflow.  */
1984   HOWTO (R_PPC64_REL16_LO,      /* type */
1985          0,                     /* rightshift */
1986          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1987          16,                    /* bitsize */
1988          TRUE,                  /* pc_relative */
1989          0,                     /* bitpos */
1990          complain_overflow_dont,/* complain_on_overflow */
1991          bfd_elf_generic_reloc, /* special_function */
1992          "R_PPC64_REL16_LO",    /* name */
1993          FALSE,                 /* partial_inplace */
1994          0,                     /* src_mask */
1995          0xffff,                /* dst_mask */
1996          TRUE),                 /* pcrel_offset */
1997
1998   /* The high order 16 bits of a relative address.  */
1999   HOWTO (R_PPC64_REL16_HI,      /* type */
2000          16,                    /* rightshift */
2001          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2002          16,                    /* bitsize */
2003          TRUE,                  /* pc_relative */
2004          0,                     /* bitpos */
2005          complain_overflow_signed, /* complain_on_overflow */
2006          bfd_elf_generic_reloc, /* special_function */
2007          "R_PPC64_REL16_HI",    /* name */
2008          FALSE,                 /* partial_inplace */
2009          0,                     /* src_mask */
2010          0xffff,                /* dst_mask */
2011          TRUE),                 /* pcrel_offset */
2012
2013   /* The high order 16 bits of a relative address, plus 1 if the contents of
2014      the low 16 bits, treated as a signed number, is negative.  */
2015   HOWTO (R_PPC64_REL16_HA,      /* type */
2016          16,                    /* rightshift */
2017          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2018          16,                    /* bitsize */
2019          TRUE,                  /* pc_relative */
2020          0,                     /* bitpos */
2021          complain_overflow_signed, /* complain_on_overflow */
2022          ppc64_elf_ha_reloc,    /* special_function */
2023          "R_PPC64_REL16_HA",    /* name */
2024          FALSE,                 /* partial_inplace */
2025          0,                     /* src_mask */
2026          0xffff,                /* dst_mask */
2027          TRUE),                 /* pcrel_offset */
2028
2029   /* Like R_PPC64_REL16_HA but for split field in addpcis.  */
2030   HOWTO (R_PPC64_REL16DX_HA,    /* type */
2031          16,                    /* rightshift */
2032          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2033          16,                    /* bitsize */
2034          TRUE,                  /* pc_relative */
2035          0,                     /* bitpos */
2036          complain_overflow_signed, /* complain_on_overflow */
2037          ppc64_elf_ha_reloc,    /* special_function */
2038          "R_PPC64_REL16DX_HA",  /* name */
2039          FALSE,                 /* partial_inplace */
2040          0,                     /* src_mask */
2041          0x1fffc1,              /* dst_mask */
2042          TRUE),                 /* pcrel_offset */
2043
2044   /* Like R_PPC64_ADDR16_HI, but no overflow.  */
2045   HOWTO (R_PPC64_ADDR16_HIGH,   /* type */
2046          16,                    /* rightshift */
2047          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2048          16,                    /* bitsize */
2049          FALSE,                 /* pc_relative */
2050          0,                     /* bitpos */
2051          complain_overflow_dont, /* complain_on_overflow */
2052          bfd_elf_generic_reloc, /* special_function */
2053          "R_PPC64_ADDR16_HIGH", /* name */
2054          FALSE,                 /* partial_inplace */
2055          0,                     /* src_mask */
2056          0xffff,                /* dst_mask */
2057          FALSE),                /* pcrel_offset */
2058
2059   /* Like R_PPC64_ADDR16_HA, but no overflow.  */
2060   HOWTO (R_PPC64_ADDR16_HIGHA,  /* type */
2061          16,                    /* rightshift */
2062          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2063          16,                    /* bitsize */
2064          FALSE,                 /* pc_relative */
2065          0,                     /* bitpos */
2066          complain_overflow_dont, /* complain_on_overflow */
2067          ppc64_elf_ha_reloc,    /* special_function */
2068          "R_PPC64_ADDR16_HIGHA",        /* name */
2069          FALSE,                 /* partial_inplace */
2070          0,                     /* src_mask */
2071          0xffff,                /* dst_mask */
2072          FALSE),                /* pcrel_offset */
2073
2074   /* Like R_PPC64_DTPREL16_HI, but no overflow.  */
2075   HOWTO (R_PPC64_DTPREL16_HIGH,
2076          16,                    /* rightshift */
2077          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2078          16,                    /* bitsize */
2079          FALSE,                 /* pc_relative */
2080          0,                     /* bitpos */
2081          complain_overflow_dont, /* complain_on_overflow */
2082          ppc64_elf_unhandled_reloc, /* special_function */
2083          "R_PPC64_DTPREL16_HIGH", /* name */
2084          FALSE,                 /* partial_inplace */
2085          0,                     /* src_mask */
2086          0xffff,                /* dst_mask */
2087          FALSE),                /* pcrel_offset */
2088
2089   /* Like R_PPC64_DTPREL16_HA, but no overflow.  */
2090   HOWTO (R_PPC64_DTPREL16_HIGHA,
2091          16,                    /* rightshift */
2092          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2093          16,                    /* bitsize */
2094          FALSE,                 /* pc_relative */
2095          0,                     /* bitpos */
2096          complain_overflow_dont, /* complain_on_overflow */
2097          ppc64_elf_unhandled_reloc, /* special_function */
2098          "R_PPC64_DTPREL16_HIGHA", /* name */
2099          FALSE,                 /* partial_inplace */
2100          0,                     /* src_mask */
2101          0xffff,                /* dst_mask */
2102          FALSE),                /* pcrel_offset */
2103
2104   /* Like R_PPC64_TPREL16_HI, but no overflow.  */
2105   HOWTO (R_PPC64_TPREL16_HIGH,
2106          16,                    /* rightshift */
2107          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2108          16,                    /* bitsize */
2109          FALSE,                 /* pc_relative */
2110          0,                     /* bitpos */
2111          complain_overflow_dont, /* complain_on_overflow */
2112          ppc64_elf_unhandled_reloc, /* special_function */
2113          "R_PPC64_TPREL16_HIGH",        /* name */
2114          FALSE,                 /* partial_inplace */
2115          0,                     /* src_mask */
2116          0xffff,                /* dst_mask */
2117          FALSE),                /* pcrel_offset */
2118
2119   /* Like R_PPC64_TPREL16_HA, but no overflow.  */
2120   HOWTO (R_PPC64_TPREL16_HIGHA,
2121          16,                    /* rightshift */
2122          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2123          16,                    /* bitsize */
2124          FALSE,                 /* pc_relative */
2125          0,                     /* bitpos */
2126          complain_overflow_dont, /* complain_on_overflow */
2127          ppc64_elf_unhandled_reloc, /* special_function */
2128          "R_PPC64_TPREL16_HIGHA",       /* name */
2129          FALSE,                 /* partial_inplace */
2130          0,                     /* src_mask */
2131          0xffff,                /* dst_mask */
2132          FALSE),                /* pcrel_offset */
2133
2134   /* Marker reloc on ELFv2 large-model function entry.  */
2135   HOWTO (R_PPC64_ENTRY,
2136          0,                     /* rightshift */
2137          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2138          32,                    /* bitsize */
2139          FALSE,                 /* pc_relative */
2140          0,                     /* bitpos */
2141          complain_overflow_dont, /* complain_on_overflow */
2142          bfd_elf_generic_reloc, /* special_function */
2143          "R_PPC64_ENTRY",       /* name */
2144          FALSE,                 /* partial_inplace */
2145          0,                     /* src_mask */
2146          0,                     /* dst_mask */
2147          FALSE),                /* pcrel_offset */
2148
2149   /* Like ADDR64, but use local entry point of function.  */
2150   HOWTO (R_PPC64_ADDR64_LOCAL,  /* type */
2151          0,                     /* rightshift */
2152          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2153          64,                    /* bitsize */
2154          FALSE,                 /* pc_relative */
2155          0,                     /* bitpos */
2156          complain_overflow_dont, /* complain_on_overflow */
2157          bfd_elf_generic_reloc, /* special_function */
2158          "R_PPC64_ADDR64_LOCAL", /* name */
2159          FALSE,                 /* partial_inplace */
2160          0,                     /* src_mask */
2161          ONES (64),             /* dst_mask */
2162          FALSE),                /* pcrel_offset */
2163
2164   /* GNU extension to record C++ vtable hierarchy.  */
2165   HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2166          0,                     /* rightshift */
2167          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2168          0,                     /* bitsize */
2169          FALSE,                 /* pc_relative */
2170          0,                     /* bitpos */
2171          complain_overflow_dont, /* complain_on_overflow */
2172          NULL,                  /* special_function */
2173          "R_PPC64_GNU_VTINHERIT", /* name */
2174          FALSE,                 /* partial_inplace */
2175          0,                     /* src_mask */
2176          0,                     /* dst_mask */
2177          FALSE),                /* pcrel_offset */
2178
2179   /* GNU extension to record C++ vtable member usage.  */
2180   HOWTO (R_PPC64_GNU_VTENTRY,   /* type */
2181          0,                     /* rightshift */
2182          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2183          0,                     /* bitsize */
2184          FALSE,                 /* pc_relative */
2185          0,                     /* bitpos */
2186          complain_overflow_dont, /* complain_on_overflow */
2187          NULL,                  /* special_function */
2188          "R_PPC64_GNU_VTENTRY", /* name */
2189          FALSE,                 /* partial_inplace */
2190          0,                     /* src_mask */
2191          0,                     /* dst_mask */
2192          FALSE),                /* pcrel_offset */
2193 };
2194
2195 \f
2196 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2197    be done.  */
2198
2199 static void
2200 ppc_howto_init (void)
2201 {
2202   unsigned int i, type;
2203
2204   for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2205     {
2206       type = ppc64_elf_howto_raw[i].type;
2207       BFD_ASSERT (type < ARRAY_SIZE (ppc64_elf_howto_table));
2208       ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2209     }
2210 }
2211
2212 static reloc_howto_type *
2213 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2214                              bfd_reloc_code_real_type code)
2215 {
2216   enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2217
2218   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2219     /* Initialize howto table if needed.  */
2220     ppc_howto_init ();
2221
2222   switch (code)
2223     {
2224     default:
2225       return NULL;
2226
2227     case BFD_RELOC_NONE:                        r = R_PPC64_NONE;
2228       break;
2229     case BFD_RELOC_32:                          r = R_PPC64_ADDR32;
2230       break;
2231     case BFD_RELOC_PPC_BA26:                    r = R_PPC64_ADDR24;
2232       break;
2233     case BFD_RELOC_16:                          r = R_PPC64_ADDR16;
2234       break;
2235     case BFD_RELOC_LO16:                        r = R_PPC64_ADDR16_LO;
2236       break;
2237     case BFD_RELOC_HI16:                        r = R_PPC64_ADDR16_HI;
2238       break;
2239     case BFD_RELOC_PPC64_ADDR16_HIGH:           r = R_PPC64_ADDR16_HIGH;
2240       break;
2241     case BFD_RELOC_HI16_S:                      r = R_PPC64_ADDR16_HA;
2242       break;
2243     case BFD_RELOC_PPC64_ADDR16_HIGHA:          r = R_PPC64_ADDR16_HIGHA;
2244       break;
2245     case BFD_RELOC_PPC_BA16:                    r = R_PPC64_ADDR14;
2246       break;
2247     case BFD_RELOC_PPC_BA16_BRTAKEN:            r = R_PPC64_ADDR14_BRTAKEN;
2248       break;
2249     case BFD_RELOC_PPC_BA16_BRNTAKEN:           r = R_PPC64_ADDR14_BRNTAKEN;
2250       break;
2251     case BFD_RELOC_PPC_B26:                     r = R_PPC64_REL24;
2252       break;
2253     case BFD_RELOC_PPC_B16:                     r = R_PPC64_REL14;
2254       break;
2255     case BFD_RELOC_PPC_B16_BRTAKEN:             r = R_PPC64_REL14_BRTAKEN;
2256       break;
2257     case BFD_RELOC_PPC_B16_BRNTAKEN:            r = R_PPC64_REL14_BRNTAKEN;
2258       break;
2259     case BFD_RELOC_16_GOTOFF:                   r = R_PPC64_GOT16;
2260       break;
2261     case BFD_RELOC_LO16_GOTOFF:                 r = R_PPC64_GOT16_LO;
2262       break;
2263     case BFD_RELOC_HI16_GOTOFF:                 r = R_PPC64_GOT16_HI;
2264       break;
2265     case BFD_RELOC_HI16_S_GOTOFF:               r = R_PPC64_GOT16_HA;
2266       break;
2267     case BFD_RELOC_PPC_COPY:                    r = R_PPC64_COPY;
2268       break;
2269     case BFD_RELOC_PPC_GLOB_DAT:                r = R_PPC64_GLOB_DAT;
2270       break;
2271     case BFD_RELOC_32_PCREL:                    r = R_PPC64_REL32;
2272       break;
2273     case BFD_RELOC_32_PLTOFF:                   r = R_PPC64_PLT32;
2274       break;
2275     case BFD_RELOC_32_PLT_PCREL:                r = R_PPC64_PLTREL32;
2276       break;
2277     case BFD_RELOC_LO16_PLTOFF:                 r = R_PPC64_PLT16_LO;
2278       break;
2279     case BFD_RELOC_HI16_PLTOFF:                 r = R_PPC64_PLT16_HI;
2280       break;
2281     case BFD_RELOC_HI16_S_PLTOFF:               r = R_PPC64_PLT16_HA;
2282       break;
2283     case BFD_RELOC_16_BASEREL:                  r = R_PPC64_SECTOFF;
2284       break;
2285     case BFD_RELOC_LO16_BASEREL:                r = R_PPC64_SECTOFF_LO;
2286       break;
2287     case BFD_RELOC_HI16_BASEREL:                r = R_PPC64_SECTOFF_HI;
2288       break;
2289     case BFD_RELOC_HI16_S_BASEREL:              r = R_PPC64_SECTOFF_HA;
2290       break;
2291     case BFD_RELOC_CTOR:                        r = R_PPC64_ADDR64;
2292       break;
2293     case BFD_RELOC_64:                          r = R_PPC64_ADDR64;
2294       break;
2295     case BFD_RELOC_PPC64_HIGHER:                r = R_PPC64_ADDR16_HIGHER;
2296       break;
2297     case BFD_RELOC_PPC64_HIGHER_S:              r = R_PPC64_ADDR16_HIGHERA;
2298       break;
2299     case BFD_RELOC_PPC64_HIGHEST:               r = R_PPC64_ADDR16_HIGHEST;
2300       break;
2301     case BFD_RELOC_PPC64_HIGHEST_S:             r = R_PPC64_ADDR16_HIGHESTA;
2302       break;
2303     case BFD_RELOC_64_PCREL:                    r = R_PPC64_REL64;
2304       break;
2305     case BFD_RELOC_64_PLTOFF:                   r = R_PPC64_PLT64;
2306       break;
2307     case BFD_RELOC_64_PLT_PCREL:                r = R_PPC64_PLTREL64;
2308       break;
2309     case BFD_RELOC_PPC_TOC16:                   r = R_PPC64_TOC16;
2310       break;
2311     case BFD_RELOC_PPC64_TOC16_LO:              r = R_PPC64_TOC16_LO;
2312       break;
2313     case BFD_RELOC_PPC64_TOC16_HI:              r = R_PPC64_TOC16_HI;
2314       break;
2315     case BFD_RELOC_PPC64_TOC16_HA:              r = R_PPC64_TOC16_HA;
2316       break;
2317     case BFD_RELOC_PPC64_TOC:                   r = R_PPC64_TOC;
2318       break;
2319     case BFD_RELOC_PPC64_PLTGOT16:              r = R_PPC64_PLTGOT16;
2320       break;
2321     case BFD_RELOC_PPC64_PLTGOT16_LO:           r = R_PPC64_PLTGOT16_LO;
2322       break;
2323     case BFD_RELOC_PPC64_PLTGOT16_HI:           r = R_PPC64_PLTGOT16_HI;
2324       break;
2325     case BFD_RELOC_PPC64_PLTGOT16_HA:           r = R_PPC64_PLTGOT16_HA;
2326       break;
2327     case BFD_RELOC_PPC64_ADDR16_DS:             r = R_PPC64_ADDR16_DS;
2328       break;
2329     case BFD_RELOC_PPC64_ADDR16_LO_DS:          r = R_PPC64_ADDR16_LO_DS;
2330       break;
2331     case BFD_RELOC_PPC64_GOT16_DS:              r = R_PPC64_GOT16_DS;
2332       break;
2333     case BFD_RELOC_PPC64_GOT16_LO_DS:           r = R_PPC64_GOT16_LO_DS;
2334       break;
2335     case BFD_RELOC_PPC64_PLT16_LO_DS:           r = R_PPC64_PLT16_LO_DS;
2336       break;
2337     case BFD_RELOC_PPC64_SECTOFF_DS:            r = R_PPC64_SECTOFF_DS;
2338       break;
2339     case BFD_RELOC_PPC64_SECTOFF_LO_DS:         r = R_PPC64_SECTOFF_LO_DS;
2340       break;
2341     case BFD_RELOC_PPC64_TOC16_DS:              r = R_PPC64_TOC16_DS;
2342       break;
2343     case BFD_RELOC_PPC64_TOC16_LO_DS:           r = R_PPC64_TOC16_LO_DS;
2344       break;
2345     case BFD_RELOC_PPC64_PLTGOT16_DS:           r = R_PPC64_PLTGOT16_DS;
2346       break;
2347     case BFD_RELOC_PPC64_PLTGOT16_LO_DS:        r = R_PPC64_PLTGOT16_LO_DS;
2348       break;
2349     case BFD_RELOC_PPC_TLS:                     r = R_PPC64_TLS;
2350       break;
2351     case BFD_RELOC_PPC_TLSGD:                   r = R_PPC64_TLSGD;
2352       break;
2353     case BFD_RELOC_PPC_TLSLD:                   r = R_PPC64_TLSLD;
2354       break;
2355     case BFD_RELOC_PPC_DTPMOD:                  r = R_PPC64_DTPMOD64;
2356       break;
2357     case BFD_RELOC_PPC_TPREL16:                 r = R_PPC64_TPREL16;
2358       break;
2359     case BFD_RELOC_PPC_TPREL16_LO:              r = R_PPC64_TPREL16_LO;
2360       break;
2361     case BFD_RELOC_PPC_TPREL16_HI:              r = R_PPC64_TPREL16_HI;
2362       break;
2363     case BFD_RELOC_PPC64_TPREL16_HIGH:          r = R_PPC64_TPREL16_HIGH;
2364       break;
2365     case BFD_RELOC_PPC_TPREL16_HA:              r = R_PPC64_TPREL16_HA;
2366       break;
2367     case BFD_RELOC_PPC64_TPREL16_HIGHA:         r = R_PPC64_TPREL16_HIGHA;
2368       break;
2369     case BFD_RELOC_PPC_TPREL:                   r = R_PPC64_TPREL64;
2370       break;
2371     case BFD_RELOC_PPC_DTPREL16:                r = R_PPC64_DTPREL16;
2372       break;
2373     case BFD_RELOC_PPC_DTPREL16_LO:             r = R_PPC64_DTPREL16_LO;
2374       break;
2375     case BFD_RELOC_PPC_DTPREL16_HI:             r = R_PPC64_DTPREL16_HI;
2376       break;
2377     case BFD_RELOC_PPC64_DTPREL16_HIGH:         r = R_PPC64_DTPREL16_HIGH;
2378       break;
2379     case BFD_RELOC_PPC_DTPREL16_HA:             r = R_PPC64_DTPREL16_HA;
2380       break;
2381     case BFD_RELOC_PPC64_DTPREL16_HIGHA:        r = R_PPC64_DTPREL16_HIGHA;
2382       break;
2383     case BFD_RELOC_PPC_DTPREL:                  r = R_PPC64_DTPREL64;
2384       break;
2385     case BFD_RELOC_PPC_GOT_TLSGD16:             r = R_PPC64_GOT_TLSGD16;
2386       break;
2387     case BFD_RELOC_PPC_GOT_TLSGD16_LO:          r = R_PPC64_GOT_TLSGD16_LO;
2388       break;
2389     case BFD_RELOC_PPC_GOT_TLSGD16_HI:          r = R_PPC64_GOT_TLSGD16_HI;
2390       break;
2391     case BFD_RELOC_PPC_GOT_TLSGD16_HA:          r = R_PPC64_GOT_TLSGD16_HA;
2392       break;
2393     case BFD_RELOC_PPC_GOT_TLSLD16:             r = R_PPC64_GOT_TLSLD16;
2394       break;
2395     case BFD_RELOC_PPC_GOT_TLSLD16_LO:          r = R_PPC64_GOT_TLSLD16_LO;
2396       break;
2397     case BFD_RELOC_PPC_GOT_TLSLD16_HI:          r = R_PPC64_GOT_TLSLD16_HI;
2398       break;
2399     case BFD_RELOC_PPC_GOT_TLSLD16_HA:          r = R_PPC64_GOT_TLSLD16_HA;
2400       break;
2401     case BFD_RELOC_PPC_GOT_TPREL16:             r = R_PPC64_GOT_TPREL16_DS;
2402       break;
2403     case BFD_RELOC_PPC_GOT_TPREL16_LO:          r = R_PPC64_GOT_TPREL16_LO_DS;
2404       break;
2405     case BFD_RELOC_PPC_GOT_TPREL16_HI:          r = R_PPC64_GOT_TPREL16_HI;
2406       break;
2407     case BFD_RELOC_PPC_GOT_TPREL16_HA:          r = R_PPC64_GOT_TPREL16_HA;
2408       break;
2409     case BFD_RELOC_PPC_GOT_DTPREL16:            r = R_PPC64_GOT_DTPREL16_DS;
2410       break;
2411     case BFD_RELOC_PPC_GOT_DTPREL16_LO:         r = R_PPC64_GOT_DTPREL16_LO_DS;
2412       break;
2413     case BFD_RELOC_PPC_GOT_DTPREL16_HI:         r = R_PPC64_GOT_DTPREL16_HI;
2414       break;
2415     case BFD_RELOC_PPC_GOT_DTPREL16_HA:         r = R_PPC64_GOT_DTPREL16_HA;
2416       break;
2417     case BFD_RELOC_PPC64_TPREL16_DS:            r = R_PPC64_TPREL16_DS;
2418       break;
2419     case BFD_RELOC_PPC64_TPREL16_LO_DS:         r = R_PPC64_TPREL16_LO_DS;
2420       break;
2421     case BFD_RELOC_PPC64_TPREL16_HIGHER:        r = R_PPC64_TPREL16_HIGHER;
2422       break;
2423     case BFD_RELOC_PPC64_TPREL16_HIGHERA:       r = R_PPC64_TPREL16_HIGHERA;
2424       break;
2425     case BFD_RELOC_PPC64_TPREL16_HIGHEST:       r = R_PPC64_TPREL16_HIGHEST;
2426       break;
2427     case BFD_RELOC_PPC64_TPREL16_HIGHESTA:      r = R_PPC64_TPREL16_HIGHESTA;
2428       break;
2429     case BFD_RELOC_PPC64_DTPREL16_DS:           r = R_PPC64_DTPREL16_DS;
2430       break;
2431     case BFD_RELOC_PPC64_DTPREL16_LO_DS:        r = R_PPC64_DTPREL16_LO_DS;
2432       break;
2433     case BFD_RELOC_PPC64_DTPREL16_HIGHER:       r = R_PPC64_DTPREL16_HIGHER;
2434       break;
2435     case BFD_RELOC_PPC64_DTPREL16_HIGHERA:      r = R_PPC64_DTPREL16_HIGHERA;
2436       break;
2437     case BFD_RELOC_PPC64_DTPREL16_HIGHEST:      r = R_PPC64_DTPREL16_HIGHEST;
2438       break;
2439     case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:     r = R_PPC64_DTPREL16_HIGHESTA;
2440       break;
2441     case BFD_RELOC_16_PCREL:                    r = R_PPC64_REL16;
2442       break;
2443     case BFD_RELOC_LO16_PCREL:                  r = R_PPC64_REL16_LO;
2444       break;
2445     case BFD_RELOC_HI16_PCREL:                  r = R_PPC64_REL16_HI;
2446       break;
2447     case BFD_RELOC_HI16_S_PCREL:                r = R_PPC64_REL16_HA;
2448       break;
2449     case BFD_RELOC_PPC_REL16DX_HA:              r = R_PPC64_REL16DX_HA;
2450       break;
2451     case BFD_RELOC_PPC64_ENTRY:                 r = R_PPC64_ENTRY;
2452       break;
2453     case BFD_RELOC_PPC64_ADDR64_LOCAL:          r = R_PPC64_ADDR64_LOCAL;
2454       break;
2455     case BFD_RELOC_VTABLE_INHERIT:              r = R_PPC64_GNU_VTINHERIT;
2456       break;
2457     case BFD_RELOC_VTABLE_ENTRY:                r = R_PPC64_GNU_VTENTRY;
2458       break;
2459     }
2460
2461   return ppc64_elf_howto_table[r];
2462 };
2463
2464 static reloc_howto_type *
2465 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2466                              const char *r_name)
2467 {
2468   unsigned int i;
2469
2470   for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2471     if (ppc64_elf_howto_raw[i].name != NULL
2472         && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2473       return &ppc64_elf_howto_raw[i];
2474
2475   return NULL;
2476 }
2477
2478 /* Set the howto pointer for a PowerPC ELF reloc.  */
2479
2480 static void
2481 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2482                          Elf_Internal_Rela *dst)
2483 {
2484   unsigned int type;
2485
2486   /* Initialize howto table if needed.  */
2487   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2488     ppc_howto_init ();
2489
2490   type = ELF64_R_TYPE (dst->r_info);
2491   if (type >= ARRAY_SIZE (ppc64_elf_howto_table))
2492     {
2493       (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
2494                              abfd, (int) type);
2495       type = R_PPC64_NONE;
2496     }
2497   cache_ptr->howto = ppc64_elf_howto_table[type];
2498 }
2499
2500 /* Handle the R_PPC64_ADDR16_HA and similar relocs.  */
2501
2502 static bfd_reloc_status_type
2503 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2504                     void *data, asection *input_section,
2505                     bfd *output_bfd, char **error_message)
2506 {
2507   enum elf_ppc64_reloc_type r_type;
2508   long insn;
2509   bfd_size_type octets;
2510   bfd_vma value;
2511
2512   /* If this is a relocatable link (output_bfd test tells us), just
2513      call the generic function.  Any adjustment will be done at final
2514      link time.  */
2515   if (output_bfd != NULL)
2516     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2517                                   input_section, output_bfd, error_message);
2518
2519   /* Adjust the addend for sign extension of the low 16 bits.
2520      We won't actually be using the low 16 bits, so trashing them
2521      doesn't matter.  */
2522   reloc_entry->addend += 0x8000;
2523   r_type = reloc_entry->howto->type;
2524   if (r_type != R_PPC64_REL16DX_HA)
2525     return bfd_reloc_continue;
2526
2527   value = 0;
2528   if (!bfd_is_com_section (symbol->section))
2529     value = symbol->value;
2530   value += (reloc_entry->addend
2531             + symbol->section->output_offset
2532             + symbol->section->output_section->vma);
2533   value -= (reloc_entry->address
2534             + input_section->output_offset
2535             + input_section->output_section->vma);
2536   value = (bfd_signed_vma) value >> 16;
2537
2538   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2539   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2540   insn &= ~0x1fffc1;
2541   insn |= (value & 0xffc1) | ((value & 0x3e) << 15);
2542   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2543   if (value + 0x8000 > 0xffff)
2544     return bfd_reloc_overflow;
2545   return bfd_reloc_ok;
2546 }
2547
2548 static bfd_reloc_status_type
2549 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2550                         void *data, asection *input_section,
2551                         bfd *output_bfd, char **error_message)
2552 {
2553   if (output_bfd != NULL)
2554     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2555                                   input_section, output_bfd, error_message);
2556
2557   if (strcmp (symbol->section->name, ".opd") == 0
2558       && (symbol->section->owner->flags & DYNAMIC) == 0)
2559     {
2560       bfd_vma dest = opd_entry_value (symbol->section,
2561                                       symbol->value + reloc_entry->addend,
2562                                       NULL, NULL, FALSE);
2563       if (dest != (bfd_vma) -1)
2564         reloc_entry->addend = dest - (symbol->value
2565                                       + symbol->section->output_section->vma
2566                                       + symbol->section->output_offset);
2567     }
2568   else
2569     {
2570       elf_symbol_type *elfsym = (elf_symbol_type *) symbol;
2571
2572       if (symbol->section->owner != abfd
2573           && symbol->section->owner != NULL
2574           && abiversion (symbol->section->owner) >= 2)
2575         {
2576           unsigned int i;
2577
2578           for (i = 0; i < symbol->section->owner->symcount; ++i)
2579             {
2580               asymbol *symdef = symbol->section->owner->outsymbols[i];
2581
2582               if (strcmp (symdef->name, symbol->name) == 0)
2583                 {
2584                   elfsym = (elf_symbol_type *) symdef;
2585                   break;
2586                 }
2587             }
2588         }
2589       reloc_entry->addend
2590         += PPC64_LOCAL_ENTRY_OFFSET (elfsym->internal_elf_sym.st_other);
2591     }
2592   return bfd_reloc_continue;
2593 }
2594
2595 static bfd_reloc_status_type
2596 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2597                          void *data, asection *input_section,
2598                          bfd *output_bfd, char **error_message)
2599 {
2600   long insn;
2601   enum elf_ppc64_reloc_type r_type;
2602   bfd_size_type octets;
2603   /* Assume 'at' branch hints.  */
2604   bfd_boolean is_isa_v2 = TRUE;
2605
2606   /* If this is a relocatable link (output_bfd test tells us), just
2607      call the generic function.  Any adjustment will be done at final
2608      link time.  */
2609   if (output_bfd != NULL)
2610     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2611                                   input_section, output_bfd, error_message);
2612
2613   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2614   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2615   insn &= ~(0x01 << 21);
2616   r_type = reloc_entry->howto->type;
2617   if (r_type == R_PPC64_ADDR14_BRTAKEN
2618       || r_type == R_PPC64_REL14_BRTAKEN)
2619     insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
2620
2621   if (is_isa_v2)
2622     {
2623       /* Set 'a' bit.  This is 0b00010 in BO field for branch
2624          on CR(BI) insns (BO == 001at or 011at), and 0b01000
2625          for branch on CTR insns (BO == 1a00t or 1a01t).  */
2626       if ((insn & (0x14 << 21)) == (0x04 << 21))
2627         insn |= 0x02 << 21;
2628       else if ((insn & (0x14 << 21)) == (0x10 << 21))
2629         insn |= 0x08 << 21;
2630       else
2631         goto out;
2632     }
2633   else
2634     {
2635       bfd_vma target = 0;
2636       bfd_vma from;
2637
2638       if (!bfd_is_com_section (symbol->section))
2639         target = symbol->value;
2640       target += symbol->section->output_section->vma;
2641       target += symbol->section->output_offset;
2642       target += reloc_entry->addend;
2643
2644       from = (reloc_entry->address
2645               + input_section->output_offset
2646               + input_section->output_section->vma);
2647
2648       /* Invert 'y' bit if not the default.  */
2649       if ((bfd_signed_vma) (target - from) < 0)
2650         insn ^= 0x01 << 21;
2651     }
2652   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2653  out:
2654   return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2655                                  input_section, output_bfd, error_message);
2656 }
2657
2658 static bfd_reloc_status_type
2659 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2660                          void *data, asection *input_section,
2661                          bfd *output_bfd, char **error_message)
2662 {
2663   /* If this is a relocatable link (output_bfd test tells us), just
2664      call the generic function.  Any adjustment will be done at final
2665      link time.  */
2666   if (output_bfd != NULL)
2667     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2668                                   input_section, output_bfd, error_message);
2669
2670   /* Subtract the symbol section base address.  */
2671   reloc_entry->addend -= symbol->section->output_section->vma;
2672   return bfd_reloc_continue;
2673 }
2674
2675 static bfd_reloc_status_type
2676 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2677                             void *data, asection *input_section,
2678                             bfd *output_bfd, char **error_message)
2679 {
2680   /* If this is a relocatable link (output_bfd test tells us), just
2681      call the generic function.  Any adjustment will be done at final
2682      link time.  */
2683   if (output_bfd != NULL)
2684     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2685                                   input_section, output_bfd, error_message);
2686
2687   /* Subtract the symbol section base address.  */
2688   reloc_entry->addend -= symbol->section->output_section->vma;
2689
2690   /* Adjust the addend for sign extension of the low 16 bits.  */
2691   reloc_entry->addend += 0x8000;
2692   return bfd_reloc_continue;
2693 }
2694
2695 static bfd_reloc_status_type
2696 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2697                      void *data, asection *input_section,
2698                      bfd *output_bfd, char **error_message)
2699 {
2700   bfd_vma TOCstart;
2701
2702   /* If this is a relocatable link (output_bfd test tells us), just
2703      call the generic function.  Any adjustment will be done at final
2704      link time.  */
2705   if (output_bfd != NULL)
2706     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2707                                   input_section, output_bfd, error_message);
2708
2709   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2710   if (TOCstart == 0)
2711     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2712
2713   /* Subtract the TOC base address.  */
2714   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2715   return bfd_reloc_continue;
2716 }
2717
2718 static bfd_reloc_status_type
2719 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2720                         void *data, asection *input_section,
2721                         bfd *output_bfd, char **error_message)
2722 {
2723   bfd_vma TOCstart;
2724
2725   /* If this is a relocatable link (output_bfd test tells us), just
2726      call the generic function.  Any adjustment will be done at final
2727      link time.  */
2728   if (output_bfd != NULL)
2729     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2730                                   input_section, output_bfd, error_message);
2731
2732   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2733   if (TOCstart == 0)
2734     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2735
2736   /* Subtract the TOC base address.  */
2737   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2738
2739   /* Adjust the addend for sign extension of the low 16 bits.  */
2740   reloc_entry->addend += 0x8000;
2741   return bfd_reloc_continue;
2742 }
2743
2744 static bfd_reloc_status_type
2745 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2746                        void *data, asection *input_section,
2747                        bfd *output_bfd, char **error_message)
2748 {
2749   bfd_vma TOCstart;
2750   bfd_size_type octets;
2751
2752   /* If this is a relocatable link (output_bfd test tells us), just
2753      call the generic function.  Any adjustment will be done at final
2754      link time.  */
2755   if (output_bfd != NULL)
2756     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2757                                   input_section, output_bfd, error_message);
2758
2759   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2760   if (TOCstart == 0)
2761     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2762
2763   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2764   bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2765   return bfd_reloc_ok;
2766 }
2767
2768 static bfd_reloc_status_type
2769 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2770                            void *data, asection *input_section,
2771                            bfd *output_bfd, char **error_message)
2772 {
2773   /* If this is a relocatable link (output_bfd test tells us), just
2774      call the generic function.  Any adjustment will be done at final
2775      link time.  */
2776   if (output_bfd != NULL)
2777     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2778                                   input_section, output_bfd, error_message);
2779
2780   if (error_message != NULL)
2781     {
2782       static char buf[60];
2783       sprintf (buf, "generic linker can't handle %s",
2784                reloc_entry->howto->name);
2785       *error_message = buf;
2786     }
2787   return bfd_reloc_dangerous;
2788 }
2789
2790 /* Track GOT entries needed for a given symbol.  We might need more
2791    than one got entry per symbol.  */
2792 struct got_entry
2793 {
2794   struct got_entry *next;
2795
2796   /* The symbol addend that we'll be placing in the GOT.  */
2797   bfd_vma addend;
2798
2799   /* Unlike other ELF targets, we use separate GOT entries for the same
2800      symbol referenced from different input files.  This is to support
2801      automatic multiple TOC/GOT sections, where the TOC base can vary
2802      from one input file to another.  After partitioning into TOC groups
2803      we merge entries within the group.
2804
2805      Point to the BFD owning this GOT entry.  */
2806   bfd *owner;
2807
2808   /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2809      TLS_TPREL or TLS_DTPREL for tls entries.  */
2810   unsigned char tls_type;
2811
2812   /* Non-zero if got.ent points to real entry.  */
2813   unsigned char is_indirect;
2814
2815   /* Reference count until size_dynamic_sections, GOT offset thereafter.  */
2816   union
2817     {
2818       bfd_signed_vma refcount;
2819       bfd_vma offset;
2820       struct got_entry *ent;
2821     } got;
2822 };
2823
2824 /* The same for PLT.  */
2825 struct plt_entry
2826 {
2827   struct plt_entry *next;
2828
2829   bfd_vma addend;
2830
2831   union
2832     {
2833       bfd_signed_vma refcount;
2834       bfd_vma offset;
2835     } plt;
2836 };
2837
2838 struct ppc64_elf_obj_tdata
2839 {
2840   struct elf_obj_tdata elf;
2841
2842   /* Shortcuts to dynamic linker sections.  */
2843   asection *got;
2844   asection *relgot;
2845
2846   /* Used during garbage collection.  We attach global symbols defined
2847      on removed .opd entries to this section so that the sym is removed.  */
2848   asection *deleted_section;
2849
2850   /* TLS local dynamic got entry handling.  Support for multiple GOT
2851      sections means we potentially need one of these for each input bfd.  */
2852   struct got_entry tlsld_got;
2853
2854   union {
2855     /* A copy of relocs before they are modified for --emit-relocs.  */
2856     Elf_Internal_Rela *relocs;
2857
2858     /* Section contents.  */
2859     bfd_byte *contents;
2860   } opd;
2861
2862   /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2863      the reloc to be in the range -32768 to 32767.  */
2864   unsigned int has_small_toc_reloc : 1;
2865
2866   /* Set if toc/got ha relocs detected not using r2, or lo reloc
2867      instruction not one we handle.  */
2868   unsigned int unexpected_toc_insn : 1;
2869 };
2870
2871 #define ppc64_elf_tdata(bfd) \
2872   ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2873
2874 #define ppc64_tlsld_got(bfd) \
2875   (&ppc64_elf_tdata (bfd)->tlsld_got)
2876
2877 #define is_ppc64_elf(bfd) \
2878   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2879    && elf_object_id (bfd) == PPC64_ELF_DATA)
2880
2881 /* Override the generic function because we store some extras.  */
2882
2883 static bfd_boolean
2884 ppc64_elf_mkobject (bfd *abfd)
2885 {
2886   return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2887                                   PPC64_ELF_DATA);
2888 }
2889
2890 /* Fix bad default arch selected for a 64 bit input bfd when the
2891    default is 32 bit.  Also select arch based on apuinfo.  */
2892
2893 static bfd_boolean
2894 ppc64_elf_object_p (bfd *abfd)
2895 {
2896   if (!abfd->arch_info->the_default)
2897     return TRUE;
2898
2899   if (abfd->arch_info->bits_per_word == 32)
2900     {
2901       Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2902
2903       if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2904         {
2905           /* Relies on arch after 32 bit default being 64 bit default.  */
2906           abfd->arch_info = abfd->arch_info->next;
2907           BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2908         }
2909     }
2910   return _bfd_elf_ppc_set_arch (abfd);
2911 }
2912
2913 /* Support for core dump NOTE sections.  */
2914
2915 static bfd_boolean
2916 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2917 {
2918   size_t offset, size;
2919
2920   if (note->descsz != 504)
2921     return FALSE;
2922
2923   /* pr_cursig */
2924   elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2925
2926   /* pr_pid */
2927   elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2928
2929   /* pr_reg */
2930   offset = 112;
2931   size = 384;
2932
2933   /* Make a ".reg/999" section.  */
2934   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2935                                           size, note->descpos + offset);
2936 }
2937
2938 static bfd_boolean
2939 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2940 {
2941   if (note->descsz != 136)
2942     return FALSE;
2943
2944   elf_tdata (abfd)->core->pid
2945     = bfd_get_32 (abfd, note->descdata + 24);
2946   elf_tdata (abfd)->core->program
2947     = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2948   elf_tdata (abfd)->core->command
2949     = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2950
2951   return TRUE;
2952 }
2953
2954 static char *
2955 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2956                            ...)
2957 {
2958   switch (note_type)
2959     {
2960     default:
2961       return NULL;
2962
2963     case NT_PRPSINFO:
2964       {
2965         char data[136];
2966         va_list ap;
2967
2968         va_start (ap, note_type);
2969         memset (data, 0, sizeof (data));
2970         strncpy (data + 40, va_arg (ap, const char *), 16);
2971         strncpy (data + 56, va_arg (ap, const char *), 80);
2972         va_end (ap);
2973         return elfcore_write_note (abfd, buf, bufsiz,
2974                                    "CORE", note_type, data, sizeof (data));
2975       }
2976
2977     case NT_PRSTATUS:
2978       {
2979         char data[504];
2980         va_list ap;
2981         long pid;
2982         int cursig;
2983         const void *greg;
2984
2985         va_start (ap, note_type);
2986         memset (data, 0, 112);
2987         pid = va_arg (ap, long);
2988         bfd_put_32 (abfd, pid, data + 32);
2989         cursig = va_arg (ap, int);
2990         bfd_put_16 (abfd, cursig, data + 12);
2991         greg = va_arg (ap, const void *);
2992         memcpy (data + 112, greg, 384);
2993         memset (data + 496, 0, 8);
2994         va_end (ap);
2995         return elfcore_write_note (abfd, buf, bufsiz,
2996                                    "CORE", note_type, data, sizeof (data));
2997       }
2998     }
2999 }
3000
3001 /* Add extra PPC sections.  */
3002
3003 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
3004 {
3005   { STRING_COMMA_LEN (".plt"),    0, SHT_NOBITS,   0 },
3006   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
3007   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3008   { STRING_COMMA_LEN (".toc"),    0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3009   { STRING_COMMA_LEN (".toc1"),   0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3010   { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
3011   { NULL,                     0,  0, 0,            0 }
3012 };
3013
3014 enum _ppc64_sec_type {
3015   sec_normal = 0,
3016   sec_opd = 1,
3017   sec_toc = 2
3018 };
3019
3020 struct _ppc64_elf_section_data
3021 {
3022   struct bfd_elf_section_data elf;
3023
3024   union
3025   {
3026     /* An array with one entry for each opd function descriptor,
3027        and some spares since opd entries may be either 16 or 24 bytes.  */
3028 #define OPD_NDX(OFF) ((OFF) >> 4)
3029     struct _opd_sec_data
3030     {
3031       /* Points to the function code section for local opd entries.  */
3032       asection **func_sec;
3033
3034       /* After editing .opd, adjust references to opd local syms.  */
3035       long *adjust;
3036     } opd;
3037
3038     /* An array for toc sections, indexed by offset/8.  */
3039     struct _toc_sec_data
3040     {
3041       /* Specifies the relocation symbol index used at a given toc offset.  */
3042       unsigned *symndx;
3043
3044       /* And the relocation addend.  */
3045       bfd_vma *add;
3046     } toc;
3047   } u;
3048
3049   enum _ppc64_sec_type sec_type:2;
3050
3051   /* Flag set when small branches are detected.  Used to
3052      select suitable defaults for the stub group size.  */
3053   unsigned int has_14bit_branch:1;
3054 };
3055
3056 #define ppc64_elf_section_data(sec) \
3057   ((struct _ppc64_elf_section_data *) elf_section_data (sec))
3058
3059 static bfd_boolean
3060 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
3061 {
3062   if (!sec->used_by_bfd)
3063     {
3064       struct _ppc64_elf_section_data *sdata;
3065       bfd_size_type amt = sizeof (*sdata);
3066
3067       sdata = bfd_zalloc (abfd, amt);
3068       if (sdata == NULL)
3069         return FALSE;
3070       sec->used_by_bfd = sdata;
3071     }
3072
3073   return _bfd_elf_new_section_hook (abfd, sec);
3074 }
3075
3076 static struct _opd_sec_data *
3077 get_opd_info (asection * sec)
3078 {
3079   if (sec != NULL
3080       && ppc64_elf_section_data (sec) != NULL
3081       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
3082     return &ppc64_elf_section_data (sec)->u.opd;
3083   return NULL;
3084 }
3085 \f
3086 /* Parameters for the qsort hook.  */
3087 static bfd_boolean synthetic_relocatable;
3088 static asection *synthetic_opd;
3089
3090 /* qsort comparison function for ppc64_elf_get_synthetic_symtab.  */
3091
3092 static int
3093 compare_symbols (const void *ap, const void *bp)
3094 {
3095   const asymbol *a = * (const asymbol **) ap;
3096   const asymbol *b = * (const asymbol **) bp;
3097
3098   /* Section symbols first.  */
3099   if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
3100     return -1;
3101   if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
3102     return 1;
3103
3104   /* then .opd symbols.  */
3105   if (synthetic_opd != NULL)
3106     {
3107       if (strcmp (a->section->name, ".opd") == 0
3108           && strcmp (b->section->name, ".opd") != 0)
3109         return -1;
3110       if (strcmp (a->section->name, ".opd") != 0
3111           && strcmp (b->section->name, ".opd") == 0)
3112         return 1;
3113     }
3114
3115   /* then other code symbols.  */
3116   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3117       == (SEC_CODE | SEC_ALLOC)
3118       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3119          != (SEC_CODE | SEC_ALLOC))
3120     return -1;
3121
3122   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3123       != (SEC_CODE | SEC_ALLOC)
3124       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3125          == (SEC_CODE | SEC_ALLOC))
3126     return 1;
3127
3128   if (synthetic_relocatable)
3129     {
3130       if (a->section->id < b->section->id)
3131         return -1;
3132
3133       if (a->section->id > b->section->id)
3134         return 1;
3135     }
3136
3137   if (a->value + a->section->vma < b->value + b->section->vma)
3138     return -1;
3139
3140   if (a->value + a->section->vma > b->value + b->section->vma)
3141     return 1;
3142
3143   /* For syms with the same value, prefer strong dynamic global function
3144      syms over other syms.  */
3145   if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3146     return -1;
3147
3148   if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3149     return 1;
3150
3151   if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3152     return -1;
3153
3154   if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3155     return 1;
3156
3157   if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3158     return -1;
3159
3160   if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3161     return 1;
3162
3163   if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3164     return -1;
3165
3166   if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3167     return 1;
3168
3169   return 0;
3170 }
3171
3172 /* Search SYMS for a symbol of the given VALUE.  */
3173
3174 static asymbol *
3175 sym_exists_at (asymbol **syms, long lo, long hi, unsigned int id, bfd_vma value)
3176 {
3177   long mid;
3178
3179   if (id == (unsigned) -1)
3180     {
3181       while (lo < hi)
3182         {
3183           mid = (lo + hi) >> 1;
3184           if (syms[mid]->value + syms[mid]->section->vma < value)
3185             lo = mid + 1;
3186           else if (syms[mid]->value + syms[mid]->section->vma > value)
3187             hi = mid;
3188           else
3189             return syms[mid];
3190         }
3191     }
3192   else
3193     {
3194       while (lo < hi)
3195         {
3196           mid = (lo + hi) >> 1;
3197           if (syms[mid]->section->id < id)
3198             lo = mid + 1;
3199           else if (syms[mid]->section->id > id)
3200             hi = mid;
3201           else if (syms[mid]->value < value)
3202             lo = mid + 1;
3203           else if (syms[mid]->value > value)
3204             hi = mid;
3205           else
3206             return syms[mid];
3207         }
3208     }
3209   return NULL;
3210 }
3211
3212 static bfd_boolean
3213 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3214 {
3215   bfd_vma vma = *(bfd_vma *) ptr;
3216   return ((section->flags & SEC_ALLOC) != 0
3217           && section->vma <= vma
3218           && vma < section->vma + section->size);
3219 }
3220
3221 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3222    entry syms.  Also generate @plt symbols for the glink branch table.
3223    Returns count of synthetic symbols in RET or -1 on error.  */
3224
3225 static long
3226 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3227                                 long static_count, asymbol **static_syms,
3228                                 long dyn_count, asymbol **dyn_syms,
3229                                 asymbol **ret)
3230 {
3231   asymbol *s;
3232   long i;
3233   long count;
3234   char *names;
3235   long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3236   asection *opd = NULL;
3237   bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3238   asymbol **syms;
3239   int abi = abiversion (abfd);
3240
3241   *ret = NULL;
3242
3243   if (abi < 2)
3244     {
3245       opd = bfd_get_section_by_name (abfd, ".opd");
3246       if (opd == NULL && abi == 1)
3247         return 0;
3248     }
3249
3250   symcount = static_count;
3251   if (!relocatable)
3252     symcount += dyn_count;
3253   if (symcount == 0)
3254     return 0;
3255
3256   syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3257   if (syms == NULL)
3258     return -1;
3259
3260   if (!relocatable && static_count != 0 && dyn_count != 0)
3261     {
3262       /* Use both symbol tables.  */
3263       memcpy (syms, static_syms, static_count * sizeof (*syms));
3264       memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3265     }
3266   else if (!relocatable && static_count == 0)
3267     memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3268   else
3269     memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3270
3271   synthetic_relocatable = relocatable;
3272   synthetic_opd = opd;
3273   qsort (syms, symcount, sizeof (*syms), compare_symbols);
3274
3275   if (!relocatable && symcount > 1)
3276     {
3277       long j;
3278       /* Trim duplicate syms, since we may have merged the normal and
3279          dynamic symbols.  Actually, we only care about syms that have
3280          different values, so trim any with the same value.  */
3281       for (i = 1, j = 1; i < symcount; ++i)
3282         if (syms[i - 1]->value + syms[i - 1]->section->vma
3283             != syms[i]->value + syms[i]->section->vma)
3284           syms[j++] = syms[i];
3285       symcount = j;
3286     }
3287
3288   i = 0;
3289   /* Note that here and in compare_symbols we can't compare opd and
3290      sym->section directly.  With separate debug info files, the
3291      symbols will be extracted from the debug file while abfd passed
3292      to this function is the real binary.  */
3293   if (opd != NULL && strcmp (syms[i]->section->name, ".opd") == 0)
3294     ++i;
3295   codesecsym = i;
3296
3297   for (; i < symcount; ++i)
3298     if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3299          != (SEC_CODE | SEC_ALLOC))
3300         || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3301       break;
3302   codesecsymend = i;
3303
3304   for (; i < symcount; ++i)
3305     if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3306       break;
3307   secsymend = i;
3308
3309   if (opd != NULL)
3310     for (; i < symcount; ++i)
3311       if (strcmp (syms[i]->section->name, ".opd") != 0)
3312         break;
3313   opdsymend = i;
3314
3315   for (; i < symcount; ++i)
3316     if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3317         != (SEC_CODE | SEC_ALLOC))
3318       break;
3319   symcount = i;
3320
3321   count = 0;
3322
3323   if (relocatable)
3324     {
3325       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3326       arelent *r;
3327       size_t size;
3328       long relcount;
3329
3330       if (opdsymend == secsymend)
3331         goto done;
3332
3333       slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3334       relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3335       if (relcount == 0)
3336         goto done;
3337
3338       if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3339         {
3340           count = -1;
3341           goto done;
3342         }
3343
3344       size = 0;
3345       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3346         {
3347           asymbol *sym;
3348
3349           while (r < opd->relocation + relcount
3350                  && r->address < syms[i]->value + opd->vma)
3351             ++r;
3352
3353           if (r == opd->relocation + relcount)
3354             break;
3355
3356           if (r->address != syms[i]->value + opd->vma)
3357             continue;
3358
3359           if (r->howto->type != R_PPC64_ADDR64)
3360             continue;
3361
3362           sym = *r->sym_ptr_ptr;
3363           if (!sym_exists_at (syms, opdsymend, symcount,
3364                               sym->section->id, sym->value + r->addend))
3365             {
3366               ++count;
3367               size += sizeof (asymbol);
3368               size += strlen (syms[i]->name) + 2;
3369             }
3370         }
3371
3372       if (size == 0)
3373         goto done;
3374       s = *ret = bfd_malloc (size);
3375       if (s == NULL)
3376         {
3377           count = -1;
3378           goto done;
3379         }
3380
3381       names = (char *) (s + count);
3382
3383       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3384         {
3385           asymbol *sym;
3386
3387           while (r < opd->relocation + relcount
3388                  && r->address < syms[i]->value + opd->vma)
3389             ++r;
3390
3391           if (r == opd->relocation + relcount)
3392             break;
3393
3394           if (r->address != syms[i]->value + opd->vma)
3395             continue;
3396
3397           if (r->howto->type != R_PPC64_ADDR64)
3398             continue;
3399
3400           sym = *r->sym_ptr_ptr;
3401           if (!sym_exists_at (syms, opdsymend, symcount,
3402                               sym->section->id, sym->value + r->addend))
3403             {
3404               size_t len;
3405
3406               *s = *syms[i];
3407               s->flags |= BSF_SYNTHETIC;
3408               s->section = sym->section;
3409               s->value = sym->value + r->addend;
3410               s->name = names;
3411               *names++ = '.';
3412               len = strlen (syms[i]->name);
3413               memcpy (names, syms[i]->name, len + 1);
3414               names += len + 1;
3415               /* Have udata.p point back to the original symbol this
3416                  synthetic symbol was derived from.  */
3417               s->udata.p = syms[i];
3418               s++;
3419             }
3420         }
3421     }
3422   else
3423     {
3424       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3425       bfd_byte *contents = NULL;
3426       size_t size;
3427       long plt_count = 0;
3428       bfd_vma glink_vma = 0, resolv_vma = 0;
3429       asection *dynamic, *glink = NULL, *relplt = NULL;
3430       arelent *p;
3431
3432       if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3433         {
3434         free_contents_and_exit_err:
3435           count = -1;
3436         free_contents_and_exit:
3437           if (contents)
3438             free (contents);
3439           goto done;
3440         }
3441
3442       size = 0;
3443       for (i = secsymend; i < opdsymend; ++i)
3444         {
3445           bfd_vma ent;
3446
3447           /* Ignore bogus symbols.  */
3448           if (syms[i]->value > opd->size - 8)
3449             continue;
3450
3451           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3452           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3453             {
3454               ++count;
3455               size += sizeof (asymbol);
3456               size += strlen (syms[i]->name) + 2;
3457             }
3458         }
3459
3460       /* Get start of .glink stubs from DT_PPC64_GLINK.  */
3461       if (dyn_count != 0
3462           && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3463         {
3464           bfd_byte *dynbuf, *extdyn, *extdynend;
3465           size_t extdynsize;
3466           void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3467
3468           if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3469             goto free_contents_and_exit_err;
3470
3471           extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3472           swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3473
3474           extdyn = dynbuf;
3475           extdynend = extdyn + dynamic->size;
3476           for (; extdyn < extdynend; extdyn += extdynsize)
3477             {
3478               Elf_Internal_Dyn dyn;
3479               (*swap_dyn_in) (abfd, extdyn, &dyn);
3480
3481               if (dyn.d_tag == DT_NULL)
3482                 break;
3483
3484               if (dyn.d_tag == DT_PPC64_GLINK)
3485                 {
3486                   /* The first glink stub starts at offset 32; see
3487                      comment in ppc64_elf_finish_dynamic_sections. */
3488                   glink_vma = dyn.d_un.d_val + GLINK_CALL_STUB_SIZE - 8 * 4;
3489                   /* The .glink section usually does not survive the final
3490                      link; search for the section (usually .text) where the
3491                      glink stubs now reside.  */
3492                   glink = bfd_sections_find_if (abfd, section_covers_vma,
3493                                                 &glink_vma);
3494                   break;
3495                 }
3496             }
3497
3498           free (dynbuf);
3499         }
3500
3501       if (glink != NULL)
3502         {
3503           /* Determine __glink trampoline by reading the relative branch
3504              from the first glink stub.  */
3505           bfd_byte buf[4];
3506           unsigned int off = 0;
3507
3508           while (bfd_get_section_contents (abfd, glink, buf,
3509                                            glink_vma + off - glink->vma, 4))
3510             {
3511               unsigned int insn = bfd_get_32 (abfd, buf);
3512               insn ^= B_DOT;
3513               if ((insn & ~0x3fffffc) == 0)
3514                 {
3515                   resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3516                   break;
3517                 }
3518               off += 4;
3519               if (off > 4)
3520                 break;
3521             }
3522
3523           if (resolv_vma)
3524             size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3525
3526           relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3527           if (relplt != NULL)
3528             {
3529               slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3530               if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3531                 goto free_contents_and_exit_err;
3532
3533               plt_count = relplt->size / sizeof (Elf64_External_Rela);
3534               size += plt_count * sizeof (asymbol);
3535
3536               p = relplt->relocation;
3537               for (i = 0; i < plt_count; i++, p++)
3538                 {
3539                   size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3540                   if (p->addend != 0)
3541                     size += sizeof ("+0x") - 1 + 16;
3542                 }
3543             }
3544         }
3545
3546       if (size == 0)
3547         goto free_contents_and_exit;
3548       s = *ret = bfd_malloc (size);
3549       if (s == NULL)
3550         goto free_contents_and_exit_err;
3551
3552       names = (char *) (s + count + plt_count + (resolv_vma != 0));
3553
3554       for (i = secsymend; i < opdsymend; ++i)
3555         {
3556           bfd_vma ent;
3557
3558           if (syms[i]->value > opd->size - 8)
3559             continue;
3560
3561           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3562           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3563             {
3564               long lo, hi;
3565               size_t len;
3566               asection *sec = abfd->sections;
3567
3568               *s = *syms[i];
3569               lo = codesecsym;
3570               hi = codesecsymend;
3571               while (lo < hi)
3572                 {
3573                   long mid = (lo + hi) >> 1;
3574                   if (syms[mid]->section->vma < ent)
3575                     lo = mid + 1;
3576                   else if (syms[mid]->section->vma > ent)
3577                     hi = mid;
3578                   else
3579                     {
3580                       sec = syms[mid]->section;
3581                       break;
3582                     }
3583                 }
3584
3585               if (lo >= hi && lo > codesecsym)
3586                 sec = syms[lo - 1]->section;
3587
3588               for (; sec != NULL; sec = sec->next)
3589                 {
3590                   if (sec->vma > ent)
3591                     break;
3592                   /* SEC_LOAD may not be set if SEC is from a separate debug
3593                      info file.  */
3594                   if ((sec->flags & SEC_ALLOC) == 0)
3595                     break;
3596                   if ((sec->flags & SEC_CODE) != 0)
3597                     s->section = sec;
3598                 }
3599               s->flags |= BSF_SYNTHETIC;
3600               s->value = ent - s->section->vma;
3601               s->name = names;
3602               *names++ = '.';
3603               len = strlen (syms[i]->name);
3604               memcpy (names, syms[i]->name, len + 1);
3605               names += len + 1;
3606               /* Have udata.p point back to the original symbol this
3607                  synthetic symbol was derived from.  */
3608               s->udata.p = syms[i];
3609               s++;
3610             }
3611         }
3612       free (contents);
3613
3614       if (glink != NULL && relplt != NULL)
3615         {
3616           if (resolv_vma)
3617             {
3618               /* Add a symbol for the main glink trampoline.  */
3619               memset (s, 0, sizeof *s);
3620               s->the_bfd = abfd;
3621               s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3622               s->section = glink;
3623               s->value = resolv_vma - glink->vma;
3624               s->name = names;
3625               memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3626               names += sizeof ("__glink_PLTresolve");
3627               s++;
3628               count++;
3629             }
3630
3631           /* FIXME: It would be very much nicer to put sym@plt on the
3632              stub rather than on the glink branch table entry.  The
3633              objdump disassembler would then use a sensible symbol
3634              name on plt calls.  The difficulty in doing so is
3635              a) finding the stubs, and,
3636              b) matching stubs against plt entries, and,
3637              c) there can be multiple stubs for a given plt entry.
3638
3639              Solving (a) could be done by code scanning, but older
3640              ppc64 binaries used different stubs to current code.
3641              (b) is the tricky one since you need to known the toc
3642              pointer for at least one function that uses a pic stub to
3643              be able to calculate the plt address referenced.
3644              (c) means gdb would need to set multiple breakpoints (or
3645              find the glink branch itself) when setting breakpoints
3646              for pending shared library loads.  */
3647           p = relplt->relocation;
3648           for (i = 0; i < plt_count; i++, p++)
3649             {
3650               size_t len;
3651
3652               *s = **p->sym_ptr_ptr;
3653               /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
3654                  we are defining a symbol, ensure one of them is set.  */
3655               if ((s->flags & BSF_LOCAL) == 0)
3656                 s->flags |= BSF_GLOBAL;
3657               s->flags |= BSF_SYNTHETIC;
3658               s->section = glink;
3659               s->value = glink_vma - glink->vma;
3660               s->name = names;
3661               s->udata.p = NULL;
3662               len = strlen ((*p->sym_ptr_ptr)->name);
3663               memcpy (names, (*p->sym_ptr_ptr)->name, len);
3664               names += len;
3665               if (p->addend != 0)
3666                 {
3667                   memcpy (names, "+0x", sizeof ("+0x") - 1);
3668                   names += sizeof ("+0x") - 1;
3669                   bfd_sprintf_vma (abfd, names, p->addend);
3670                   names += strlen (names);
3671                 }
3672               memcpy (names, "@plt", sizeof ("@plt"));
3673               names += sizeof ("@plt");
3674               s++;
3675               if (abi < 2)
3676                 {
3677                   glink_vma += 8;
3678                   if (i >= 0x8000)
3679                     glink_vma += 4;
3680                 }
3681               else
3682                 glink_vma += 4;
3683             }
3684           count += plt_count;
3685         }
3686     }
3687
3688  done:
3689   free (syms);
3690   return count;
3691 }
3692 \f
3693 /* The following functions are specific to the ELF linker, while
3694    functions above are used generally.  Those named ppc64_elf_* are
3695    called by the main ELF linker code.  They appear in this file more
3696    or less in the order in which they are called.  eg.
3697    ppc64_elf_check_relocs is called early in the link process,
3698    ppc64_elf_finish_dynamic_sections is one of the last functions
3699    called.
3700
3701    PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3702    functions have both a function code symbol and a function descriptor
3703    symbol.  A call to foo in a relocatable object file looks like:
3704
3705    .            .text
3706    .    x:
3707    .            bl      .foo
3708    .            nop
3709
3710    The function definition in another object file might be:
3711
3712    .            .section .opd
3713    .    foo:    .quad   .foo
3714    .            .quad   .TOC.@tocbase
3715    .            .quad   0
3716    .
3717    .            .text
3718    .    .foo:   blr
3719
3720    When the linker resolves the call during a static link, the branch
3721    unsurprisingly just goes to .foo and the .opd information is unused.
3722    If the function definition is in a shared library, things are a little
3723    different:  The call goes via a plt call stub, the opd information gets
3724    copied to the plt, and the linker patches the nop.
3725
3726    .    x:
3727    .            bl      .foo_stub
3728    .            ld      2,40(1)
3729    .
3730    .
3731    .    .foo_stub:
3732    .            std     2,40(1)                 # in practice, the call stub
3733    .            addis   11,2,Lfoo@toc@ha        # is slightly optimized, but
3734    .            addi    11,11,Lfoo@toc@l        # this is the general idea
3735    .            ld      12,0(11)
3736    .            ld      2,8(11)
3737    .            mtctr   12
3738    .            ld      11,16(11)
3739    .            bctr
3740    .
3741    .            .section .plt
3742    .    Lfoo:   reloc (R_PPC64_JMP_SLOT, foo)
3743
3744    The "reloc ()" notation is supposed to indicate that the linker emits
3745    an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
3746    copying.
3747
3748    What are the difficulties here?  Well, firstly, the relocations
3749    examined by the linker in check_relocs are against the function code
3750    sym .foo, while the dynamic relocation in the plt is emitted against
3751    the function descriptor symbol, foo.  Somewhere along the line, we need
3752    to carefully copy dynamic link information from one symbol to the other.
3753    Secondly, the generic part of the elf linker will make .foo a dynamic
3754    symbol as is normal for most other backends.  We need foo dynamic
3755    instead, at least for an application final link.  However, when
3756    creating a shared library containing foo, we need to have both symbols
3757    dynamic so that references to .foo are satisfied during the early
3758    stages of linking.  Otherwise the linker might decide to pull in a
3759    definition from some other object, eg. a static library.
3760
3761    Update: As of August 2004, we support a new convention.  Function
3762    calls may use the function descriptor symbol, ie. "bl foo".  This
3763    behaves exactly as "bl .foo".  */
3764
3765 /* Of those relocs that might be copied as dynamic relocs, this function
3766    selects those that must be copied when linking a shared library,
3767    even when the symbol is local.  */
3768
3769 static int
3770 must_be_dyn_reloc (struct bfd_link_info *info,
3771                    enum elf_ppc64_reloc_type r_type)
3772 {
3773   switch (r_type)
3774     {
3775     default:
3776       return 1;
3777
3778     case R_PPC64_REL32:
3779     case R_PPC64_REL64:
3780     case R_PPC64_REL30:
3781       return 0;
3782
3783     case R_PPC64_TPREL16:
3784     case R_PPC64_TPREL16_LO:
3785     case R_PPC64_TPREL16_HI:
3786     case R_PPC64_TPREL16_HA:
3787     case R_PPC64_TPREL16_DS:
3788     case R_PPC64_TPREL16_LO_DS:
3789     case R_PPC64_TPREL16_HIGH:
3790     case R_PPC64_TPREL16_HIGHA:
3791     case R_PPC64_TPREL16_HIGHER:
3792     case R_PPC64_TPREL16_HIGHERA:
3793     case R_PPC64_TPREL16_HIGHEST:
3794     case R_PPC64_TPREL16_HIGHESTA:
3795     case R_PPC64_TPREL64:
3796       return !bfd_link_executable (info);
3797     }
3798 }
3799
3800 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3801    copying dynamic variables from a shared lib into an app's dynbss
3802    section, and instead use a dynamic relocation to point into the
3803    shared lib.  With code that gcc generates, it's vital that this be
3804    enabled;  In the PowerPC64 ABI, the address of a function is actually
3805    the address of a function descriptor, which resides in the .opd
3806    section.  gcc uses the descriptor directly rather than going via the
3807    GOT as some other ABI's do, which means that initialized function
3808    pointers must reference the descriptor.  Thus, a function pointer
3809    initialized to the address of a function in a shared library will
3810    either require a copy reloc, or a dynamic reloc.  Using a copy reloc
3811    redefines the function descriptor symbol to point to the copy.  This
3812    presents a problem as a plt entry for that function is also
3813    initialized from the function descriptor symbol and the copy reloc
3814    may not be initialized first.  */
3815 #define ELIMINATE_COPY_RELOCS 1
3816
3817 /* Section name for stubs is the associated section name plus this
3818    string.  */
3819 #define STUB_SUFFIX ".stub"
3820
3821 /* Linker stubs.
3822    ppc_stub_long_branch:
3823    Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3824    destination, but a 24 bit branch in a stub section will reach.
3825    .    b       dest
3826
3827    ppc_stub_plt_branch:
3828    Similar to the above, but a 24 bit branch in the stub section won't
3829    reach its destination.
3830    .    addis   %r11,%r2,xxx@toc@ha
3831    .    ld      %r12,xxx@toc@l(%r11)
3832    .    mtctr   %r12
3833    .    bctr
3834
3835    ppc_stub_plt_call:
3836    Used to call a function in a shared library.  If it so happens that
3837    the plt entry referenced crosses a 64k boundary, then an extra
3838    "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3839    .    std     %r2,40(%r1)
3840    .    addis   %r11,%r2,xxx@toc@ha
3841    .    ld      %r12,xxx+0@toc@l(%r11)
3842    .    mtctr   %r12
3843    .    ld      %r2,xxx+8@toc@l(%r11)
3844    .    ld      %r11,xxx+16@toc@l(%r11)
3845    .    bctr
3846
3847    ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3848    code to adjust the value and save r2 to support multiple toc sections.
3849    A ppc_stub_long_branch with an r2 offset looks like:
3850    .    std     %r2,40(%r1)
3851    .    addis   %r2,%r2,off@ha
3852    .    addi    %r2,%r2,off@l
3853    .    b       dest
3854
3855    A ppc_stub_plt_branch with an r2 offset looks like:
3856    .    std     %r2,40(%r1)
3857    .    addis   %r11,%r2,xxx@toc@ha
3858    .    ld      %r12,xxx@toc@l(%r11)
3859    .    addis   %r2,%r2,off@ha
3860    .    addi    %r2,%r2,off@l
3861    .    mtctr   %r12
3862    .    bctr
3863
3864    In cases where the "addis" instruction would add zero, the "addis" is
3865    omitted and following instructions modified slightly in some cases.
3866 */
3867
3868 enum ppc_stub_type {
3869   ppc_stub_none,
3870   ppc_stub_long_branch,
3871   ppc_stub_long_branch_r2off,
3872   ppc_stub_plt_branch,
3873   ppc_stub_plt_branch_r2off,
3874   ppc_stub_plt_call,
3875   ppc_stub_plt_call_r2save,
3876   ppc_stub_global_entry,
3877   ppc_stub_save_res
3878 };
3879
3880 /* Information on stub grouping.  */
3881 struct map_stub
3882 {
3883   /* The stub section.  */
3884   asection *stub_sec;
3885   /* This is the section to which stubs in the group will be attached.  */
3886   asection *link_sec;
3887   /* Next group.  */
3888   struct map_stub *next;
3889   /* Whether to emit a copy of register save/restore functions in this
3890      group.  */
3891   int needs_save_res;
3892 };
3893
3894 struct ppc_stub_hash_entry {
3895
3896   /* Base hash table entry structure.  */
3897   struct bfd_hash_entry root;
3898
3899   enum ppc_stub_type stub_type;
3900
3901   /* Group information.  */
3902   struct map_stub *group;
3903
3904   /* Offset within stub_sec of the beginning of this stub.  */
3905   bfd_vma stub_offset;
3906
3907   /* Given the symbol's value and its section we can determine its final
3908      value when building the stubs (so the stub knows where to jump.  */
3909   bfd_vma target_value;
3910   asection *target_section;
3911
3912   /* The symbol table entry, if any, that this was derived from.  */
3913   struct ppc_link_hash_entry *h;
3914   struct plt_entry *plt_ent;
3915
3916   /* Symbol st_other.  */
3917   unsigned char other;
3918 };
3919
3920 struct ppc_branch_hash_entry {
3921
3922   /* Base hash table entry structure.  */
3923   struct bfd_hash_entry root;
3924
3925   /* Offset within branch lookup table.  */
3926   unsigned int offset;
3927
3928   /* Generation marker.  */
3929   unsigned int iter;
3930 };
3931
3932 /* Used to track dynamic relocations for local symbols.  */
3933 struct ppc_dyn_relocs
3934 {
3935   struct ppc_dyn_relocs *next;
3936
3937   /* The input section of the reloc.  */
3938   asection *sec;
3939
3940   /* Total number of relocs copied for the input section.  */
3941   unsigned int count : 31;
3942
3943   /* Whether this entry is for STT_GNU_IFUNC symbols.  */
3944   unsigned int ifunc : 1;
3945 };
3946
3947 struct ppc_link_hash_entry
3948 {
3949   struct elf_link_hash_entry elf;
3950
3951   union {
3952     /* A pointer to the most recently used stub hash entry against this
3953        symbol.  */
3954     struct ppc_stub_hash_entry *stub_cache;
3955
3956     /* A pointer to the next symbol starting with a '.'  */
3957     struct ppc_link_hash_entry *next_dot_sym;
3958   } u;
3959
3960   /* Track dynamic relocs copied for this symbol.  */
3961   struct elf_dyn_relocs *dyn_relocs;
3962
3963   /* Chain of aliases referring to a weakdef.  */
3964   struct ppc_link_hash_entry *weakref;
3965
3966   /* Link between function code and descriptor symbols.  */
3967   struct ppc_link_hash_entry *oh;
3968
3969   /* Flag function code and descriptor symbols.  */
3970   unsigned int is_func:1;
3971   unsigned int is_func_descriptor:1;
3972   unsigned int fake:1;
3973
3974   /* Whether global opd/toc sym has been adjusted or not.
3975      After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3976      should be set for all globals defined in any opd/toc section.  */
3977   unsigned int adjust_done:1;
3978
3979   /* Set if we twiddled this symbol to weak at some stage.  */
3980   unsigned int was_undefined:1;
3981
3982   /* Set if this is an out-of-line register save/restore function,
3983      with non-standard calling convention.  */
3984   unsigned int save_res:1;
3985
3986   /* Contexts in which symbol is used in the GOT (or TOC).
3987      TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3988      corresponding relocs are encountered during check_relocs.
3989      tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3990      indicate the corresponding GOT entry type is not needed.
3991      tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3992      a TPREL one.  We use a separate flag rather than setting TPREL
3993      just for convenience in distinguishing the two cases.  */
3994 #define TLS_GD           1      /* GD reloc. */
3995 #define TLS_LD           2      /* LD reloc. */
3996 #define TLS_TPREL        4      /* TPREL reloc, => IE. */
3997 #define TLS_DTPREL       8      /* DTPREL reloc, => LD. */
3998 #define TLS_TLS         16      /* Any TLS reloc.  */
3999 #define TLS_EXPLICIT    32      /* Marks TOC section TLS relocs. */
4000 #define TLS_TPRELGD     64      /* TPREL reloc resulting from GD->IE. */
4001 #define PLT_IFUNC      128      /* STT_GNU_IFUNC.  */
4002   unsigned char tls_mask;
4003 };
4004
4005 /* ppc64 ELF linker hash table.  */
4006
4007 struct ppc_link_hash_table
4008 {
4009   struct elf_link_hash_table elf;
4010
4011   /* The stub hash table.  */
4012   struct bfd_hash_table stub_hash_table;
4013
4014   /* Another hash table for plt_branch stubs.  */
4015   struct bfd_hash_table branch_hash_table;
4016
4017   /* Hash table for function prologue tocsave.  */
4018   htab_t tocsave_htab;
4019
4020   /* Various options and other info passed from the linker.  */
4021   struct ppc64_elf_params *params;
4022
4023   /* The size of sec_info below.  */
4024   unsigned int sec_info_arr_size;
4025
4026   /* Per-section array of extra section info.  Done this way rather
4027      than as part of ppc64_elf_section_data so we have the info for
4028      non-ppc64 sections.  */
4029   struct
4030   {
4031     /* Along with elf_gp, specifies the TOC pointer used by this section.  */
4032     bfd_vma toc_off;
4033
4034     union
4035     {
4036       /* The section group that this section belongs to.  */
4037       struct map_stub *group;
4038       /* A temp section list pointer.  */
4039       asection *list;
4040     } u;
4041   } *sec_info;
4042
4043   /* Linked list of groups.  */
4044   struct map_stub *group;
4045
4046   /* Temp used when calculating TOC pointers.  */
4047   bfd_vma toc_curr;
4048   bfd *toc_bfd;
4049   asection *toc_first_sec;
4050
4051   /* Used when adding symbols.  */
4052   struct ppc_link_hash_entry *dot_syms;
4053
4054   /* Shortcuts to get to dynamic linker sections.  */
4055   asection *dynbss;
4056   asection *relbss;
4057   asection *glink;
4058   asection *sfpr;
4059   asection *brlt;
4060   asection *relbrlt;
4061   asection *glink_eh_frame;
4062
4063   /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
4064   struct ppc_link_hash_entry *tls_get_addr;
4065   struct ppc_link_hash_entry *tls_get_addr_fd;
4066
4067   /* The size of reliplt used by got entry relocs.  */
4068   bfd_size_type got_reli_size;
4069
4070   /* Statistics.  */
4071   unsigned long stub_count[ppc_stub_global_entry];
4072
4073   /* Number of stubs against global syms.  */
4074   unsigned long stub_globals;
4075
4076   /* Set if we're linking code with function descriptors.  */
4077   unsigned int opd_abi:1;
4078
4079   /* Support for multiple toc sections.  */
4080   unsigned int do_multi_toc:1;
4081   unsigned int multi_toc_needed:1;
4082   unsigned int second_toc_pass:1;
4083   unsigned int do_toc_opt:1;
4084
4085   /* Set on error.  */
4086   unsigned int stub_error:1;
4087
4088   /* Temp used by ppc64_elf_before_check_relocs.  */
4089   unsigned int twiddled_syms:1;
4090
4091   /* Incremented every time we size stubs.  */
4092   unsigned int stub_iteration;
4093
4094   /* Small local sym cache.  */
4095   struct sym_cache sym_cache;
4096 };
4097
4098 /* Rename some of the generic section flags to better document how they
4099    are used here.  */
4100
4101 /* Nonzero if this section has TLS related relocations.  */
4102 #define has_tls_reloc sec_flg0
4103
4104 /* Nonzero if this section has a call to __tls_get_addr.  */
4105 #define has_tls_get_addr_call sec_flg1
4106
4107 /* Nonzero if this section has any toc or got relocs.  */
4108 #define has_toc_reloc sec_flg2
4109
4110 /* Nonzero if this section has a call to another section that uses
4111    the toc or got.  */
4112 #define makes_toc_func_call sec_flg3
4113
4114 /* Recursion protection when determining above flag.  */
4115 #define call_check_in_progress sec_flg4
4116 #define call_check_done sec_flg5
4117
4118 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
4119
4120 #define ppc_hash_table(p) \
4121   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
4122   == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
4123
4124 #define ppc_stub_hash_lookup(table, string, create, copy) \
4125   ((struct ppc_stub_hash_entry *) \
4126    bfd_hash_lookup ((table), (string), (create), (copy)))
4127
4128 #define ppc_branch_hash_lookup(table, string, create, copy) \
4129   ((struct ppc_branch_hash_entry *) \
4130    bfd_hash_lookup ((table), (string), (create), (copy)))
4131
4132 /* Create an entry in the stub hash table.  */
4133
4134 static struct bfd_hash_entry *
4135 stub_hash_newfunc (struct bfd_hash_entry *entry,
4136                    struct bfd_hash_table *table,
4137                    const char *string)
4138 {
4139   /* Allocate the structure if it has not already been allocated by a
4140      subclass.  */
4141   if (entry == NULL)
4142     {
4143       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4144       if (entry == NULL)
4145         return entry;
4146     }
4147
4148   /* Call the allocation method of the superclass.  */
4149   entry = bfd_hash_newfunc (entry, table, string);
4150   if (entry != NULL)
4151     {
4152       struct ppc_stub_hash_entry *eh;
4153
4154       /* Initialize the local fields.  */
4155       eh = (struct ppc_stub_hash_entry *) entry;
4156       eh->stub_type = ppc_stub_none;
4157       eh->group = NULL;
4158       eh->stub_offset = 0;
4159       eh->target_value = 0;
4160       eh->target_section = NULL;
4161       eh->h = NULL;
4162       eh->plt_ent = NULL;
4163       eh->other = 0;
4164     }
4165
4166   return entry;
4167 }
4168
4169 /* Create an entry in the branch hash table.  */
4170
4171 static struct bfd_hash_entry *
4172 branch_hash_newfunc (struct bfd_hash_entry *entry,
4173                      struct bfd_hash_table *table,
4174                      const char *string)
4175 {
4176   /* Allocate the structure if it has not already been allocated by a
4177      subclass.  */
4178   if (entry == NULL)
4179     {
4180       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4181       if (entry == NULL)
4182         return entry;
4183     }
4184
4185   /* Call the allocation method of the superclass.  */
4186   entry = bfd_hash_newfunc (entry, table, string);
4187   if (entry != NULL)
4188     {
4189       struct ppc_branch_hash_entry *eh;
4190
4191       /* Initialize the local fields.  */
4192       eh = (struct ppc_branch_hash_entry *) entry;
4193       eh->offset = 0;
4194       eh->iter = 0;
4195     }
4196
4197   return entry;
4198 }
4199
4200 /* Create an entry in a ppc64 ELF linker hash table.  */
4201
4202 static struct bfd_hash_entry *
4203 link_hash_newfunc (struct bfd_hash_entry *entry,
4204                    struct bfd_hash_table *table,
4205                    const char *string)
4206 {
4207   /* Allocate the structure if it has not already been allocated by a
4208      subclass.  */
4209   if (entry == NULL)
4210     {
4211       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4212       if (entry == NULL)
4213         return entry;
4214     }
4215
4216   /* Call the allocation method of the superclass.  */
4217   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4218   if (entry != NULL)
4219     {
4220       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4221
4222       memset (&eh->u.stub_cache, 0,
4223               (sizeof (struct ppc_link_hash_entry)
4224                - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4225
4226       /* When making function calls, old ABI code references function entry
4227          points (dot symbols), while new ABI code references the function
4228          descriptor symbol.  We need to make any combination of reference and
4229          definition work together, without breaking archive linking.
4230
4231          For a defined function "foo" and an undefined call to "bar":
4232          An old object defines "foo" and ".foo", references ".bar" (possibly
4233          "bar" too).
4234          A new object defines "foo" and references "bar".
4235
4236          A new object thus has no problem with its undefined symbols being
4237          satisfied by definitions in an old object.  On the other hand, the
4238          old object won't have ".bar" satisfied by a new object.
4239
4240          Keep a list of newly added dot-symbols.  */
4241
4242       if (string[0] == '.')
4243         {
4244           struct ppc_link_hash_table *htab;
4245
4246           htab = (struct ppc_link_hash_table *) table;
4247           eh->u.next_dot_sym = htab->dot_syms;
4248           htab->dot_syms = eh;
4249         }
4250     }
4251
4252   return entry;
4253 }
4254
4255 struct tocsave_entry {
4256   asection *sec;
4257   bfd_vma offset;
4258 };
4259
4260 static hashval_t
4261 tocsave_htab_hash (const void *p)
4262 {
4263   const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4264   return ((bfd_vma)(intptr_t) e->sec ^ e->offset) >> 3;
4265 }
4266
4267 static int
4268 tocsave_htab_eq (const void *p1, const void *p2)
4269 {
4270   const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4271   const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4272   return e1->sec == e2->sec && e1->offset == e2->offset;
4273 }
4274
4275 /* Destroy a ppc64 ELF linker hash table.  */
4276
4277 static void
4278 ppc64_elf_link_hash_table_free (bfd *obfd)
4279 {
4280   struct ppc_link_hash_table *htab;
4281
4282   htab = (struct ppc_link_hash_table *) obfd->link.hash;
4283   if (htab->tocsave_htab)
4284     htab_delete (htab->tocsave_htab);
4285   bfd_hash_table_free (&htab->branch_hash_table);
4286   bfd_hash_table_free (&htab->stub_hash_table);
4287   _bfd_elf_link_hash_table_free (obfd);
4288 }
4289
4290 /* Create a ppc64 ELF linker hash table.  */
4291
4292 static struct bfd_link_hash_table *
4293 ppc64_elf_link_hash_table_create (bfd *abfd)
4294 {
4295   struct ppc_link_hash_table *htab;
4296   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4297
4298   htab = bfd_zmalloc (amt);
4299   if (htab == NULL)
4300     return NULL;
4301
4302   if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4303                                       sizeof (struct ppc_link_hash_entry),
4304                                       PPC64_ELF_DATA))
4305     {
4306       free (htab);
4307       return NULL;
4308     }
4309
4310   /* Init the stub hash table too.  */
4311   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4312                             sizeof (struct ppc_stub_hash_entry)))
4313     {
4314       _bfd_elf_link_hash_table_free (abfd);
4315       return NULL;
4316     }
4317
4318   /* And the branch hash table.  */
4319   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4320                             sizeof (struct ppc_branch_hash_entry)))
4321     {
4322       bfd_hash_table_free (&htab->stub_hash_table);
4323       _bfd_elf_link_hash_table_free (abfd);
4324       return NULL;
4325     }
4326
4327   htab->tocsave_htab = htab_try_create (1024,
4328                                         tocsave_htab_hash,
4329                                         tocsave_htab_eq,
4330                                         NULL);
4331   if (htab->tocsave_htab == NULL)
4332     {
4333       ppc64_elf_link_hash_table_free (abfd);
4334       return NULL;
4335     }
4336   htab->elf.root.hash_table_free = ppc64_elf_link_hash_table_free;
4337
4338   /* Initializing two fields of the union is just cosmetic.  We really
4339      only care about glist, but when compiled on a 32-bit host the
4340      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
4341      debugger inspection of these fields look nicer.  */
4342   htab->elf.init_got_refcount.refcount = 0;
4343   htab->elf.init_got_refcount.glist = NULL;
4344   htab->elf.init_plt_refcount.refcount = 0;
4345   htab->elf.init_plt_refcount.glist = NULL;
4346   htab->elf.init_got_offset.offset = 0;
4347   htab->elf.init_got_offset.glist = NULL;
4348   htab->elf.init_plt_offset.offset = 0;
4349   htab->elf.init_plt_offset.glist = NULL;
4350
4351   return &htab->elf.root;
4352 }
4353
4354 /* Create sections for linker generated code.  */
4355
4356 static bfd_boolean
4357 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4358 {
4359   struct ppc_link_hash_table *htab;
4360   flagword flags;
4361
4362   htab = ppc_hash_table (info);
4363
4364   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4365            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4366   if (htab->params->save_restore_funcs)
4367     {
4368       /* Create .sfpr for code to save and restore fp regs.  */
4369       htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4370                                                        flags);
4371       if (htab->sfpr == NULL
4372           || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4373         return FALSE;
4374     }
4375
4376   if (bfd_link_relocatable (info))
4377     return TRUE;
4378
4379   /* Create .glink for lazy dynamic linking support.  */
4380   htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4381                                                     flags);
4382   if (htab->glink == NULL
4383       || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4384     return FALSE;
4385
4386   if (!info->no_ld_generated_unwind_info)
4387     {
4388       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4389                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4390       htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4391                                                                  ".eh_frame",
4392                                                                  flags);
4393       if (htab->glink_eh_frame == NULL
4394           || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4395         return FALSE;
4396     }
4397
4398   flags = SEC_ALLOC | SEC_LINKER_CREATED;
4399   htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4400   if (htab->elf.iplt == NULL
4401       || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4402     return FALSE;
4403
4404   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4405            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4406   htab->elf.irelplt
4407     = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4408   if (htab->elf.irelplt == NULL
4409       || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4410     return FALSE;
4411
4412   /* Create branch lookup table for plt_branch stubs.  */
4413   flags = (SEC_ALLOC | SEC_LOAD
4414            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4415   htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4416                                                    flags);
4417   if (htab->brlt == NULL
4418       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4419     return FALSE;
4420
4421   if (!bfd_link_pic (info))
4422     return TRUE;
4423
4424   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4425            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4426   htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4427                                                       ".rela.branch_lt",
4428                                                       flags);
4429   if (htab->relbrlt == NULL
4430       || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4431     return FALSE;
4432
4433   return TRUE;
4434 }
4435
4436 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
4437
4438 bfd_boolean
4439 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4440                          struct ppc64_elf_params *params)
4441 {
4442   struct ppc_link_hash_table *htab;
4443
4444   elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4445
4446 /* Always hook our dynamic sections into the first bfd, which is the
4447    linker created stub bfd.  This ensures that the GOT header is at
4448    the start of the output TOC section.  */
4449   htab = ppc_hash_table (info);
4450   htab->elf.dynobj = params->stub_bfd;
4451   htab->params = params;
4452
4453   return create_linkage_sections (htab->elf.dynobj, info);
4454 }
4455
4456 /* Build a name for an entry in the stub hash table.  */
4457
4458 static char *
4459 ppc_stub_name (const asection *input_section,
4460                const asection *sym_sec,
4461                const struct ppc_link_hash_entry *h,
4462                const Elf_Internal_Rela *rel)
4463 {
4464   char *stub_name;
4465   ssize_t len;
4466
4467   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4468      offsets from a sym as a branch target?  In fact, we could
4469      probably assume the addend is always zero.  */
4470   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4471
4472   if (h)
4473     {
4474       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4475       stub_name = bfd_malloc (len);
4476       if (stub_name == NULL)
4477         return stub_name;
4478
4479       len = sprintf (stub_name, "%08x.%s+%x",
4480                      input_section->id & 0xffffffff,
4481                      h->elf.root.root.string,
4482                      (int) rel->r_addend & 0xffffffff);
4483     }
4484   else
4485     {
4486       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4487       stub_name = bfd_malloc (len);
4488       if (stub_name == NULL)
4489         return stub_name;
4490
4491       len = sprintf (stub_name, "%08x.%x:%x+%x",
4492                      input_section->id & 0xffffffff,
4493                      sym_sec->id & 0xffffffff,
4494                      (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4495                      (int) rel->r_addend & 0xffffffff);
4496     }
4497   if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4498     stub_name[len - 2] = 0;
4499   return stub_name;
4500 }
4501
4502 /* Look up an entry in the stub hash.  Stub entries are cached because
4503    creating the stub name takes a bit of time.  */
4504
4505 static struct ppc_stub_hash_entry *
4506 ppc_get_stub_entry (const asection *input_section,
4507                     const asection *sym_sec,
4508                     struct ppc_link_hash_entry *h,
4509                     const Elf_Internal_Rela *rel,
4510                     struct ppc_link_hash_table *htab)
4511 {
4512   struct ppc_stub_hash_entry *stub_entry;
4513   struct map_stub *group;
4514
4515   /* If this input section is part of a group of sections sharing one
4516      stub section, then use the id of the first section in the group.
4517      Stub names need to include a section id, as there may well be
4518      more than one stub used to reach say, printf, and we need to
4519      distinguish between them.  */
4520   group = htab->sec_info[input_section->id].u.group;
4521   if (group == NULL)
4522     return NULL;
4523
4524   if (h != NULL && h->u.stub_cache != NULL
4525       && h->u.stub_cache->h == h
4526       && h->u.stub_cache->group == group)
4527     {
4528       stub_entry = h->u.stub_cache;
4529     }
4530   else
4531     {
4532       char *stub_name;
4533
4534       stub_name = ppc_stub_name (group->link_sec, sym_sec, h, rel);
4535       if (stub_name == NULL)
4536         return NULL;
4537
4538       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4539                                          stub_name, FALSE, FALSE);
4540       if (h != NULL)
4541         h->u.stub_cache = stub_entry;
4542
4543       free (stub_name);
4544     }
4545
4546   return stub_entry;
4547 }
4548
4549 /* Add a new stub entry to the stub hash.  Not all fields of the new
4550    stub entry are initialised.  */
4551
4552 static struct ppc_stub_hash_entry *
4553 ppc_add_stub (const char *stub_name,
4554               asection *section,
4555               struct bfd_link_info *info)
4556 {
4557   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4558   struct map_stub *group;
4559   asection *link_sec;
4560   asection *stub_sec;
4561   struct ppc_stub_hash_entry *stub_entry;
4562
4563   group = htab->sec_info[section->id].u.group;
4564   link_sec = group->link_sec;
4565   stub_sec = group->stub_sec;
4566   if (stub_sec == NULL)
4567     {
4568       size_t namelen;
4569       bfd_size_type len;
4570       char *s_name;
4571
4572       namelen = strlen (link_sec->name);
4573       len = namelen + sizeof (STUB_SUFFIX);
4574       s_name = bfd_alloc (htab->params->stub_bfd, len);
4575       if (s_name == NULL)
4576         return NULL;
4577
4578       memcpy (s_name, link_sec->name, namelen);
4579       memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4580       stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4581       if (stub_sec == NULL)
4582         return NULL;
4583       group->stub_sec = stub_sec;
4584     }
4585
4586   /* Enter this entry into the linker stub hash table.  */
4587   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4588                                      TRUE, FALSE);
4589   if (stub_entry == NULL)
4590     {
4591       info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4592                               section->owner, stub_name);
4593       return NULL;
4594     }
4595
4596   stub_entry->group = group;
4597   stub_entry->stub_offset = 0;
4598   return stub_entry;
4599 }
4600
4601 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4602    not already done.  */
4603
4604 static bfd_boolean
4605 create_got_section (bfd *abfd, struct bfd_link_info *info)
4606 {
4607   asection *got, *relgot;
4608   flagword flags;
4609   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4610
4611   if (!is_ppc64_elf (abfd))
4612     return FALSE;
4613   if (htab == NULL)
4614     return FALSE;
4615
4616   if (!htab->elf.sgot
4617       && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4618     return FALSE;
4619
4620   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4621            | SEC_LINKER_CREATED);
4622
4623   got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4624   if (!got
4625       || !bfd_set_section_alignment (abfd, got, 3))
4626     return FALSE;
4627
4628   relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4629                                                flags | SEC_READONLY);
4630   if (!relgot
4631       || ! bfd_set_section_alignment (abfd, relgot, 3))
4632     return FALSE;
4633
4634   ppc64_elf_tdata (abfd)->got = got;
4635   ppc64_elf_tdata (abfd)->relgot = relgot;
4636   return TRUE;
4637 }
4638
4639 /* Create the dynamic sections, and set up shortcuts.  */
4640
4641 static bfd_boolean
4642 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4643 {
4644   struct ppc_link_hash_table *htab;
4645
4646   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4647     return FALSE;
4648
4649   htab = ppc_hash_table (info);
4650   if (htab == NULL)
4651     return FALSE;
4652
4653   htab->dynbss = bfd_get_linker_section (dynobj, ".dynbss");
4654   if (!bfd_link_pic (info))
4655     htab->relbss = bfd_get_linker_section (dynobj, ".rela.bss");
4656
4657   if (!htab->elf.sgot || !htab->elf.splt || !htab->elf.srelplt || !htab->dynbss
4658       || (!bfd_link_pic (info) && !htab->relbss))
4659     abort ();
4660
4661   return TRUE;
4662 }
4663
4664 /* Follow indirect and warning symbol links.  */
4665
4666 static inline struct bfd_link_hash_entry *
4667 follow_link (struct bfd_link_hash_entry *h)
4668 {
4669   while (h->type == bfd_link_hash_indirect
4670          || h->type == bfd_link_hash_warning)
4671     h = h->u.i.link;
4672   return h;
4673 }
4674
4675 static inline struct elf_link_hash_entry *
4676 elf_follow_link (struct elf_link_hash_entry *h)
4677 {
4678   return (struct elf_link_hash_entry *) follow_link (&h->root);
4679 }
4680
4681 static inline struct ppc_link_hash_entry *
4682 ppc_follow_link (struct ppc_link_hash_entry *h)
4683 {
4684   return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4685 }
4686
4687 /* Merge PLT info on FROM with that on TO.  */
4688
4689 static void
4690 move_plt_plist (struct ppc_link_hash_entry *from,
4691                 struct ppc_link_hash_entry *to)
4692 {
4693   if (from->elf.plt.plist != NULL)
4694     {
4695       if (to->elf.plt.plist != NULL)
4696         {
4697           struct plt_entry **entp;
4698           struct plt_entry *ent;
4699
4700           for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4701             {
4702               struct plt_entry *dent;
4703
4704               for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4705                 if (dent->addend == ent->addend)
4706                   {
4707                     dent->plt.refcount += ent->plt.refcount;
4708                     *entp = ent->next;
4709                     break;
4710                   }
4711               if (dent == NULL)
4712                 entp = &ent->next;
4713             }
4714           *entp = to->elf.plt.plist;
4715         }
4716
4717       to->elf.plt.plist = from->elf.plt.plist;
4718       from->elf.plt.plist = NULL;
4719     }
4720 }
4721
4722 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
4723
4724 static void
4725 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4726                                 struct elf_link_hash_entry *dir,
4727                                 struct elf_link_hash_entry *ind)
4728 {
4729   struct ppc_link_hash_entry *edir, *eind;
4730
4731   edir = (struct ppc_link_hash_entry *) dir;
4732   eind = (struct ppc_link_hash_entry *) ind;
4733
4734   edir->is_func |= eind->is_func;
4735   edir->is_func_descriptor |= eind->is_func_descriptor;
4736   edir->tls_mask |= eind->tls_mask;
4737   if (eind->oh != NULL)
4738     edir->oh = ppc_follow_link (eind->oh);
4739
4740   /* If called to transfer flags for a weakdef during processing
4741      of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4742      We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
4743   if (!(ELIMINATE_COPY_RELOCS
4744         && eind->elf.root.type != bfd_link_hash_indirect
4745         && edir->elf.dynamic_adjusted))
4746     edir->elf.non_got_ref |= eind->elf.non_got_ref;
4747
4748   edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4749   edir->elf.ref_regular |= eind->elf.ref_regular;
4750   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4751   edir->elf.needs_plt |= eind->elf.needs_plt;
4752   edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4753
4754   /* If we were called to copy over info for a weak sym, don't copy
4755      dyn_relocs, plt/got info, or dynindx.  We used to copy dyn_relocs
4756      in order to simplify readonly_dynrelocs and save a field in the
4757      symbol hash entry, but that means dyn_relocs can't be used in any
4758      tests about a specific symbol, or affect other symbol flags which
4759      are then tested.
4760      Chain weakdefs so we can get from the weakdef back to an alias.
4761      The list is circular so that we don't need to use u.weakdef as
4762      well as this list to look at all aliases.  */
4763   if (eind->elf.root.type != bfd_link_hash_indirect)
4764     {
4765       struct ppc_link_hash_entry *cur, *add, *next;
4766
4767       add = eind;
4768       do
4769         {
4770           cur = edir->weakref;
4771           if (cur != NULL)
4772             {
4773               do
4774                 {
4775                   /* We can be called twice for the same symbols.
4776                      Don't make multiple loops.  */
4777                   if (cur == add)
4778                     return;
4779                   cur = cur->weakref;
4780                 } while (cur != edir);
4781             }
4782           next = add->weakref;
4783           if (cur != add)
4784             {
4785               add->weakref = edir->weakref != NULL ? edir->weakref : edir;
4786               edir->weakref = add;
4787             }
4788           add = next;
4789         } while (add != NULL && add != eind);
4790       return;
4791     }
4792
4793   /* Copy over any dynamic relocs we may have on the indirect sym.  */
4794   if (eind->dyn_relocs != NULL)
4795     {
4796       if (edir->dyn_relocs != NULL)
4797         {
4798           struct elf_dyn_relocs **pp;
4799           struct elf_dyn_relocs *p;
4800
4801           /* Add reloc counts against the indirect sym to the direct sym
4802              list.  Merge any entries against the same section.  */
4803           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4804             {
4805               struct elf_dyn_relocs *q;
4806
4807               for (q = edir->dyn_relocs; q != NULL; q = q->next)
4808                 if (q->sec == p->sec)
4809                   {
4810                     q->pc_count += p->pc_count;
4811                     q->count += p->count;
4812                     *pp = p->next;
4813                     break;
4814                   }
4815               if (q == NULL)
4816                 pp = &p->next;
4817             }
4818           *pp = edir->dyn_relocs;
4819         }
4820
4821       edir->dyn_relocs = eind->dyn_relocs;
4822       eind->dyn_relocs = NULL;
4823     }
4824
4825   /* Copy over got entries that we may have already seen to the
4826      symbol which just became indirect.  */
4827   if (eind->elf.got.glist != NULL)
4828     {
4829       if (edir->elf.got.glist != NULL)
4830         {
4831           struct got_entry **entp;
4832           struct got_entry *ent;
4833
4834           for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4835             {
4836               struct got_entry *dent;
4837
4838               for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4839                 if (dent->addend == ent->addend
4840                     && dent->owner == ent->owner
4841                     && dent->tls_type == ent->tls_type)
4842                   {
4843                     dent->got.refcount += ent->got.refcount;
4844                     *entp = ent->next;
4845                     break;
4846                   }
4847               if (dent == NULL)
4848                 entp = &ent->next;
4849             }
4850           *entp = edir->elf.got.glist;
4851         }
4852
4853       edir->elf.got.glist = eind->elf.got.glist;
4854       eind->elf.got.glist = NULL;
4855     }
4856
4857   /* And plt entries.  */
4858   move_plt_plist (eind, edir);
4859
4860   if (eind->elf.dynindx != -1)
4861     {
4862       if (edir->elf.dynindx != -1)
4863         _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4864                                 edir->elf.dynstr_index);
4865       edir->elf.dynindx = eind->elf.dynindx;
4866       edir->elf.dynstr_index = eind->elf.dynstr_index;
4867       eind->elf.dynindx = -1;
4868       eind->elf.dynstr_index = 0;
4869     }
4870 }
4871
4872 /* Find the function descriptor hash entry from the given function code
4873    hash entry FH.  Link the entries via their OH fields.  */
4874
4875 static struct ppc_link_hash_entry *
4876 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4877 {
4878   struct ppc_link_hash_entry *fdh = fh->oh;
4879
4880   if (fdh == NULL)
4881     {
4882       const char *fd_name = fh->elf.root.root.string + 1;
4883
4884       fdh = (struct ppc_link_hash_entry *)
4885         elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4886       if (fdh == NULL)
4887         return fdh;
4888
4889       fdh->is_func_descriptor = 1;
4890       fdh->oh = fh;
4891       fh->is_func = 1;
4892       fh->oh = fdh;
4893     }
4894
4895   return ppc_follow_link (fdh);
4896 }
4897
4898 /* Make a fake function descriptor sym for the code sym FH.  */
4899
4900 static struct ppc_link_hash_entry *
4901 make_fdh (struct bfd_link_info *info,
4902           struct ppc_link_hash_entry *fh)
4903 {
4904   bfd *abfd;
4905   asymbol *newsym;
4906   struct bfd_link_hash_entry *bh;
4907   struct ppc_link_hash_entry *fdh;
4908
4909   abfd = fh->elf.root.u.undef.abfd;
4910   newsym = bfd_make_empty_symbol (abfd);
4911   newsym->name = fh->elf.root.root.string + 1;
4912   newsym->section = bfd_und_section_ptr;
4913   newsym->value = 0;
4914   newsym->flags = BSF_WEAK;
4915
4916   bh = NULL;
4917   if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4918                                          newsym->flags, newsym->section,
4919                                          newsym->value, NULL, FALSE, FALSE,
4920                                          &bh))
4921     return NULL;
4922
4923   fdh = (struct ppc_link_hash_entry *) bh;
4924   fdh->elf.non_elf = 0;
4925   fdh->fake = 1;
4926   fdh->is_func_descriptor = 1;
4927   fdh->oh = fh;
4928   fh->is_func = 1;
4929   fh->oh = fdh;
4930   return fdh;
4931 }
4932
4933 /* Fix function descriptor symbols defined in .opd sections to be
4934    function type.  */
4935
4936 static bfd_boolean
4937 ppc64_elf_add_symbol_hook (bfd *ibfd,
4938                            struct bfd_link_info *info,
4939                            Elf_Internal_Sym *isym,
4940                            const char **name,
4941                            flagword *flags ATTRIBUTE_UNUSED,
4942                            asection **sec,
4943                            bfd_vma *value)
4944 {
4945   if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4946       && (ibfd->flags & DYNAMIC) == 0
4947       && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
4948     elf_tdata (info->output_bfd)->has_gnu_symbols |= elf_gnu_symbol_ifunc;
4949
4950   if (*sec != NULL
4951       && strcmp ((*sec)->name, ".opd") == 0)
4952     {
4953       asection *code_sec;
4954
4955       if (!(ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4956             || ELF_ST_TYPE (isym->st_info) == STT_FUNC))
4957         isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4958
4959       /* If the symbol is a function defined in .opd, and the function
4960          code is in a discarded group, let it appear to be undefined.  */
4961       if (!bfd_link_relocatable (info)
4962           && (*sec)->reloc_count != 0
4963           && opd_entry_value (*sec, *value, &code_sec, NULL,
4964                               FALSE) != (bfd_vma) -1
4965           && discarded_section (code_sec))
4966         {
4967           *sec = bfd_und_section_ptr;
4968           isym->st_shndx = SHN_UNDEF;
4969         }
4970     }
4971   else if (*sec != NULL
4972            && strcmp ((*sec)->name, ".toc") == 0
4973            && ELF_ST_TYPE (isym->st_info) == STT_OBJECT)
4974     {
4975       struct ppc_link_hash_table *htab = ppc_hash_table (info);
4976       if (htab != NULL)
4977         htab->params->object_in_toc = 1;
4978     }
4979
4980   if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4981     {
4982       if (abiversion (ibfd) == 0)
4983         set_abiversion (ibfd, 2);
4984       else if (abiversion (ibfd) == 1)
4985         {
4986           info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other"
4987                                     " for ABI version 1\n"), name);
4988           bfd_set_error (bfd_error_bad_value);
4989           return FALSE;
4990         }
4991     }
4992
4993   return TRUE;
4994 }
4995
4996 /* Merge non-visibility st_other attributes: local entry point.  */
4997
4998 static void
4999 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
5000                                   const Elf_Internal_Sym *isym,
5001                                   bfd_boolean definition,
5002                                   bfd_boolean dynamic)
5003 {
5004   if (definition && !dynamic)
5005     h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
5006                 | ELF_ST_VISIBILITY (h->other));
5007 }
5008
5009 /* This function makes an old ABI object reference to ".bar" cause the
5010    inclusion of a new ABI object archive that defines "bar".
5011    NAME is a symbol defined in an archive.  Return a symbol in the hash
5012    table that might be satisfied by the archive symbols.  */
5013
5014 static struct elf_link_hash_entry *
5015 ppc64_elf_archive_symbol_lookup (bfd *abfd,
5016                                  struct bfd_link_info *info,
5017                                  const char *name)
5018 {
5019   struct elf_link_hash_entry *h;
5020   char *dot_name;
5021   size_t len;
5022
5023   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
5024   if (h != NULL
5025       /* Don't return this sym if it is a fake function descriptor
5026          created by add_symbol_adjust.  */
5027       && !(h->root.type == bfd_link_hash_undefweak
5028            && ((struct ppc_link_hash_entry *) h)->fake))
5029     return h;
5030
5031   if (name[0] == '.')
5032     return h;
5033
5034   len = strlen (name);
5035   dot_name = bfd_alloc (abfd, len + 2);
5036   if (dot_name == NULL)
5037     return (struct elf_link_hash_entry *) 0 - 1;
5038   dot_name[0] = '.';
5039   memcpy (dot_name + 1, name, len + 1);
5040   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
5041   bfd_release (abfd, dot_name);
5042   return h;
5043 }
5044
5045 /* This function satisfies all old ABI object references to ".bar" if a
5046    new ABI object defines "bar".  Well, at least, undefined dot symbols
5047    are made weak.  This stops later archive searches from including an
5048    object if we already have a function descriptor definition.  It also
5049    prevents the linker complaining about undefined symbols.
5050    We also check and correct mismatched symbol visibility here.  The
5051    most restrictive visibility of the function descriptor and the
5052    function entry symbol is used.  */
5053
5054 static bfd_boolean
5055 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
5056 {
5057   struct ppc_link_hash_table *htab;
5058   struct ppc_link_hash_entry *fdh;
5059
5060   if (eh->elf.root.type == bfd_link_hash_indirect)
5061     return TRUE;
5062
5063   if (eh->elf.root.type == bfd_link_hash_warning)
5064     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
5065
5066   if (eh->elf.root.root.string[0] != '.')
5067     abort ();
5068
5069   htab = ppc_hash_table (info);
5070   if (htab == NULL)
5071     return FALSE;
5072
5073   fdh = lookup_fdh (eh, htab);
5074   if (fdh == NULL)
5075     {
5076       if (!bfd_link_relocatable (info)
5077           && (eh->elf.root.type == bfd_link_hash_undefined
5078               || eh->elf.root.type == bfd_link_hash_undefweak)
5079           && eh->elf.ref_regular)
5080         {
5081           /* Make an undefweak function descriptor sym, which is enough to
5082              pull in an --as-needed shared lib, but won't cause link
5083              errors.  Archives are handled elsewhere.  */
5084           fdh = make_fdh (info, eh);
5085           if (fdh == NULL)
5086             return FALSE;
5087           fdh->elf.ref_regular = 1;
5088         }
5089     }
5090   else
5091     {
5092       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
5093       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
5094       if (entry_vis < descr_vis)
5095         fdh->elf.other += entry_vis - descr_vis;
5096       else if (entry_vis > descr_vis)
5097         eh->elf.other += descr_vis - entry_vis;
5098
5099       if ((fdh->elf.root.type == bfd_link_hash_defined
5100            || fdh->elf.root.type == bfd_link_hash_defweak)
5101           && eh->elf.root.type == bfd_link_hash_undefined)
5102         {
5103           eh->elf.root.type = bfd_link_hash_undefweak;
5104           eh->was_undefined = 1;
5105           htab->twiddled_syms = 1;
5106         }
5107     }
5108
5109   return TRUE;
5110 }
5111
5112 /* Set up opd section info and abiversion for IBFD, and process list
5113    of dot-symbols we made in link_hash_newfunc.  */
5114
5115 static bfd_boolean
5116 ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
5117 {
5118   struct ppc_link_hash_table *htab;
5119   struct ppc_link_hash_entry **p, *eh;
5120   asection *opd = bfd_get_section_by_name (ibfd, ".opd");
5121
5122   if (opd != NULL && opd->size != 0)
5123     {
5124       if (abiversion (ibfd) == 0)
5125         set_abiversion (ibfd, 1);
5126       else if (abiversion (ibfd) >= 2)
5127         {
5128           info->callbacks->einfo (_("%P: %B .opd not allowed in ABI"
5129                                     " version %d\n"),
5130                                   ibfd, abiversion (ibfd));
5131           bfd_set_error (bfd_error_bad_value);
5132           return FALSE;
5133         }
5134
5135       if ((ibfd->flags & DYNAMIC) == 0
5136           && (opd->flags & SEC_RELOC) != 0
5137           && opd->reloc_count != 0
5138           && !bfd_is_abs_section (opd->output_section))
5139         {
5140           /* Garbage collection needs some extra help with .opd sections.
5141              We don't want to necessarily keep everything referenced by
5142              relocs in .opd, as that would keep all functions.  Instead,
5143              if we reference an .opd symbol (a function descriptor), we
5144              want to keep the function code symbol's section.  This is
5145              easy for global symbols, but for local syms we need to keep
5146              information about the associated function section.  */
5147           bfd_size_type amt;
5148           asection **opd_sym_map;
5149
5150           amt = OPD_NDX (opd->size) * sizeof (*opd_sym_map);
5151           opd_sym_map = bfd_zalloc (ibfd, amt);
5152           if (opd_sym_map == NULL)
5153             return FALSE;
5154           ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
5155           BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
5156           ppc64_elf_section_data (opd)->sec_type = sec_opd;
5157         }
5158     }
5159
5160   if (!is_ppc64_elf (info->output_bfd))
5161     return TRUE;
5162   htab = ppc_hash_table (info);
5163   if (htab == NULL)
5164     return FALSE;
5165
5166   /* For input files without an explicit abiversion in e_flags
5167      we should have flagged any with symbol st_other bits set
5168      as ELFv1 and above flagged those with .opd as ELFv2.
5169      Set the output abiversion if not yet set, and for any input
5170      still ambiguous, take its abiversion from the output.
5171      Differences in ABI are reported later.  */
5172   if (abiversion (info->output_bfd) == 0)
5173     set_abiversion (info->output_bfd, abiversion (ibfd));
5174   else if (abiversion (ibfd) == 0)
5175     set_abiversion (ibfd, abiversion (info->output_bfd));
5176
5177   p = &htab->dot_syms;
5178   while ((eh = *p) != NULL)
5179     {
5180       *p = NULL;
5181       if (&eh->elf == htab->elf.hgot)
5182         ;
5183       else if (htab->elf.hgot == NULL
5184                && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
5185         htab->elf.hgot = &eh->elf;
5186       else if (!add_symbol_adjust (eh, info))
5187         return FALSE;
5188       p = &eh->u.next_dot_sym;
5189     }
5190
5191   /* Clear the list for non-ppc64 input files.  */
5192   p = &htab->dot_syms;
5193   while ((eh = *p) != NULL)
5194     {
5195       *p = NULL;
5196       p = &eh->u.next_dot_sym;
5197     }
5198
5199   /* We need to fix the undefs list for any syms we have twiddled to
5200      undefweak.  */
5201   if (htab->twiddled_syms)
5202     {
5203       bfd_link_repair_undef_list (&htab->elf.root);
5204       htab->twiddled_syms = 0;
5205     }
5206   return TRUE;
5207 }
5208
5209 /* Undo hash table changes when an --as-needed input file is determined
5210    not to be needed.  */
5211
5212 static bfd_boolean
5213 ppc64_elf_notice_as_needed (bfd *ibfd,
5214                             struct bfd_link_info *info,
5215                             enum notice_asneeded_action act)
5216 {
5217   if (act == notice_not_needed)
5218     {
5219       struct ppc_link_hash_table *htab = ppc_hash_table (info);
5220
5221       if (htab == NULL)
5222         return FALSE;
5223
5224       htab->dot_syms = NULL;
5225     }
5226   return _bfd_elf_notice_as_needed (ibfd, info, act);
5227 }
5228
5229 /* If --just-symbols against a final linked binary, then assume we need
5230    toc adjusting stubs when calling functions defined there.  */
5231
5232 static void
5233 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5234 {
5235   if ((sec->flags & SEC_CODE) != 0
5236       && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5237       && is_ppc64_elf (sec->owner))
5238     {
5239       if (abiversion (sec->owner) >= 2
5240           || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5241         sec->has_toc_reloc = 1;
5242     }
5243   _bfd_elf_link_just_syms (sec, info);
5244 }
5245
5246 static struct plt_entry **
5247 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5248                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5249 {
5250   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5251   struct plt_entry **local_plt;
5252   unsigned char *local_got_tls_masks;
5253
5254   if (local_got_ents == NULL)
5255     {
5256       bfd_size_type size = symtab_hdr->sh_info;
5257
5258       size *= (sizeof (*local_got_ents)
5259                + sizeof (*local_plt)
5260                + sizeof (*local_got_tls_masks));
5261       local_got_ents = bfd_zalloc (abfd, size);
5262       if (local_got_ents == NULL)
5263         return NULL;
5264       elf_local_got_ents (abfd) = local_got_ents;
5265     }
5266
5267   if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
5268     {
5269       struct got_entry *ent;
5270
5271       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5272         if (ent->addend == r_addend
5273             && ent->owner == abfd
5274             && ent->tls_type == tls_type)
5275           break;
5276       if (ent == NULL)
5277         {
5278           bfd_size_type amt = sizeof (*ent);
5279           ent = bfd_alloc (abfd, amt);
5280           if (ent == NULL)
5281             return FALSE;
5282           ent->next = local_got_ents[r_symndx];
5283           ent->addend = r_addend;
5284           ent->owner = abfd;
5285           ent->tls_type = tls_type;
5286           ent->is_indirect = FALSE;
5287           ent->got.refcount = 0;
5288           local_got_ents[r_symndx] = ent;
5289         }
5290       ent->got.refcount += 1;
5291     }
5292
5293   local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5294   local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5295   local_got_tls_masks[r_symndx] |= tls_type;
5296
5297   return local_plt + r_symndx;
5298 }
5299
5300 static bfd_boolean
5301 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5302 {
5303   struct plt_entry *ent;
5304
5305   for (ent = *plist; ent != NULL; ent = ent->next)
5306     if (ent->addend == addend)
5307       break;
5308   if (ent == NULL)
5309     {
5310       bfd_size_type amt = sizeof (*ent);
5311       ent = bfd_alloc (abfd, amt);
5312       if (ent == NULL)
5313         return FALSE;
5314       ent->next = *plist;
5315       ent->addend = addend;
5316       ent->plt.refcount = 0;
5317       *plist = ent;
5318     }
5319   ent->plt.refcount += 1;
5320   return TRUE;
5321 }
5322
5323 static bfd_boolean
5324 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5325 {
5326   return (r_type == R_PPC64_REL24
5327           || r_type == R_PPC64_REL14
5328           || r_type == R_PPC64_REL14_BRTAKEN
5329           || r_type == R_PPC64_REL14_BRNTAKEN
5330           || r_type == R_PPC64_ADDR24
5331           || r_type == R_PPC64_ADDR14
5332           || r_type == R_PPC64_ADDR14_BRTAKEN
5333           || r_type == R_PPC64_ADDR14_BRNTAKEN);
5334 }
5335
5336 /* Look through the relocs for a section during the first phase, and
5337    calculate needed space in the global offset table, procedure
5338    linkage table, and dynamic reloc sections.  */
5339
5340 static bfd_boolean
5341 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5342                         asection *sec, const Elf_Internal_Rela *relocs)
5343 {
5344   struct ppc_link_hash_table *htab;
5345   Elf_Internal_Shdr *symtab_hdr;
5346   struct elf_link_hash_entry **sym_hashes;
5347   const Elf_Internal_Rela *rel;
5348   const Elf_Internal_Rela *rel_end;
5349   asection *sreloc;
5350   asection **opd_sym_map;
5351   struct elf_link_hash_entry *tga, *dottga;
5352
5353   if (bfd_link_relocatable (info))
5354     return TRUE;
5355
5356   /* Don't do anything special with non-loaded, non-alloced sections.
5357      In particular, any relocs in such sections should not affect GOT
5358      and PLT reference counting (ie. we don't allow them to create GOT
5359      or PLT entries), there's no possibility or desire to optimize TLS
5360      relocs, and there's not much point in propagating relocs to shared
5361      libs that the dynamic linker won't relocate.  */
5362   if ((sec->flags & SEC_ALLOC) == 0)
5363     return TRUE;
5364
5365   BFD_ASSERT (is_ppc64_elf (abfd));
5366
5367   htab = ppc_hash_table (info);
5368   if (htab == NULL)
5369     return FALSE;
5370
5371   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5372                               FALSE, FALSE, TRUE);
5373   dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5374                                  FALSE, FALSE, TRUE);
5375   symtab_hdr = &elf_symtab_hdr (abfd);
5376   sym_hashes = elf_sym_hashes (abfd);
5377   sreloc = NULL;
5378   opd_sym_map = NULL;
5379   if (ppc64_elf_section_data (sec) != NULL
5380       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
5381     opd_sym_map = ppc64_elf_section_data (sec)->u.opd.func_sec;
5382
5383   rel_end = relocs + sec->reloc_count;
5384   for (rel = relocs; rel < rel_end; rel++)
5385     {
5386       unsigned long r_symndx;
5387       struct elf_link_hash_entry *h;
5388       enum elf_ppc64_reloc_type r_type;
5389       int tls_type;
5390       struct _ppc64_elf_section_data *ppc64_sec;
5391       struct plt_entry **ifunc, **plt_list;
5392
5393       r_symndx = ELF64_R_SYM (rel->r_info);
5394       if (r_symndx < symtab_hdr->sh_info)
5395         h = NULL;
5396       else
5397         {
5398           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5399           h = elf_follow_link (h);
5400
5401           /* PR15323, ref flags aren't set for references in the same
5402              object.  */
5403           h->root.non_ir_ref = 1;
5404
5405           if (h == htab->elf.hgot)
5406             sec->has_toc_reloc = 1;
5407         }
5408
5409       tls_type = 0;
5410       ifunc = NULL;
5411       if (h != NULL)
5412         {
5413           if (h->type == STT_GNU_IFUNC)
5414             {
5415               h->needs_plt = 1;
5416               ifunc = &h->plt.plist;
5417             }
5418         }
5419       else
5420         {
5421           Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5422                                                           abfd, r_symndx);
5423           if (isym == NULL)
5424             return FALSE;
5425
5426           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5427             {
5428               ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5429                                              rel->r_addend, PLT_IFUNC);
5430               if (ifunc == NULL)
5431                 return FALSE;
5432             }
5433         }
5434
5435       r_type = ELF64_R_TYPE (rel->r_info);
5436       switch (r_type)
5437         {
5438         case R_PPC64_TLSGD:
5439         case R_PPC64_TLSLD:
5440           /* These special tls relocs tie a call to __tls_get_addr with
5441              its parameter symbol.  */
5442           break;
5443
5444         case R_PPC64_GOT_TLSLD16:
5445         case R_PPC64_GOT_TLSLD16_LO:
5446         case R_PPC64_GOT_TLSLD16_HI:
5447         case R_PPC64_GOT_TLSLD16_HA:
5448           tls_type = TLS_TLS | TLS_LD;
5449           goto dogottls;
5450
5451         case R_PPC64_GOT_TLSGD16:
5452         case R_PPC64_GOT_TLSGD16_LO:
5453         case R_PPC64_GOT_TLSGD16_HI:
5454         case R_PPC64_GOT_TLSGD16_HA:
5455           tls_type = TLS_TLS | TLS_GD;
5456           goto dogottls;
5457
5458         case R_PPC64_GOT_TPREL16_DS:
5459         case R_PPC64_GOT_TPREL16_LO_DS:
5460         case R_PPC64_GOT_TPREL16_HI:
5461         case R_PPC64_GOT_TPREL16_HA:
5462           if (bfd_link_pic (info))
5463             info->flags |= DF_STATIC_TLS;
5464           tls_type = TLS_TLS | TLS_TPREL;
5465           goto dogottls;
5466
5467         case R_PPC64_GOT_DTPREL16_DS:
5468         case R_PPC64_GOT_DTPREL16_LO_DS:
5469         case R_PPC64_GOT_DTPREL16_HI:
5470         case R_PPC64_GOT_DTPREL16_HA:
5471           tls_type = TLS_TLS | TLS_DTPREL;
5472         dogottls:
5473           sec->has_tls_reloc = 1;
5474           /* Fall thru */
5475
5476         case R_PPC64_GOT16:
5477         case R_PPC64_GOT16_DS:
5478         case R_PPC64_GOT16_HA:
5479         case R_PPC64_GOT16_HI:
5480         case R_PPC64_GOT16_LO:
5481         case R_PPC64_GOT16_LO_DS:
5482           /* This symbol requires a global offset table entry.  */
5483           sec->has_toc_reloc = 1;
5484           if (r_type == R_PPC64_GOT_TLSLD16
5485               || r_type == R_PPC64_GOT_TLSGD16
5486               || r_type == R_PPC64_GOT_TPREL16_DS
5487               || r_type == R_PPC64_GOT_DTPREL16_DS
5488               || r_type == R_PPC64_GOT16
5489               || r_type == R_PPC64_GOT16_DS)
5490             {
5491               htab->do_multi_toc = 1;
5492               ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5493             }
5494
5495           if (ppc64_elf_tdata (abfd)->got == NULL
5496               && !create_got_section (abfd, info))
5497             return FALSE;
5498
5499           if (h != NULL)
5500             {
5501               struct ppc_link_hash_entry *eh;
5502               struct got_entry *ent;
5503
5504               eh = (struct ppc_link_hash_entry *) h;
5505               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5506                 if (ent->addend == rel->r_addend
5507                     && ent->owner == abfd
5508                     && ent->tls_type == tls_type)
5509                   break;
5510               if (ent == NULL)
5511                 {
5512                   bfd_size_type amt = sizeof (*ent);
5513                   ent = bfd_alloc (abfd, amt);
5514                   if (ent == NULL)
5515                     return FALSE;
5516                   ent->next = eh->elf.got.glist;
5517                   ent->addend = rel->r_addend;
5518                   ent->owner = abfd;
5519                   ent->tls_type = tls_type;
5520                   ent->is_indirect = FALSE;
5521                   ent->got.refcount = 0;
5522                   eh->elf.got.glist = ent;
5523                 }
5524               ent->got.refcount += 1;
5525               eh->tls_mask |= tls_type;
5526             }
5527           else
5528             /* This is a global offset table entry for a local symbol.  */
5529             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5530                                         rel->r_addend, tls_type))
5531               return FALSE;
5532
5533           /* We may also need a plt entry if the symbol turns out to be
5534              an ifunc.  */
5535           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1)
5536             {
5537               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5538                 return FALSE;
5539             }
5540           break;
5541
5542         case R_PPC64_PLT16_HA:
5543         case R_PPC64_PLT16_HI:
5544         case R_PPC64_PLT16_LO:
5545         case R_PPC64_PLT32:
5546         case R_PPC64_PLT64:
5547           /* This symbol requires a procedure linkage table entry.  */
5548           plt_list = ifunc;
5549           if (h != NULL)
5550             {
5551               h->needs_plt = 1;
5552               if (h->root.root.string[0] == '.'
5553                   && h->root.root.string[1] != '\0')
5554                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5555               plt_list = &h->plt.plist;
5556             }
5557           if (plt_list == NULL)
5558             {
5559               /* It does not make sense to have a procedure linkage
5560                  table entry for a non-ifunc local symbol.  */
5561               info->callbacks->einfo
5562                 (_("%P: %H: %s reloc against local symbol\n"),
5563                  abfd, sec, rel->r_offset,
5564                  ppc64_elf_howto_table[r_type]->name);
5565               bfd_set_error (bfd_error_bad_value);
5566               return FALSE;
5567             }
5568           if (!update_plt_info (abfd, plt_list, rel->r_addend))
5569             return FALSE;
5570           break;
5571
5572           /* The following relocations don't need to propagate the
5573              relocation if linking a shared object since they are
5574              section relative.  */
5575         case R_PPC64_SECTOFF:
5576         case R_PPC64_SECTOFF_LO:
5577         case R_PPC64_SECTOFF_HI:
5578         case R_PPC64_SECTOFF_HA:
5579         case R_PPC64_SECTOFF_DS:
5580         case R_PPC64_SECTOFF_LO_DS:
5581         case R_PPC64_DTPREL16:
5582         case R_PPC64_DTPREL16_LO:
5583         case R_PPC64_DTPREL16_HI:
5584         case R_PPC64_DTPREL16_HA:
5585         case R_PPC64_DTPREL16_DS:
5586         case R_PPC64_DTPREL16_LO_DS:
5587         case R_PPC64_DTPREL16_HIGH:
5588         case R_PPC64_DTPREL16_HIGHA:
5589         case R_PPC64_DTPREL16_HIGHER:
5590         case R_PPC64_DTPREL16_HIGHERA:
5591         case R_PPC64_DTPREL16_HIGHEST:
5592         case R_PPC64_DTPREL16_HIGHESTA:
5593           break;
5594
5595           /* Nor do these.  */
5596         case R_PPC64_REL16:
5597         case R_PPC64_REL16_LO:
5598         case R_PPC64_REL16_HI:
5599         case R_PPC64_REL16_HA:
5600         case R_PPC64_REL16DX_HA:
5601           break;
5602
5603           /* Not supported as a dynamic relocation.  */
5604         case R_PPC64_ADDR64_LOCAL:
5605           if (bfd_link_pic (info))
5606             {
5607               if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5608                 ppc_howto_init ();
5609               info->callbacks->einfo (_("%P: %H: %s reloc unsupported "
5610                                         "in shared libraries and PIEs.\n"),
5611                                       abfd, sec, rel->r_offset,
5612                                       ppc64_elf_howto_table[r_type]->name);
5613               bfd_set_error (bfd_error_bad_value);
5614               return FALSE;
5615             }
5616           break;
5617
5618         case R_PPC64_TOC16:
5619         case R_PPC64_TOC16_DS:
5620           htab->do_multi_toc = 1;
5621           ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5622         case R_PPC64_TOC16_LO:
5623         case R_PPC64_TOC16_HI:
5624         case R_PPC64_TOC16_HA:
5625         case R_PPC64_TOC16_LO_DS:
5626           sec->has_toc_reloc = 1;
5627           break;
5628
5629           /* Marker reloc.  */
5630         case R_PPC64_ENTRY:
5631           break;
5632
5633           /* This relocation describes the C++ object vtable hierarchy.
5634              Reconstruct it for later use during GC.  */
5635         case R_PPC64_GNU_VTINHERIT:
5636           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5637             return FALSE;
5638           break;
5639
5640           /* This relocation describes which C++ vtable entries are actually
5641              used.  Record for later use during GC.  */
5642         case R_PPC64_GNU_VTENTRY:
5643           BFD_ASSERT (h != NULL);
5644           if (h != NULL
5645               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5646             return FALSE;
5647           break;
5648
5649         case R_PPC64_REL14:
5650         case R_PPC64_REL14_BRTAKEN:
5651         case R_PPC64_REL14_BRNTAKEN:
5652           {
5653             asection *dest = NULL;
5654
5655             /* Heuristic: If jumping outside our section, chances are
5656                we are going to need a stub.  */
5657             if (h != NULL)
5658               {
5659                 /* If the sym is weak it may be overridden later, so
5660                    don't assume we know where a weak sym lives.  */
5661                 if (h->root.type == bfd_link_hash_defined)
5662                   dest = h->root.u.def.section;
5663               }
5664             else
5665               {
5666                 Elf_Internal_Sym *isym;
5667
5668                 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5669                                               abfd, r_symndx);
5670                 if (isym == NULL)
5671                   return FALSE;
5672
5673                 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5674               }
5675
5676             if (dest != sec)
5677               ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5678           }
5679           /* Fall through.  */
5680
5681         case R_PPC64_REL24:
5682           plt_list = ifunc;
5683           if (h != NULL)
5684             {
5685               h->needs_plt = 1;
5686               if (h->root.root.string[0] == '.'
5687                   && h->root.root.string[1] != '\0')
5688                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5689
5690               if (h == tga || h == dottga)
5691                 {
5692                   sec->has_tls_reloc = 1;
5693                   if (rel != relocs
5694                       && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5695                           || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5696                     /* We have a new-style __tls_get_addr call with
5697                        a marker reloc.  */
5698                     ;
5699                   else
5700                     /* Mark this section as having an old-style call.  */
5701                     sec->has_tls_get_addr_call = 1;
5702                 }
5703               plt_list = &h->plt.plist;
5704             }
5705
5706           /* We may need a .plt entry if the function this reloc
5707              refers to is in a shared lib.  */
5708           if (plt_list
5709               && !update_plt_info (abfd, plt_list, rel->r_addend))
5710             return FALSE;
5711           break;
5712
5713         case R_PPC64_ADDR14:
5714         case R_PPC64_ADDR14_BRNTAKEN:
5715         case R_PPC64_ADDR14_BRTAKEN:
5716         case R_PPC64_ADDR24:
5717           goto dodyn;
5718
5719         case R_PPC64_TPREL64:
5720           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5721           if (bfd_link_pic (info))
5722             info->flags |= DF_STATIC_TLS;
5723           goto dotlstoc;
5724
5725         case R_PPC64_DTPMOD64:
5726           if (rel + 1 < rel_end
5727               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5728               && rel[1].r_offset == rel->r_offset + 8)
5729             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5730           else
5731             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5732           goto dotlstoc;
5733
5734         case R_PPC64_DTPREL64:
5735           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5736           if (rel != relocs
5737               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5738               && rel[-1].r_offset == rel->r_offset - 8)
5739             /* This is the second reloc of a dtpmod, dtprel pair.
5740                Don't mark with TLS_DTPREL.  */
5741             goto dodyn;
5742
5743         dotlstoc:
5744           sec->has_tls_reloc = 1;
5745           if (h != NULL)
5746             {
5747               struct ppc_link_hash_entry *eh;
5748               eh = (struct ppc_link_hash_entry *) h;
5749               eh->tls_mask |= tls_type;
5750             }
5751           else
5752             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5753                                         rel->r_addend, tls_type))
5754               return FALSE;
5755
5756           ppc64_sec = ppc64_elf_section_data (sec);
5757           if (ppc64_sec->sec_type != sec_toc)
5758             {
5759               bfd_size_type amt;
5760
5761               /* One extra to simplify get_tls_mask.  */
5762               amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5763               ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5764               if (ppc64_sec->u.toc.symndx == NULL)
5765                 return FALSE;
5766               amt = sec->size * sizeof (bfd_vma) / 8;
5767               ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5768               if (ppc64_sec->u.toc.add == NULL)
5769                 return FALSE;
5770               BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5771               ppc64_sec->sec_type = sec_toc;
5772             }
5773           BFD_ASSERT (rel->r_offset % 8 == 0);
5774           ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5775           ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5776
5777           /* Mark the second slot of a GD or LD entry.
5778              -1 to indicate GD and -2 to indicate LD.  */
5779           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5780             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5781           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5782             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5783           goto dodyn;
5784
5785         case R_PPC64_TPREL16:
5786         case R_PPC64_TPREL16_LO:
5787         case R_PPC64_TPREL16_HI:
5788         case R_PPC64_TPREL16_HA:
5789         case R_PPC64_TPREL16_DS:
5790         case R_PPC64_TPREL16_LO_DS:
5791         case R_PPC64_TPREL16_HIGH:
5792         case R_PPC64_TPREL16_HIGHA:
5793         case R_PPC64_TPREL16_HIGHER:
5794         case R_PPC64_TPREL16_HIGHERA:
5795         case R_PPC64_TPREL16_HIGHEST:
5796         case R_PPC64_TPREL16_HIGHESTA:
5797           if (bfd_link_pic (info))
5798             {
5799               info->flags |= DF_STATIC_TLS;
5800               goto dodyn;
5801             }
5802           break;
5803
5804         case R_PPC64_ADDR64:
5805           if (opd_sym_map != NULL
5806               && rel + 1 < rel_end
5807               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5808             {
5809               if (h != NULL)
5810                 {
5811                   if (h->root.root.string[0] == '.'
5812                       && h->root.root.string[1] != 0
5813                       && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
5814                     ;
5815                   else
5816                     ((struct ppc_link_hash_entry *) h)->is_func = 1;
5817                 }
5818               else
5819                 {
5820                   asection *s;
5821                   Elf_Internal_Sym *isym;
5822
5823                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5824                                                 abfd, r_symndx);
5825                   if (isym == NULL)
5826                     return FALSE;
5827
5828                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5829                   if (s != NULL && s != sec)
5830                     opd_sym_map[OPD_NDX (rel->r_offset)] = s;
5831                 }
5832             }
5833           /* Fall through.  */
5834
5835         case R_PPC64_ADDR16:
5836         case R_PPC64_ADDR16_DS:
5837         case R_PPC64_ADDR16_HA:
5838         case R_PPC64_ADDR16_HI:
5839         case R_PPC64_ADDR16_HIGH:
5840         case R_PPC64_ADDR16_HIGHA:
5841         case R_PPC64_ADDR16_HIGHER:
5842         case R_PPC64_ADDR16_HIGHERA:
5843         case R_PPC64_ADDR16_HIGHEST:
5844         case R_PPC64_ADDR16_HIGHESTA:
5845         case R_PPC64_ADDR16_LO:
5846         case R_PPC64_ADDR16_LO_DS:
5847           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1
5848               && rel->r_addend == 0)
5849             {
5850               /* We may need a .plt entry if this reloc refers to a
5851                  function in a shared lib.  */
5852               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5853                 return FALSE;
5854               h->pointer_equality_needed = 1;
5855             }
5856           /* Fall through.  */
5857
5858         case R_PPC64_REL30:
5859         case R_PPC64_REL32:
5860         case R_PPC64_REL64:
5861         case R_PPC64_ADDR32:
5862         case R_PPC64_UADDR16:
5863         case R_PPC64_UADDR32:
5864         case R_PPC64_UADDR64:
5865         case R_PPC64_TOC:
5866           if (h != NULL && !bfd_link_pic (info))
5867             /* We may need a copy reloc.  */
5868             h->non_got_ref = 1;
5869
5870           /* Don't propagate .opd relocs.  */
5871           if (NO_OPD_RELOCS && opd_sym_map != NULL)
5872             break;
5873
5874           /* If we are creating a shared library, and this is a reloc
5875              against a global symbol, or a non PC relative reloc
5876              against a local symbol, then we need to copy the reloc
5877              into the shared library.  However, if we are linking with
5878              -Bsymbolic, we do not need to copy a reloc against a
5879              global symbol which is defined in an object we are
5880              including in the link (i.e., DEF_REGULAR is set).  At
5881              this point we have not seen all the input files, so it is
5882              possible that DEF_REGULAR is not set now but will be set
5883              later (it is never cleared).  In case of a weak definition,
5884              DEF_REGULAR may be cleared later by a strong definition in
5885              a shared library.  We account for that possibility below by
5886              storing information in the dyn_relocs field of the hash
5887              table entry.  A similar situation occurs when creating
5888              shared libraries and symbol visibility changes render the
5889              symbol local.
5890
5891              If on the other hand, we are creating an executable, we
5892              may need to keep relocations for symbols satisfied by a
5893              dynamic library if we manage to avoid copy relocs for the
5894              symbol.  */
5895         dodyn:
5896           if ((bfd_link_pic (info)
5897                && (must_be_dyn_reloc (info, r_type)
5898                    || (h != NULL
5899                        && (!SYMBOLIC_BIND (info, h)
5900                            || h->root.type == bfd_link_hash_defweak
5901                            || !h->def_regular))))
5902               || (ELIMINATE_COPY_RELOCS
5903                   && !bfd_link_pic (info)
5904                   && h != NULL
5905                   && (h->root.type == bfd_link_hash_defweak
5906                       || !h->def_regular))
5907               || (!bfd_link_pic (info)
5908                   && ifunc != NULL))
5909             {
5910               /* We must copy these reloc types into the output file.
5911                  Create a reloc section in dynobj and make room for
5912                  this reloc.  */
5913               if (sreloc == NULL)
5914                 {
5915                   sreloc = _bfd_elf_make_dynamic_reloc_section
5916                     (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5917
5918                   if (sreloc == NULL)
5919                     return FALSE;
5920                 }
5921
5922               /* If this is a global symbol, we count the number of
5923                  relocations we need for this symbol.  */
5924               if (h != NULL)
5925                 {
5926                   struct elf_dyn_relocs *p;
5927                   struct elf_dyn_relocs **head;
5928
5929                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5930                   p = *head;
5931                   if (p == NULL || p->sec != sec)
5932                     {
5933                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5934                       if (p == NULL)
5935                         return FALSE;
5936                       p->next = *head;
5937                       *head = p;
5938                       p->sec = sec;
5939                       p->count = 0;
5940                       p->pc_count = 0;
5941                     }
5942                   p->count += 1;
5943                   if (!must_be_dyn_reloc (info, r_type))
5944                     p->pc_count += 1;
5945                 }
5946               else
5947                 {
5948                   /* Track dynamic relocs needed for local syms too.
5949                      We really need local syms available to do this
5950                      easily.  Oh well.  */
5951                   struct ppc_dyn_relocs *p;
5952                   struct ppc_dyn_relocs **head;
5953                   bfd_boolean is_ifunc;
5954                   asection *s;
5955                   void *vpp;
5956                   Elf_Internal_Sym *isym;
5957
5958                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5959                                                 abfd, r_symndx);
5960                   if (isym == NULL)
5961                     return FALSE;
5962
5963                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5964                   if (s == NULL)
5965                     s = sec;
5966
5967                   vpp = &elf_section_data (s)->local_dynrel;
5968                   head = (struct ppc_dyn_relocs **) vpp;
5969                   is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5970                   p = *head;
5971                   if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5972                     p = p->next;
5973                   if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5974                     {
5975                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5976                       if (p == NULL)
5977                         return FALSE;
5978                       p->next = *head;
5979                       *head = p;
5980                       p->sec = sec;
5981                       p->ifunc = is_ifunc;
5982                       p->count = 0;
5983                     }
5984                   p->count += 1;
5985                 }
5986             }
5987           break;
5988
5989         default:
5990           break;
5991         }
5992     }
5993
5994   return TRUE;
5995 }
5996
5997 /* Merge backend specific data from an object file to the output
5998    object file when linking.  */
5999
6000 static bfd_boolean
6001 ppc64_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
6002 {
6003   unsigned long iflags, oflags;
6004
6005   if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
6006     return TRUE;
6007
6008   if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
6009     return TRUE;
6010
6011   if (!_bfd_generic_verify_endian_match (ibfd, obfd))
6012     return FALSE;
6013
6014   iflags = elf_elfheader (ibfd)->e_flags;
6015   oflags = elf_elfheader (obfd)->e_flags;
6016
6017   if (iflags & ~EF_PPC64_ABI)
6018     {
6019       (*_bfd_error_handler)
6020         (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
6021       bfd_set_error (bfd_error_bad_value);
6022       return FALSE;
6023     }
6024   else if (iflags != oflags && iflags != 0)
6025     {
6026       (*_bfd_error_handler)
6027         (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
6028          ibfd, iflags, oflags);
6029       bfd_set_error (bfd_error_bad_value);
6030       return FALSE;
6031     }
6032
6033   /* Merge Tag_compatibility attributes and any common GNU ones.  */
6034   _bfd_elf_merge_object_attributes (ibfd, obfd);
6035
6036   return TRUE;
6037 }
6038
6039 static bfd_boolean
6040 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
6041 {
6042   /* Print normal ELF private data.  */
6043   _bfd_elf_print_private_bfd_data (abfd, ptr);
6044
6045   if (elf_elfheader (abfd)->e_flags != 0)
6046     {
6047       FILE *file = ptr;
6048
6049       /* xgettext:c-format */
6050       fprintf (file, _("private flags = 0x%lx:"),
6051                elf_elfheader (abfd)->e_flags);
6052
6053       if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
6054         fprintf (file, _(" [abiv%ld]"),
6055                  elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
6056       fputc ('\n', file);
6057     }
6058
6059   return TRUE;
6060 }
6061
6062 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
6063    of the code entry point, and its section, which must be in the same
6064    object as OPD_SEC.  Returns (bfd_vma) -1 on error.  */
6065
6066 static bfd_vma
6067 opd_entry_value (asection *opd_sec,
6068                  bfd_vma offset,
6069                  asection **code_sec,
6070                  bfd_vma *code_off,
6071                  bfd_boolean in_code_sec)
6072 {
6073   bfd *opd_bfd = opd_sec->owner;
6074   Elf_Internal_Rela *relocs;
6075   Elf_Internal_Rela *lo, *hi, *look;
6076   bfd_vma val;
6077
6078   /* No relocs implies we are linking a --just-symbols object, or looking
6079      at a final linked executable with addr2line or somesuch.  */
6080   if (opd_sec->reloc_count == 0)
6081     {
6082       bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
6083
6084       if (contents == NULL)
6085         {
6086           if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
6087             return (bfd_vma) -1;
6088           ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
6089         }
6090
6091       /* PR 17512: file: 64b9dfbb.  */
6092       if (offset + 7 >= opd_sec->size || offset + 7 < offset)
6093         return (bfd_vma) -1;
6094
6095       val = bfd_get_64 (opd_bfd, contents + offset);
6096       if (code_sec != NULL)
6097         {
6098           asection *sec, *likely = NULL;
6099
6100           if (in_code_sec)
6101             {
6102               sec = *code_sec;
6103               if (sec->vma <= val
6104                   && val < sec->vma + sec->size)
6105                 likely = sec;
6106               else
6107                 val = -1;
6108             }
6109           else
6110             for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
6111               if (sec->vma <= val
6112                   && (sec->flags & SEC_LOAD) != 0
6113                   && (sec->flags & SEC_ALLOC) != 0)
6114                 likely = sec;
6115           if (likely != NULL)
6116             {
6117               *code_sec = likely;
6118               if (code_off != NULL)
6119                 *code_off = val - likely->vma;
6120             }
6121         }
6122       return val;
6123     }
6124
6125   BFD_ASSERT (is_ppc64_elf (opd_bfd));
6126
6127   relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
6128   if (relocs == NULL)
6129     relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
6130   /* PR 17512: file: df8e1fd6.  */
6131   if (relocs == NULL)
6132     return (bfd_vma) -1;
6133
6134   /* Go find the opd reloc at the sym address.  */
6135   lo = relocs;
6136   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
6137   val = (bfd_vma) -1;
6138   while (lo < hi)
6139     {
6140       look = lo + (hi - lo) / 2;
6141       if (look->r_offset < offset)
6142         lo = look + 1;
6143       else if (look->r_offset > offset)
6144         hi = look;
6145       else
6146         {
6147           Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
6148
6149           if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
6150               && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
6151             {
6152               unsigned long symndx = ELF64_R_SYM (look->r_info);
6153               asection *sec = NULL;
6154
6155               if (symndx >= symtab_hdr->sh_info
6156                   && elf_sym_hashes (opd_bfd) != NULL)
6157                 {
6158                   struct elf_link_hash_entry **sym_hashes;
6159                   struct elf_link_hash_entry *rh;
6160
6161                   sym_hashes = elf_sym_hashes (opd_bfd);
6162                   rh = sym_hashes[symndx - symtab_hdr->sh_info];
6163                   if (rh != NULL)
6164                     {
6165                       rh = elf_follow_link (rh);
6166                       if (rh->root.type != bfd_link_hash_defined
6167                           && rh->root.type != bfd_link_hash_defweak)
6168                         break;
6169                       if (rh->root.u.def.section->owner == opd_bfd)
6170                         {
6171                           val = rh->root.u.def.value;
6172                           sec = rh->root.u.def.section;
6173                         }
6174                     }
6175                 }
6176
6177               if (sec == NULL)
6178                 {
6179                   Elf_Internal_Sym *sym;
6180
6181                   if (symndx < symtab_hdr->sh_info)
6182                     {
6183                       sym = (Elf_Internal_Sym *) symtab_hdr->contents;
6184                       if (sym == NULL)
6185                         {
6186                           size_t symcnt = symtab_hdr->sh_info;
6187                           sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6188                                                       symcnt, 0,
6189                                                       NULL, NULL, NULL);
6190                           if (sym == NULL)
6191                             break;
6192                           symtab_hdr->contents = (bfd_byte *) sym;
6193                         }
6194                       sym += symndx;
6195                     }
6196                   else
6197                     {
6198                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6199                                                   1, symndx,
6200                                                   NULL, NULL, NULL);
6201                       if (sym == NULL)
6202                         break;
6203                     }
6204                   sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6205                   if (sec == NULL)
6206                     break;
6207                   BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
6208                   val = sym->st_value;
6209                 }
6210
6211               val += look->r_addend;
6212               if (code_off != NULL)
6213                 *code_off = val;
6214               if (code_sec != NULL)
6215                 {
6216                   if (in_code_sec && *code_sec != sec)
6217                     return -1;
6218                   else
6219                     *code_sec = sec;
6220                 }
6221               if (sec->output_section != NULL)
6222                 val += sec->output_section->vma + sec->output_offset;
6223             }
6224           break;
6225         }
6226     }
6227
6228   return val;
6229 }
6230
6231 /* If the ELF symbol SYM might be a function in SEC, return the
6232    function size and set *CODE_OFF to the function's entry point,
6233    otherwise return zero.  */
6234
6235 static bfd_size_type
6236 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6237                               bfd_vma *code_off)
6238 {
6239   bfd_size_type size;
6240
6241   if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6242                      | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6243     return 0;
6244
6245   size = 0;
6246   if (!(sym->flags & BSF_SYNTHETIC))
6247     size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6248
6249   if (strcmp (sym->section->name, ".opd") == 0)
6250     {
6251       struct _opd_sec_data *opd = get_opd_info (sym->section);
6252       bfd_vma symval = sym->value;
6253
6254       if (opd != NULL
6255           && opd->adjust != NULL
6256           && elf_section_data (sym->section)->relocs != NULL)
6257         {
6258           /* opd_entry_value will use cached relocs that have been
6259              adjusted, but with raw symbols.  That means both local
6260              and global symbols need adjusting.  */
6261           long adjust = opd->adjust[OPD_NDX (symval)];
6262           if (adjust == -1)
6263             return 0;
6264           symval += adjust;
6265         }
6266
6267       if (opd_entry_value (sym->section, symval,
6268                            &sec, code_off, TRUE) == (bfd_vma) -1)
6269         return 0;
6270       /* An old ABI binary with dot-syms has a size of 24 on the .opd
6271          symbol.  This size has nothing to do with the code size of the
6272          function, which is what we're supposed to return, but the
6273          code size isn't available without looking up the dot-sym.
6274          However, doing that would be a waste of time particularly
6275          since elf_find_function will look at the dot-sym anyway.
6276          Now, elf_find_function will keep the largest size of any
6277          function sym found at the code address of interest, so return
6278          1 here to avoid it incorrectly caching a larger function size
6279          for a small function.  This does mean we return the wrong
6280          size for a new-ABI function of size 24, but all that does is
6281          disable caching for such functions.  */
6282       if (size == 24)
6283         size = 1;
6284     }
6285   else
6286     {
6287       if (sym->section != sec)
6288         return 0;
6289       *code_off = sym->value;
6290     }
6291   if (size == 0)
6292     size = 1;
6293   return size;
6294 }
6295
6296 /* Return true if symbol is defined in a regular object file.  */
6297
6298 static bfd_boolean
6299 is_static_defined (struct elf_link_hash_entry *h)
6300 {
6301   return ((h->root.type == bfd_link_hash_defined
6302            || h->root.type == bfd_link_hash_defweak)
6303           && h->root.u.def.section != NULL
6304           && h->root.u.def.section->output_section != NULL);
6305 }
6306
6307 /* If FDH is a function descriptor symbol, return the associated code
6308    entry symbol if it is defined.  Return NULL otherwise.  */
6309
6310 static struct ppc_link_hash_entry *
6311 defined_code_entry (struct ppc_link_hash_entry *fdh)
6312 {
6313   if (fdh->is_func_descriptor)
6314     {
6315       struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6316       if (fh->elf.root.type == bfd_link_hash_defined
6317           || fh->elf.root.type == bfd_link_hash_defweak)
6318         return fh;
6319     }
6320   return NULL;
6321 }
6322
6323 /* If FH is a function code entry symbol, return the associated
6324    function descriptor symbol if it is defined.  Return NULL otherwise.  */
6325
6326 static struct ppc_link_hash_entry *
6327 defined_func_desc (struct ppc_link_hash_entry *fh)
6328 {
6329   if (fh->oh != NULL
6330       && fh->oh->is_func_descriptor)
6331     {
6332       struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6333       if (fdh->elf.root.type == bfd_link_hash_defined
6334           || fdh->elf.root.type == bfd_link_hash_defweak)
6335         return fdh;
6336     }
6337   return NULL;
6338 }
6339
6340 /* Mark all our entry sym sections, both opd and code section.  */
6341
6342 static void
6343 ppc64_elf_gc_keep (struct bfd_link_info *info)
6344 {
6345   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6346   struct bfd_sym_chain *sym;
6347
6348   if (htab == NULL)
6349     return;
6350
6351   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6352     {
6353       struct ppc_link_hash_entry *eh, *fh;
6354       asection *sec;
6355
6356       eh = (struct ppc_link_hash_entry *)
6357         elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6358       if (eh == NULL)
6359         continue;
6360       if (eh->elf.root.type != bfd_link_hash_defined
6361           && eh->elf.root.type != bfd_link_hash_defweak)
6362         continue;
6363
6364       fh = defined_code_entry (eh);
6365       if (fh != NULL)
6366         {
6367           sec = fh->elf.root.u.def.section;
6368           sec->flags |= SEC_KEEP;
6369         }
6370       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6371                && opd_entry_value (eh->elf.root.u.def.section,
6372                                    eh->elf.root.u.def.value,
6373                                    &sec, NULL, FALSE) != (bfd_vma) -1)
6374         sec->flags |= SEC_KEEP;
6375
6376       sec = eh->elf.root.u.def.section;
6377       sec->flags |= SEC_KEEP;
6378     }
6379 }
6380
6381 /* Mark sections containing dynamically referenced symbols.  When
6382    building shared libraries, we must assume that any visible symbol is
6383    referenced.  */
6384
6385 static bfd_boolean
6386 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6387 {
6388   struct bfd_link_info *info = (struct bfd_link_info *) inf;
6389   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6390   struct ppc_link_hash_entry *fdh;
6391   struct bfd_elf_dynamic_list *d = info->dynamic_list;
6392
6393   /* Dynamic linking info is on the func descriptor sym.  */
6394   fdh = defined_func_desc (eh);
6395   if (fdh != NULL)
6396     eh = fdh;
6397
6398   if ((eh->elf.root.type == bfd_link_hash_defined
6399        || eh->elf.root.type == bfd_link_hash_defweak)
6400       && (eh->elf.ref_dynamic
6401           || ((eh->elf.def_regular || ELF_COMMON_DEF_P (&eh->elf))
6402               && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6403               && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6404               && (!bfd_link_executable (info)
6405                   || info->export_dynamic
6406                   || (eh->elf.dynamic
6407                       && d != NULL
6408                       && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
6409               && (strchr (eh->elf.root.root.string, ELF_VER_CHR) != NULL
6410                   || !bfd_hide_sym_by_version (info->version_info,
6411                                                eh->elf.root.root.string)))))
6412     {
6413       asection *code_sec;
6414       struct ppc_link_hash_entry *fh;
6415
6416       eh->elf.root.u.def.section->flags |= SEC_KEEP;
6417
6418       /* Function descriptor syms cause the associated
6419          function code sym section to be marked.  */
6420       fh = defined_code_entry (eh);
6421       if (fh != NULL)
6422         {
6423           code_sec = fh->elf.root.u.def.section;
6424           code_sec->flags |= SEC_KEEP;
6425         }
6426       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6427                && opd_entry_value (eh->elf.root.u.def.section,
6428                                    eh->elf.root.u.def.value,
6429                                    &code_sec, NULL, FALSE) != (bfd_vma) -1)
6430         code_sec->flags |= SEC_KEEP;
6431     }
6432
6433   return TRUE;
6434 }
6435
6436 /* Return the section that should be marked against GC for a given
6437    relocation.  */
6438
6439 static asection *
6440 ppc64_elf_gc_mark_hook (asection *sec,
6441                         struct bfd_link_info *info,
6442                         Elf_Internal_Rela *rel,
6443                         struct elf_link_hash_entry *h,
6444                         Elf_Internal_Sym *sym)
6445 {
6446   asection *rsec;
6447
6448   /* Syms return NULL if we're marking .opd, so we avoid marking all
6449      function sections, as all functions are referenced in .opd.  */
6450   rsec = NULL;
6451   if (get_opd_info (sec) != NULL)
6452     return rsec;
6453
6454   if (h != NULL)
6455     {
6456       enum elf_ppc64_reloc_type r_type;
6457       struct ppc_link_hash_entry *eh, *fh, *fdh;
6458
6459       r_type = ELF64_R_TYPE (rel->r_info);
6460       switch (r_type)
6461         {
6462         case R_PPC64_GNU_VTINHERIT:
6463         case R_PPC64_GNU_VTENTRY:
6464           break;
6465
6466         default:
6467           switch (h->root.type)
6468             {
6469             case bfd_link_hash_defined:
6470             case bfd_link_hash_defweak:
6471               eh = (struct ppc_link_hash_entry *) h;
6472               fdh = defined_func_desc (eh);
6473               if (fdh != NULL)
6474                 eh = fdh;
6475
6476               /* Function descriptor syms cause the associated
6477                  function code sym section to be marked.  */
6478               fh = defined_code_entry (eh);
6479               if (fh != NULL)
6480                 {
6481                   /* They also mark their opd section.  */
6482                   eh->elf.root.u.def.section->gc_mark = 1;
6483
6484                   rsec = fh->elf.root.u.def.section;
6485                 }
6486               else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6487                        && opd_entry_value (eh->elf.root.u.def.section,
6488                                            eh->elf.root.u.def.value,
6489                                            &rsec, NULL, FALSE) != (bfd_vma) -1)
6490                 eh->elf.root.u.def.section->gc_mark = 1;
6491               else
6492                 rsec = h->root.u.def.section;
6493               break;
6494
6495             case bfd_link_hash_common:
6496               rsec = h->root.u.c.p->section;
6497               break;
6498
6499             default:
6500               return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6501             }
6502         }
6503     }
6504   else
6505     {
6506       struct _opd_sec_data *opd;
6507
6508       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6509       opd = get_opd_info (rsec);
6510       if (opd != NULL && opd->func_sec != NULL)
6511         {
6512           rsec->gc_mark = 1;
6513
6514           rsec = opd->func_sec[OPD_NDX (sym->st_value + rel->r_addend)];
6515         }
6516     }
6517
6518   return rsec;
6519 }
6520
6521 /* Update the .got, .plt. and dynamic reloc reference counts for the
6522    section being removed.  */
6523
6524 static bfd_boolean
6525 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
6526                          asection *sec, const Elf_Internal_Rela *relocs)
6527 {
6528   struct ppc_link_hash_table *htab;
6529   Elf_Internal_Shdr *symtab_hdr;
6530   struct elf_link_hash_entry **sym_hashes;
6531   struct got_entry **local_got_ents;
6532   const Elf_Internal_Rela *rel, *relend;
6533
6534   if (bfd_link_relocatable (info))
6535     return TRUE;
6536
6537   if ((sec->flags & SEC_ALLOC) == 0)
6538     return TRUE;
6539
6540   elf_section_data (sec)->local_dynrel = NULL;
6541
6542   htab = ppc_hash_table (info);
6543   if (htab == NULL)
6544     return FALSE;
6545
6546   symtab_hdr = &elf_symtab_hdr (abfd);
6547   sym_hashes = elf_sym_hashes (abfd);
6548   local_got_ents = elf_local_got_ents (abfd);
6549
6550   relend = relocs + sec->reloc_count;
6551   for (rel = relocs; rel < relend; rel++)
6552     {
6553       unsigned long r_symndx;
6554       enum elf_ppc64_reloc_type r_type;
6555       struct elf_link_hash_entry *h = NULL;
6556       struct plt_entry **plt_list;
6557       unsigned char tls_type = 0;
6558
6559       r_symndx = ELF64_R_SYM (rel->r_info);
6560       r_type = ELF64_R_TYPE (rel->r_info);
6561       if (r_symndx >= symtab_hdr->sh_info)
6562         {
6563           struct ppc_link_hash_entry *eh;
6564           struct elf_dyn_relocs **pp;
6565           struct elf_dyn_relocs *p;
6566
6567           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6568           h = elf_follow_link (h);
6569           eh = (struct ppc_link_hash_entry *) h;
6570
6571           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6572             if (p->sec == sec)
6573               {
6574                 /* Everything must go for SEC.  */
6575                 *pp = p->next;
6576                 break;
6577               }
6578         }
6579
6580       switch (r_type)
6581         {
6582         case R_PPC64_GOT_TLSLD16:
6583         case R_PPC64_GOT_TLSLD16_LO:
6584         case R_PPC64_GOT_TLSLD16_HI:
6585         case R_PPC64_GOT_TLSLD16_HA:
6586           tls_type = TLS_TLS | TLS_LD;
6587           goto dogot;
6588
6589         case R_PPC64_GOT_TLSGD16:
6590         case R_PPC64_GOT_TLSGD16_LO:
6591         case R_PPC64_GOT_TLSGD16_HI:
6592         case R_PPC64_GOT_TLSGD16_HA:
6593           tls_type = TLS_TLS | TLS_GD;
6594           goto dogot;
6595
6596         case R_PPC64_GOT_TPREL16_DS:
6597         case R_PPC64_GOT_TPREL16_LO_DS:
6598         case R_PPC64_GOT_TPREL16_HI:
6599         case R_PPC64_GOT_TPREL16_HA:
6600           tls_type = TLS_TLS | TLS_TPREL;
6601           goto dogot;
6602
6603         case R_PPC64_GOT_DTPREL16_DS:
6604         case R_PPC64_GOT_DTPREL16_LO_DS:
6605         case R_PPC64_GOT_DTPREL16_HI:
6606         case R_PPC64_GOT_DTPREL16_HA:
6607           tls_type = TLS_TLS | TLS_DTPREL;
6608           goto dogot;
6609
6610         case R_PPC64_GOT16:
6611         case R_PPC64_GOT16_DS:
6612         case R_PPC64_GOT16_HA:
6613         case R_PPC64_GOT16_HI:
6614         case R_PPC64_GOT16_LO:
6615         case R_PPC64_GOT16_LO_DS:
6616         dogot:
6617           {
6618             struct got_entry *ent;
6619
6620             if (h != NULL)
6621               ent = h->got.glist;
6622             else
6623               ent = local_got_ents[r_symndx];
6624
6625             for (; ent != NULL; ent = ent->next)
6626               if (ent->addend == rel->r_addend
6627                   && ent->owner == abfd
6628                   && ent->tls_type == tls_type)
6629                 break;
6630             if (ent == NULL)
6631               abort ();
6632             if (ent->got.refcount > 0)
6633               ent->got.refcount -= 1;
6634           }
6635           break;
6636
6637         case R_PPC64_PLT16_HA:
6638         case R_PPC64_PLT16_HI:
6639         case R_PPC64_PLT16_LO:
6640         case R_PPC64_PLT32:
6641         case R_PPC64_PLT64:
6642         case R_PPC64_REL14:
6643         case R_PPC64_REL14_BRNTAKEN:
6644         case R_PPC64_REL14_BRTAKEN:
6645         case R_PPC64_REL24:
6646           plt_list = NULL;
6647           if (h != NULL)
6648             plt_list = &h->plt.plist;
6649           else if (local_got_ents != NULL)
6650             {
6651               struct plt_entry **local_plt = (struct plt_entry **)
6652                 (local_got_ents + symtab_hdr->sh_info);
6653               unsigned char *local_got_tls_masks = (unsigned char *)
6654                 (local_plt + symtab_hdr->sh_info);
6655               if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6656                 plt_list = local_plt + r_symndx;
6657             }
6658           if (plt_list)
6659             {
6660               struct plt_entry *ent;
6661
6662               for (ent = *plt_list; ent != NULL; ent = ent->next)
6663                 if (ent->addend == rel->r_addend)
6664                   break;
6665               if (ent != NULL && ent->plt.refcount > 0)
6666                 ent->plt.refcount -= 1;
6667             }
6668           break;
6669
6670         default:
6671           break;
6672         }
6673     }
6674   return TRUE;
6675 }
6676
6677 /* The maximum size of .sfpr.  */
6678 #define SFPR_MAX (218*4)
6679
6680 struct sfpr_def_parms
6681 {
6682   const char name[12];
6683   unsigned char lo, hi;
6684   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6685   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6686 };
6687
6688 /* Auto-generate _save*, _rest* functions in .sfpr.
6689    If STUB_SEC is non-null, define alias symbols in STUB_SEC
6690    instead.  */
6691
6692 static bfd_boolean
6693 sfpr_define (struct bfd_link_info *info,
6694              const struct sfpr_def_parms *parm,
6695              asection *stub_sec)
6696 {
6697   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6698   unsigned int i;
6699   size_t len = strlen (parm->name);
6700   bfd_boolean writing = FALSE;
6701   char sym[16];
6702
6703   if (htab == NULL)
6704     return FALSE;
6705
6706   memcpy (sym, parm->name, len);
6707   sym[len + 2] = 0;
6708
6709   for (i = parm->lo; i <= parm->hi; i++)
6710     {
6711       struct ppc_link_hash_entry *h;
6712
6713       sym[len + 0] = i / 10 + '0';
6714       sym[len + 1] = i % 10 + '0';
6715       h = (struct ppc_link_hash_entry *)
6716         elf_link_hash_lookup (&htab->elf, sym, writing, TRUE, TRUE);
6717       if (stub_sec != NULL)
6718         {
6719           if (h != NULL
6720               && h->elf.root.type == bfd_link_hash_defined
6721               && h->elf.root.u.def.section == htab->sfpr)
6722             {
6723               struct elf_link_hash_entry *s;
6724               char buf[32];
6725               sprintf (buf, "%08x.%s", stub_sec->id & 0xffffffff, sym);
6726               s = elf_link_hash_lookup (&htab->elf, buf, TRUE, TRUE, FALSE);
6727               if (s == NULL)
6728                 return FALSE;
6729               if (s->root.type == bfd_link_hash_new
6730                   || (s->root.type = bfd_link_hash_defined
6731                       && s->root.u.def.section == stub_sec))
6732                 {
6733                   s->root.type = bfd_link_hash_defined;
6734                   s->root.u.def.section = stub_sec;
6735                   s->root.u.def.value = (stub_sec->size
6736                                          + h->elf.root.u.def.value);
6737                   s->ref_regular = 1;
6738                   s->def_regular = 1;
6739                   s->ref_regular_nonweak = 1;
6740                   s->forced_local = 1;
6741                   s->non_elf = 0;
6742                   s->root.linker_def = 1;
6743                 }
6744             }
6745           continue;
6746         }
6747       if (h != NULL)
6748         {
6749           h->save_res = 1;
6750           if (!h->elf.def_regular)
6751             {
6752               h->elf.root.type = bfd_link_hash_defined;
6753               h->elf.root.u.def.section = htab->sfpr;
6754               h->elf.root.u.def.value = htab->sfpr->size;
6755               h->elf.type = STT_FUNC;
6756               h->elf.def_regular = 1;
6757               h->elf.non_elf = 0;
6758               _bfd_elf_link_hash_hide_symbol (info, &h->elf, TRUE);
6759               writing = TRUE;
6760               if (htab->sfpr->contents == NULL)
6761                 {
6762                   htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6763                   if (htab->sfpr->contents == NULL)
6764                     return FALSE;
6765                 }
6766             }
6767         }
6768       if (writing)
6769         {
6770           bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6771           if (i != parm->hi)
6772             p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6773           else
6774             p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6775           htab->sfpr->size = p - htab->sfpr->contents;
6776         }
6777     }
6778
6779   return TRUE;
6780 }
6781
6782 static bfd_byte *
6783 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6784 {
6785   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6786   return p + 4;
6787 }
6788
6789 static bfd_byte *
6790 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6791 {
6792   p = savegpr0 (abfd, p, r);
6793   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6794   p = p + 4;
6795   bfd_put_32 (abfd, BLR, p);
6796   return p + 4;
6797 }
6798
6799 static bfd_byte *
6800 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6801 {
6802   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6803   return p + 4;
6804 }
6805
6806 static bfd_byte *
6807 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6808 {
6809   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6810   p = p + 4;
6811   p = restgpr0 (abfd, p, r);
6812   bfd_put_32 (abfd, MTLR_R0, p);
6813   p = p + 4;
6814   if (r == 29)
6815     {
6816       p = restgpr0 (abfd, p, 30);
6817       p = restgpr0 (abfd, p, 31);
6818     }
6819   bfd_put_32 (abfd, BLR, p);
6820   return p + 4;
6821 }
6822
6823 static bfd_byte *
6824 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6825 {
6826   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6827   return p + 4;
6828 }
6829
6830 static bfd_byte *
6831 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6832 {
6833   p = savegpr1 (abfd, p, r);
6834   bfd_put_32 (abfd, BLR, p);
6835   return p + 4;
6836 }
6837
6838 static bfd_byte *
6839 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6840 {
6841   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6842   return p + 4;
6843 }
6844
6845 static bfd_byte *
6846 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6847 {
6848   p = restgpr1 (abfd, p, r);
6849   bfd_put_32 (abfd, BLR, p);
6850   return p + 4;
6851 }
6852
6853 static bfd_byte *
6854 savefpr (bfd *abfd, bfd_byte *p, int r)
6855 {
6856   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6857   return p + 4;
6858 }
6859
6860 static bfd_byte *
6861 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6862 {
6863   p = savefpr (abfd, p, r);
6864   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6865   p = p + 4;
6866   bfd_put_32 (abfd, BLR, p);
6867   return p + 4;
6868 }
6869
6870 static bfd_byte *
6871 restfpr (bfd *abfd, bfd_byte *p, int r)
6872 {
6873   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6874   return p + 4;
6875 }
6876
6877 static bfd_byte *
6878 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6879 {
6880   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6881   p = p + 4;
6882   p = restfpr (abfd, p, r);
6883   bfd_put_32 (abfd, MTLR_R0, p);
6884   p = p + 4;
6885   if (r == 29)
6886     {
6887       p = restfpr (abfd, p, 30);
6888       p = restfpr (abfd, p, 31);
6889     }
6890   bfd_put_32 (abfd, BLR, p);
6891   return p + 4;
6892 }
6893
6894 static bfd_byte *
6895 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6896 {
6897   p = savefpr (abfd, p, r);
6898   bfd_put_32 (abfd, BLR, p);
6899   return p + 4;
6900 }
6901
6902 static bfd_byte *
6903 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6904 {
6905   p = restfpr (abfd, p, r);
6906   bfd_put_32 (abfd, BLR, p);
6907   return p + 4;
6908 }
6909
6910 static bfd_byte *
6911 savevr (bfd *abfd, bfd_byte *p, int r)
6912 {
6913   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6914   p = p + 4;
6915   bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6916   return p + 4;
6917 }
6918
6919 static bfd_byte *
6920 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6921 {
6922   p = savevr (abfd, p, r);
6923   bfd_put_32 (abfd, BLR, p);
6924   return p + 4;
6925 }
6926
6927 static bfd_byte *
6928 restvr (bfd *abfd, bfd_byte *p, int r)
6929 {
6930   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6931   p = p + 4;
6932   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6933   return p + 4;
6934 }
6935
6936 static bfd_byte *
6937 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6938 {
6939   p = restvr (abfd, p, r);
6940   bfd_put_32 (abfd, BLR, p);
6941   return p + 4;
6942 }
6943
6944 /* Called via elf_link_hash_traverse to transfer dynamic linking
6945    information on function code symbol entries to their corresponding
6946    function descriptor symbol entries.  */
6947
6948 static bfd_boolean
6949 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6950 {
6951   struct bfd_link_info *info;
6952   struct ppc_link_hash_table *htab;
6953   struct plt_entry *ent;
6954   struct ppc_link_hash_entry *fh;
6955   struct ppc_link_hash_entry *fdh;
6956   bfd_boolean force_local;
6957
6958   fh = (struct ppc_link_hash_entry *) h;
6959   if (fh->elf.root.type == bfd_link_hash_indirect)
6960     return TRUE;
6961
6962   info = inf;
6963   htab = ppc_hash_table (info);
6964   if (htab == NULL)
6965     return FALSE;
6966
6967   /* Resolve undefined references to dot-symbols as the value
6968      in the function descriptor, if we have one in a regular object.
6969      This is to satisfy cases like ".quad .foo".  Calls to functions
6970      in dynamic objects are handled elsewhere.  */
6971   if (fh->elf.root.type == bfd_link_hash_undefweak
6972       && fh->was_undefined
6973       && (fdh = defined_func_desc (fh)) != NULL
6974       && get_opd_info (fdh->elf.root.u.def.section) != NULL
6975       && opd_entry_value (fdh->elf.root.u.def.section,
6976                           fdh->elf.root.u.def.value,
6977                           &fh->elf.root.u.def.section,
6978                           &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
6979     {
6980       fh->elf.root.type = fdh->elf.root.type;
6981       fh->elf.forced_local = 1;
6982       fh->elf.def_regular = fdh->elf.def_regular;
6983       fh->elf.def_dynamic = fdh->elf.def_dynamic;
6984     }
6985
6986   /* If this is a function code symbol, transfer dynamic linking
6987      information to the function descriptor symbol.  */
6988   if (!fh->is_func)
6989     return TRUE;
6990
6991   for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6992     if (ent->plt.refcount > 0)
6993       break;
6994   if (ent == NULL
6995       || fh->elf.root.root.string[0] != '.'
6996       || fh->elf.root.root.string[1] == '\0')
6997     return TRUE;
6998
6999   /* Find the corresponding function descriptor symbol.  Create it
7000      as undefined if necessary.  */
7001
7002   fdh = lookup_fdh (fh, htab);
7003   if (fdh == NULL
7004       && !bfd_link_executable (info)
7005       && (fh->elf.root.type == bfd_link_hash_undefined
7006           || fh->elf.root.type == bfd_link_hash_undefweak))
7007     {
7008       fdh = make_fdh (info, fh);
7009       if (fdh == NULL)
7010         return FALSE;
7011     }
7012
7013   /* Fake function descriptors are made undefweak.  If the function
7014      code symbol is strong undefined, make the fake sym the same.
7015      If the function code symbol is defined, then force the fake
7016      descriptor local;  We can't support overriding of symbols in a
7017      shared library on a fake descriptor.  */
7018
7019   if (fdh != NULL
7020       && fdh->fake
7021       && fdh->elf.root.type == bfd_link_hash_undefweak)
7022     {
7023       if (fh->elf.root.type == bfd_link_hash_undefined)
7024         {
7025           fdh->elf.root.type = bfd_link_hash_undefined;
7026           bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
7027         }
7028       else if (fh->elf.root.type == bfd_link_hash_defined
7029                || fh->elf.root.type == bfd_link_hash_defweak)
7030         {
7031           _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
7032         }
7033     }
7034
7035   if (fdh != NULL
7036       && !fdh->elf.forced_local
7037       && (!bfd_link_executable (info)
7038           || fdh->elf.def_dynamic
7039           || fdh->elf.ref_dynamic
7040           || (fdh->elf.root.type == bfd_link_hash_undefweak
7041               && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
7042     {
7043       if (fdh->elf.dynindx == -1)
7044         if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
7045           return FALSE;
7046       fdh->elf.ref_regular |= fh->elf.ref_regular;
7047       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
7048       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
7049       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
7050       if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
7051         {
7052           move_plt_plist (fh, fdh);
7053           fdh->elf.needs_plt = 1;
7054         }
7055       fdh->is_func_descriptor = 1;
7056       fdh->oh = fh;
7057       fh->oh = fdh;
7058     }
7059
7060   /* Now that the info is on the function descriptor, clear the
7061      function code sym info.  Any function code syms for which we
7062      don't have a definition in a regular file, we force local.
7063      This prevents a shared library from exporting syms that have
7064      been imported from another library.  Function code syms that
7065      are really in the library we must leave global to prevent the
7066      linker dragging in a definition from a static library.  */
7067   force_local = (!fh->elf.def_regular
7068                  || fdh == NULL
7069                  || !fdh->elf.def_regular
7070                  || fdh->elf.forced_local);
7071   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7072
7073   return TRUE;
7074 }
7075
7076 static const struct sfpr_def_parms save_res_funcs[] =
7077   {
7078     { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
7079     { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
7080     { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
7081     { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
7082     { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
7083     { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
7084     { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
7085     { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
7086     { "._savef", 14, 31, savefpr, savefpr1_tail },
7087     { "._restf", 14, 31, restfpr, restfpr1_tail },
7088     { "_savevr_", 20, 31, savevr, savevr_tail },
7089     { "_restvr_", 20, 31, restvr, restvr_tail }
7090   };
7091
7092 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
7093    this hook to a) provide some gcc support functions, and b) transfer
7094    dynamic linking information gathered so far on function code symbol
7095    entries, to their corresponding function descriptor symbol entries.  */
7096
7097 static bfd_boolean
7098 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
7099                             struct bfd_link_info *info)
7100 {
7101   struct ppc_link_hash_table *htab;
7102
7103   htab = ppc_hash_table (info);
7104   if (htab == NULL)
7105     return FALSE;
7106
7107   /* Provide any missing _save* and _rest* functions.  */
7108   if (htab->sfpr != NULL)
7109     {
7110       unsigned int i;
7111
7112       htab->sfpr->size = 0;
7113       for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
7114         if (!sfpr_define (info, &save_res_funcs[i], NULL))
7115           return FALSE;
7116       if (htab->sfpr->size == 0)
7117         htab->sfpr->flags |= SEC_EXCLUDE;
7118     }
7119
7120   if (bfd_link_relocatable (info))
7121     return TRUE;
7122
7123   if (htab->elf.hgot != NULL)
7124     {
7125       _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
7126       /* Make .TOC. defined so as to prevent it being made dynamic.
7127          The wrong value here is fixed later in ppc64_elf_set_toc.  */
7128       if (!htab->elf.hgot->def_regular
7129           || htab->elf.hgot->root.type != bfd_link_hash_defined)
7130         {
7131           htab->elf.hgot->root.type = bfd_link_hash_defined;
7132           htab->elf.hgot->root.u.def.value = 0;
7133           htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
7134           htab->elf.hgot->def_regular = 1;
7135           htab->elf.hgot->root.linker_def = 1;
7136         }
7137       htab->elf.hgot->type = STT_OBJECT;
7138       htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
7139                                | STV_HIDDEN);
7140     }
7141
7142   elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
7143
7144   return TRUE;
7145 }
7146
7147 /* Return true if we have dynamic relocs against H that apply to
7148    read-only sections.  */
7149
7150 static bfd_boolean
7151 readonly_dynrelocs (struct elf_link_hash_entry *h)
7152 {
7153   struct ppc_link_hash_entry *eh;
7154   struct elf_dyn_relocs *p;
7155
7156   eh = (struct ppc_link_hash_entry *) h;
7157   for (p = eh->dyn_relocs; p != NULL; p = p->next)
7158     {
7159       asection *s = p->sec->output_section;
7160
7161       if (s != NULL && (s->flags & SEC_READONLY) != 0)
7162         return TRUE;
7163     }
7164   return FALSE;
7165 }
7166
7167 /* Return true if we have dynamic relocs against H or any of its weak
7168    aliases, that apply to read-only sections.  */
7169
7170 static bfd_boolean
7171 alias_readonly_dynrelocs (struct elf_link_hash_entry *h)
7172 {
7173   struct ppc_link_hash_entry *eh;
7174
7175   eh = (struct ppc_link_hash_entry *) h;
7176   do
7177     {
7178       if (readonly_dynrelocs (&eh->elf))
7179         return TRUE;
7180       eh = eh->weakref;
7181     } while (eh != NULL && &eh->elf != h);
7182
7183   return FALSE;
7184 }
7185
7186 /* Return whether EH has pc-relative dynamic relocs.  */
7187
7188 static bfd_boolean
7189 pc_dynrelocs (struct ppc_link_hash_entry *eh)
7190 {
7191   struct elf_dyn_relocs *p;
7192
7193   for (p = eh->dyn_relocs; p != NULL; p = p->next)
7194     if (p->pc_count != 0)
7195       return TRUE;
7196   return FALSE;
7197 }
7198
7199 /* Return true if a global entry stub will be created for H.  Valid
7200    for ELFv2 before plt entries have been allocated.  */
7201
7202 static bfd_boolean
7203 global_entry_stub (struct elf_link_hash_entry *h)
7204 {
7205   struct plt_entry *pent;
7206
7207   if (!h->pointer_equality_needed
7208       || h->def_regular)
7209     return FALSE;
7210
7211   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
7212     if (pent->plt.refcount > 0
7213         && pent->addend == 0)
7214       return TRUE;
7215
7216   return FALSE;
7217 }
7218
7219 /* Adjust a symbol defined by a dynamic object and referenced by a
7220    regular object.  The current definition is in some section of the
7221    dynamic object, but we're not including those sections.  We have to
7222    change the definition to something the rest of the link can
7223    understand.  */
7224
7225 static bfd_boolean
7226 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
7227                                  struct elf_link_hash_entry *h)
7228 {
7229   struct ppc_link_hash_table *htab;
7230   asection *s;
7231
7232   htab = ppc_hash_table (info);
7233   if (htab == NULL)
7234     return FALSE;
7235
7236   /* Deal with function syms.  */
7237   if (h->type == STT_FUNC
7238       || h->type == STT_GNU_IFUNC
7239       || h->needs_plt)
7240     {
7241       /* Clear procedure linkage table information for any symbol that
7242          won't need a .plt entry.  */
7243       struct plt_entry *ent;
7244       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
7245         if (ent->plt.refcount > 0)
7246           break;
7247       if (ent == NULL
7248           || (h->type != STT_GNU_IFUNC
7249               && (SYMBOL_CALLS_LOCAL (info, h)
7250                   || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
7251                       && h->root.type == bfd_link_hash_undefweak)))
7252           || ((struct ppc_link_hash_entry *) h)->save_res)
7253         {
7254           h->plt.plist = NULL;
7255           h->needs_plt = 0;
7256           h->pointer_equality_needed = 0;
7257         }
7258       else if (abiversion (info->output_bfd) >= 2)
7259         {
7260           /* Taking a function's address in a read/write section
7261              doesn't require us to define the function symbol in the
7262              executable on a global entry stub.  A dynamic reloc can
7263              be used instead.  The reason we prefer a few more dynamic
7264              relocs is that calling via a global entry stub costs a
7265              few more instructions, and pointer_equality_needed causes
7266              extra work in ld.so when resolving these symbols.  */
7267           if (global_entry_stub (h)
7268               && !alias_readonly_dynrelocs (h))
7269             {
7270               h->pointer_equality_needed = 0;
7271               /* After adjust_dynamic_symbol, non_got_ref set in
7272                  the non-pic case means that dyn_relocs for this
7273                  symbol should be discarded.  */
7274               h->non_got_ref = 0;
7275             }
7276
7277           /* If making a plt entry, then we don't need copy relocs.  */
7278           return TRUE;
7279         }
7280     }
7281   else
7282     h->plt.plist = NULL;
7283
7284   /* If this is a weak symbol, and there is a real definition, the
7285      processor independent code will have arranged for us to see the
7286      real definition first, and we can just use the same value.  */
7287   if (h->u.weakdef != NULL)
7288     {
7289       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
7290                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
7291       h->root.u.def.section = h->u.weakdef->root.u.def.section;
7292       h->root.u.def.value = h->u.weakdef->root.u.def.value;
7293       if (ELIMINATE_COPY_RELOCS)
7294         h->non_got_ref = h->u.weakdef->non_got_ref;
7295       return TRUE;
7296     }
7297
7298   /* If we are creating a shared library, we must presume that the
7299      only references to the symbol are via the global offset table.
7300      For such cases we need not do anything here; the relocations will
7301      be handled correctly by relocate_section.  */
7302   if (bfd_link_pic (info))
7303     return TRUE;
7304
7305   /* If there are no references to this symbol that do not use the
7306      GOT, we don't need to generate a copy reloc.  */
7307   if (!h->non_got_ref)
7308     return TRUE;
7309
7310   /* Don't generate a copy reloc for symbols defined in the executable.  */
7311   if (!h->def_dynamic || !h->ref_regular || h->def_regular
7312
7313       /* If -z nocopyreloc was given, don't generate them either.  */
7314       || info->nocopyreloc
7315
7316       /* If we didn't find any dynamic relocs in read-only sections, then
7317          we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
7318       || (ELIMINATE_COPY_RELOCS && !alias_readonly_dynrelocs (h))
7319
7320       /* Protected variables do not work with .dynbss.  The copy in
7321          .dynbss won't be used by the shared library with the protected
7322          definition for the variable.  Text relocations are preferable
7323          to an incorrect program.  */
7324       || h->protected_def)
7325     {
7326       h->non_got_ref = 0;
7327       return TRUE;
7328     }
7329
7330   if (h->plt.plist != NULL)
7331     {
7332       /* We should never get here, but unfortunately there are versions
7333          of gcc out there that improperly (for this ABI) put initialized
7334          function pointers, vtable refs and suchlike in read-only
7335          sections.  Allow them to proceed, but warn that this might
7336          break at runtime.  */
7337       info->callbacks->einfo
7338         (_("%P: copy reloc against `%T' requires lazy plt linking; "
7339            "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7340          h->root.root.string);
7341     }
7342
7343   /* This is a reference to a symbol defined by a dynamic object which
7344      is not a function.  */
7345
7346   /* We must allocate the symbol in our .dynbss section, which will
7347      become part of the .bss section of the executable.  There will be
7348      an entry for this symbol in the .dynsym section.  The dynamic
7349      object will contain position independent code, so all references
7350      from the dynamic object to this symbol will go through the global
7351      offset table.  The dynamic linker will use the .dynsym entry to
7352      determine the address it must put in the global offset table, so
7353      both the dynamic object and the regular object will refer to the
7354      same memory location for the variable.  */
7355
7356   /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
7357      to copy the initial value out of the dynamic object and into the
7358      runtime process image.  We need to remember the offset into the
7359      .rela.bss section we are going to use.  */
7360   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7361     {
7362       htab->relbss->size += sizeof (Elf64_External_Rela);
7363       h->needs_copy = 1;
7364     }
7365
7366   s = htab->dynbss;
7367
7368   return _bfd_elf_adjust_dynamic_copy (info, h, s);
7369 }
7370
7371 /* If given a function descriptor symbol, hide both the function code
7372    sym and the descriptor.  */
7373 static void
7374 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7375                        struct elf_link_hash_entry *h,
7376                        bfd_boolean force_local)
7377 {
7378   struct ppc_link_hash_entry *eh;
7379   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7380
7381   eh = (struct ppc_link_hash_entry *) h;
7382   if (eh->is_func_descriptor)
7383     {
7384       struct ppc_link_hash_entry *fh = eh->oh;
7385
7386       if (fh == NULL)
7387         {
7388           const char *p, *q;
7389           struct ppc_link_hash_table *htab;
7390           char save;
7391
7392           /* We aren't supposed to use alloca in BFD because on
7393              systems which do not have alloca the version in libiberty
7394              calls xmalloc, which might cause the program to crash
7395              when it runs out of memory.  This function doesn't have a
7396              return status, so there's no way to gracefully return an
7397              error.  So cheat.  We know that string[-1] can be safely
7398              accessed;  It's either a string in an ELF string table,
7399              or allocated in an objalloc structure.  */
7400
7401           p = eh->elf.root.root.string - 1;
7402           save = *p;
7403           *(char *) p = '.';
7404           htab = ppc_hash_table (info);
7405           if (htab == NULL)
7406             return;
7407
7408           fh = (struct ppc_link_hash_entry *)
7409             elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7410           *(char *) p = save;
7411
7412           /* Unfortunately, if it so happens that the string we were
7413              looking for was allocated immediately before this string,
7414              then we overwrote the string terminator.  That's the only
7415              reason the lookup should fail.  */
7416           if (fh == NULL)
7417             {
7418               q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7419               while (q >= eh->elf.root.root.string && *q == *p)
7420                 --q, --p;
7421               if (q < eh->elf.root.root.string && *p == '.')
7422                 fh = (struct ppc_link_hash_entry *)
7423                   elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7424             }
7425           if (fh != NULL)
7426             {
7427               eh->oh = fh;
7428               fh->oh = eh;
7429             }
7430         }
7431       if (fh != NULL)
7432         _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7433     }
7434 }
7435
7436 static bfd_boolean
7437 get_sym_h (struct elf_link_hash_entry **hp,
7438            Elf_Internal_Sym **symp,
7439            asection **symsecp,
7440            unsigned char **tls_maskp,
7441            Elf_Internal_Sym **locsymsp,
7442            unsigned long r_symndx,
7443            bfd *ibfd)
7444 {
7445   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7446
7447   if (r_symndx >= symtab_hdr->sh_info)
7448     {
7449       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7450       struct elf_link_hash_entry *h;
7451
7452       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7453       h = elf_follow_link (h);
7454
7455       if (hp != NULL)
7456         *hp = h;
7457
7458       if (symp != NULL)
7459         *symp = NULL;
7460
7461       if (symsecp != NULL)
7462         {
7463           asection *symsec = NULL;
7464           if (h->root.type == bfd_link_hash_defined
7465               || h->root.type == bfd_link_hash_defweak)
7466             symsec = h->root.u.def.section;
7467           *symsecp = symsec;
7468         }
7469
7470       if (tls_maskp != NULL)
7471         {
7472           struct ppc_link_hash_entry *eh;
7473
7474           eh = (struct ppc_link_hash_entry *) h;
7475           *tls_maskp = &eh->tls_mask;
7476         }
7477     }
7478   else
7479     {
7480       Elf_Internal_Sym *sym;
7481       Elf_Internal_Sym *locsyms = *locsymsp;
7482
7483       if (locsyms == NULL)
7484         {
7485           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7486           if (locsyms == NULL)
7487             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7488                                             symtab_hdr->sh_info,
7489                                             0, NULL, NULL, NULL);
7490           if (locsyms == NULL)
7491             return FALSE;
7492           *locsymsp = locsyms;
7493         }
7494       sym = locsyms + r_symndx;
7495
7496       if (hp != NULL)
7497         *hp = NULL;
7498
7499       if (symp != NULL)
7500         *symp = sym;
7501
7502       if (symsecp != NULL)
7503         *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7504
7505       if (tls_maskp != NULL)
7506         {
7507           struct got_entry **lgot_ents;
7508           unsigned char *tls_mask;
7509
7510           tls_mask = NULL;
7511           lgot_ents = elf_local_got_ents (ibfd);
7512           if (lgot_ents != NULL)
7513             {
7514               struct plt_entry **local_plt = (struct plt_entry **)
7515                 (lgot_ents + symtab_hdr->sh_info);
7516               unsigned char *lgot_masks = (unsigned char *)
7517                 (local_plt + symtab_hdr->sh_info);
7518               tls_mask = &lgot_masks[r_symndx];
7519             }
7520           *tls_maskp = tls_mask;
7521         }
7522     }
7523   return TRUE;
7524 }
7525
7526 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
7527    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7528    type suitable for optimization, and 1 otherwise.  */
7529
7530 static int
7531 get_tls_mask (unsigned char **tls_maskp,
7532               unsigned long *toc_symndx,
7533               bfd_vma *toc_addend,
7534               Elf_Internal_Sym **locsymsp,
7535               const Elf_Internal_Rela *rel,
7536               bfd *ibfd)
7537 {
7538   unsigned long r_symndx;
7539   int next_r;
7540   struct elf_link_hash_entry *h;
7541   Elf_Internal_Sym *sym;
7542   asection *sec;
7543   bfd_vma off;
7544
7545   r_symndx = ELF64_R_SYM (rel->r_info);
7546   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7547     return 0;
7548
7549   if ((*tls_maskp != NULL && **tls_maskp != 0)
7550       || sec == NULL
7551       || ppc64_elf_section_data (sec) == NULL
7552       || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7553     return 1;
7554
7555   /* Look inside a TOC section too.  */
7556   if (h != NULL)
7557     {
7558       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7559       off = h->root.u.def.value;
7560     }
7561   else
7562     off = sym->st_value;
7563   off += rel->r_addend;
7564   BFD_ASSERT (off % 8 == 0);
7565   r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7566   next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7567   if (toc_symndx != NULL)
7568     *toc_symndx = r_symndx;
7569   if (toc_addend != NULL)
7570     *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7571   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7572     return 0;
7573   if ((h == NULL || is_static_defined (h))
7574       && (next_r == -1 || next_r == -2))
7575     return 1 - next_r;
7576   return 1;
7577 }
7578
7579 /* Find (or create) an entry in the tocsave hash table.  */
7580
7581 static struct tocsave_entry *
7582 tocsave_find (struct ppc_link_hash_table *htab,
7583               enum insert_option insert,
7584               Elf_Internal_Sym **local_syms,
7585               const Elf_Internal_Rela *irela,
7586               bfd *ibfd)
7587 {
7588   unsigned long r_indx;
7589   struct elf_link_hash_entry *h;
7590   Elf_Internal_Sym *sym;
7591   struct tocsave_entry ent, *p;
7592   hashval_t hash;
7593   struct tocsave_entry **slot;
7594
7595   r_indx = ELF64_R_SYM (irela->r_info);
7596   if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7597     return NULL;
7598   if (ent.sec == NULL || ent.sec->output_section == NULL)
7599     {
7600       (*_bfd_error_handler)
7601         (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"));
7602       return NULL;
7603     }
7604
7605   if (h != NULL)
7606     ent.offset = h->root.u.def.value;
7607   else
7608     ent.offset = sym->st_value;
7609   ent.offset += irela->r_addend;
7610
7611   hash = tocsave_htab_hash (&ent);
7612   slot = ((struct tocsave_entry **)
7613           htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7614   if (slot == NULL)
7615     return NULL;
7616
7617   if (*slot == NULL)
7618     {
7619       p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7620       if (p == NULL)
7621         return NULL;
7622       *p = ent;
7623       *slot = p;
7624     }
7625   return *slot;
7626 }
7627
7628 /* Adjust all global syms defined in opd sections.  In gcc generated
7629    code for the old ABI, these will already have been done.  */
7630
7631 static bfd_boolean
7632 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7633 {
7634   struct ppc_link_hash_entry *eh;
7635   asection *sym_sec;
7636   struct _opd_sec_data *opd;
7637
7638   if (h->root.type == bfd_link_hash_indirect)
7639     return TRUE;
7640
7641   if (h->root.type != bfd_link_hash_defined
7642       && h->root.type != bfd_link_hash_defweak)
7643     return TRUE;
7644
7645   eh = (struct ppc_link_hash_entry *) h;
7646   if (eh->adjust_done)
7647     return TRUE;
7648
7649   sym_sec = eh->elf.root.u.def.section;
7650   opd = get_opd_info (sym_sec);
7651   if (opd != NULL && opd->adjust != NULL)
7652     {
7653       long adjust = opd->adjust[OPD_NDX (eh->elf.root.u.def.value)];
7654       if (adjust == -1)
7655         {
7656           /* This entry has been deleted.  */
7657           asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7658           if (dsec == NULL)
7659             {
7660               for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7661                 if (discarded_section (dsec))
7662                   {
7663                     ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7664                     break;
7665                   }
7666             }
7667           eh->elf.root.u.def.value = 0;
7668           eh->elf.root.u.def.section = dsec;
7669         }
7670       else
7671         eh->elf.root.u.def.value += adjust;
7672       eh->adjust_done = 1;
7673     }
7674   return TRUE;
7675 }
7676
7677 /* Handles decrementing dynamic reloc counts for the reloc specified by
7678    R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM
7679    have already been determined.  */
7680
7681 static bfd_boolean
7682 dec_dynrel_count (bfd_vma r_info,
7683                   asection *sec,
7684                   struct bfd_link_info *info,
7685                   Elf_Internal_Sym **local_syms,
7686                   struct elf_link_hash_entry *h,
7687                   Elf_Internal_Sym *sym)
7688 {
7689   enum elf_ppc64_reloc_type r_type;
7690   asection *sym_sec = NULL;
7691
7692   /* Can this reloc be dynamic?  This switch, and later tests here
7693      should be kept in sync with the code in check_relocs.  */
7694   r_type = ELF64_R_TYPE (r_info);
7695   switch (r_type)
7696     {
7697     default:
7698       return TRUE;
7699
7700     case R_PPC64_TPREL16:
7701     case R_PPC64_TPREL16_LO:
7702     case R_PPC64_TPREL16_HI:
7703     case R_PPC64_TPREL16_HA:
7704     case R_PPC64_TPREL16_DS:
7705     case R_PPC64_TPREL16_LO_DS:
7706     case R_PPC64_TPREL16_HIGH:
7707     case R_PPC64_TPREL16_HIGHA:
7708     case R_PPC64_TPREL16_HIGHER:
7709     case R_PPC64_TPREL16_HIGHERA:
7710     case R_PPC64_TPREL16_HIGHEST:
7711     case R_PPC64_TPREL16_HIGHESTA:
7712       if (!bfd_link_pic (info))
7713         return TRUE;
7714
7715     case R_PPC64_TPREL64:
7716     case R_PPC64_DTPMOD64:
7717     case R_PPC64_DTPREL64:
7718     case R_PPC64_ADDR64:
7719     case R_PPC64_REL30:
7720     case R_PPC64_REL32:
7721     case R_PPC64_REL64:
7722     case R_PPC64_ADDR14:
7723     case R_PPC64_ADDR14_BRNTAKEN:
7724     case R_PPC64_ADDR14_BRTAKEN:
7725     case R_PPC64_ADDR16:
7726     case R_PPC64_ADDR16_DS:
7727     case R_PPC64_ADDR16_HA:
7728     case R_PPC64_ADDR16_HI:
7729     case R_PPC64_ADDR16_HIGH:
7730     case R_PPC64_ADDR16_HIGHA:
7731     case R_PPC64_ADDR16_HIGHER:
7732     case R_PPC64_ADDR16_HIGHERA:
7733     case R_PPC64_ADDR16_HIGHEST:
7734     case R_PPC64_ADDR16_HIGHESTA:
7735     case R_PPC64_ADDR16_LO:
7736     case R_PPC64_ADDR16_LO_DS:
7737     case R_PPC64_ADDR24:
7738     case R_PPC64_ADDR32:
7739     case R_PPC64_UADDR16:
7740     case R_PPC64_UADDR32:
7741     case R_PPC64_UADDR64:
7742     case R_PPC64_TOC:
7743       break;
7744     }
7745
7746   if (local_syms != NULL)
7747     {
7748       unsigned long r_symndx;
7749       bfd *ibfd = sec->owner;
7750
7751       r_symndx = ELF64_R_SYM (r_info);
7752       if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7753         return FALSE;
7754     }
7755
7756   if ((bfd_link_pic (info)
7757        && (must_be_dyn_reloc (info, r_type)
7758            || (h != NULL
7759                && (!SYMBOLIC_BIND (info, h)
7760                    || h->root.type == bfd_link_hash_defweak
7761                    || !h->def_regular))))
7762       || (ELIMINATE_COPY_RELOCS
7763           && !bfd_link_pic (info)
7764           && h != NULL
7765           && (h->root.type == bfd_link_hash_defweak
7766               || !h->def_regular)))
7767     ;
7768   else
7769     return TRUE;
7770
7771   if (h != NULL)
7772     {
7773       struct elf_dyn_relocs *p;
7774       struct elf_dyn_relocs **pp;
7775       pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7776
7777       /* elf_gc_sweep may have already removed all dyn relocs associated
7778          with local syms for a given section.  Also, symbol flags are
7779          changed by elf_gc_sweep_symbol, confusing the test above.  Don't
7780          report a dynreloc miscount.  */
7781       if (*pp == NULL && info->gc_sections)
7782         return TRUE;
7783
7784       while ((p = *pp) != NULL)
7785         {
7786           if (p->sec == sec)
7787             {
7788               if (!must_be_dyn_reloc (info, r_type))
7789                 p->pc_count -= 1;
7790               p->count -= 1;
7791               if (p->count == 0)
7792                 *pp = p->next;
7793               return TRUE;
7794             }
7795           pp = &p->next;
7796         }
7797     }
7798   else
7799     {
7800       struct ppc_dyn_relocs *p;
7801       struct ppc_dyn_relocs **pp;
7802       void *vpp;
7803       bfd_boolean is_ifunc;
7804
7805       if (local_syms == NULL)
7806         sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7807       if (sym_sec == NULL)
7808         sym_sec = sec;
7809
7810       vpp = &elf_section_data (sym_sec)->local_dynrel;
7811       pp = (struct ppc_dyn_relocs **) vpp;
7812
7813       if (*pp == NULL && info->gc_sections)
7814         return TRUE;
7815
7816       is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7817       while ((p = *pp) != NULL)
7818         {
7819           if (p->sec == sec && p->ifunc == is_ifunc)
7820             {
7821               p->count -= 1;
7822               if (p->count == 0)
7823                 *pp = p->next;
7824               return TRUE;
7825             }
7826           pp = &p->next;
7827         }
7828     }
7829
7830   info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7831                           sec->owner, sec);
7832   bfd_set_error (bfd_error_bad_value);
7833   return FALSE;
7834 }
7835
7836 /* Remove unused Official Procedure Descriptor entries.  Currently we
7837    only remove those associated with functions in discarded link-once
7838    sections, or weakly defined functions that have been overridden.  It
7839    would be possible to remove many more entries for statically linked
7840    applications.  */
7841
7842 bfd_boolean
7843 ppc64_elf_edit_opd (struct bfd_link_info *info)
7844 {
7845   bfd *ibfd;
7846   bfd_boolean some_edited = FALSE;
7847   asection *need_pad = NULL;
7848   struct ppc_link_hash_table *htab;
7849
7850   htab = ppc_hash_table (info);
7851   if (htab == NULL)
7852     return FALSE;
7853
7854   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
7855     {
7856       asection *sec;
7857       Elf_Internal_Rela *relstart, *rel, *relend;
7858       Elf_Internal_Shdr *symtab_hdr;
7859       Elf_Internal_Sym *local_syms;
7860       struct _opd_sec_data *opd;
7861       bfd_boolean need_edit, add_aux_fields, broken;
7862       bfd_size_type cnt_16b = 0;
7863
7864       if (!is_ppc64_elf (ibfd))
7865         continue;
7866
7867       sec = bfd_get_section_by_name (ibfd, ".opd");
7868       if (sec == NULL || sec->size == 0)
7869         continue;
7870
7871       if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7872         continue;
7873
7874       if (sec->output_section == bfd_abs_section_ptr)
7875         continue;
7876
7877       /* Look through the section relocs.  */
7878       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7879         continue;
7880
7881       local_syms = NULL;
7882       symtab_hdr = &elf_symtab_hdr (ibfd);
7883
7884       /* Read the relocations.  */
7885       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7886                                             info->keep_memory);
7887       if (relstart == NULL)
7888         return FALSE;
7889
7890       /* First run through the relocs to check they are sane, and to
7891          determine whether we need to edit this opd section.  */
7892       need_edit = FALSE;
7893       broken = FALSE;
7894       need_pad = sec;
7895       relend = relstart + sec->reloc_count;
7896       for (rel = relstart; rel < relend; )
7897         {
7898           enum elf_ppc64_reloc_type r_type;
7899           unsigned long r_symndx;
7900           asection *sym_sec;
7901           struct elf_link_hash_entry *h;
7902           Elf_Internal_Sym *sym;
7903           bfd_vma offset;
7904
7905           /* .opd contains an array of 16 or 24 byte entries.  We're
7906              only interested in the reloc pointing to a function entry
7907              point.  */
7908           offset = rel->r_offset;
7909           if (rel + 1 == relend
7910               || rel[1].r_offset != offset + 8)
7911             {
7912               /* If someone messes with .opd alignment then after a
7913                  "ld -r" we might have padding in the middle of .opd.
7914                  Also, there's nothing to prevent someone putting
7915                  something silly in .opd with the assembler.  No .opd
7916                  optimization for them!  */
7917             broken_opd:
7918               (*_bfd_error_handler)
7919                 (_("%B: .opd is not a regular array of opd entries"), ibfd);
7920               broken = TRUE;
7921               break;
7922             }
7923
7924           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7925               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7926             {
7927               (*_bfd_error_handler)
7928                 (_("%B: unexpected reloc type %u in .opd section"),
7929                  ibfd, r_type);
7930               broken = TRUE;
7931               break;
7932             }
7933
7934           r_symndx = ELF64_R_SYM (rel->r_info);
7935           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7936                           r_symndx, ibfd))
7937             goto error_ret;
7938
7939           if (sym_sec == NULL || sym_sec->owner == NULL)
7940             {
7941               const char *sym_name;
7942               if (h != NULL)
7943                 sym_name = h->root.root.string;
7944               else
7945                 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7946                                              sym_sec);
7947
7948               (*_bfd_error_handler)
7949                 (_("%B: undefined sym `%s' in .opd section"),
7950                  ibfd, sym_name);
7951               broken = TRUE;
7952               break;
7953             }
7954
7955           /* opd entries are always for functions defined in the
7956              current input bfd.  If the symbol isn't defined in the
7957              input bfd, then we won't be using the function in this
7958              bfd;  It must be defined in a linkonce section in another
7959              bfd, or is weak.  It's also possible that we are
7960              discarding the function due to a linker script /DISCARD/,
7961              which we test for via the output_section.  */
7962           if (sym_sec->owner != ibfd
7963               || sym_sec->output_section == bfd_abs_section_ptr)
7964             need_edit = TRUE;
7965
7966           rel += 2;
7967           if (rel + 1 == relend
7968               || (rel + 2 < relend
7969                   && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC))
7970             ++rel;
7971
7972           if (rel == relend)
7973             {
7974               if (sec->size == offset + 24)
7975                 {
7976                   need_pad = NULL;
7977                   break;
7978                 }
7979               if (sec->size == offset + 16)
7980                 {
7981                   cnt_16b++;
7982                   break;
7983                 }
7984               goto broken_opd;
7985             }
7986           else if (rel + 1 < relend
7987                    && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7988                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7989             {
7990               if (rel[0].r_offset == offset + 16)
7991                 cnt_16b++;
7992               else if (rel[0].r_offset != offset + 24)
7993                 goto broken_opd;
7994             }
7995           else
7996             goto broken_opd;
7997         }
7998
7999       add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
8000
8001       if (!broken && (need_edit || add_aux_fields))
8002         {
8003           Elf_Internal_Rela *write_rel;
8004           Elf_Internal_Shdr *rel_hdr;
8005           bfd_byte *rptr, *wptr;
8006           bfd_byte *new_contents;
8007           bfd_size_type amt;
8008
8009           new_contents = NULL;
8010           amt = OPD_NDX (sec->size) * sizeof (long);
8011           opd = &ppc64_elf_section_data (sec)->u.opd;
8012           opd->adjust = bfd_zalloc (sec->owner, amt);
8013           if (opd->adjust == NULL)
8014             return FALSE;
8015           ppc64_elf_section_data (sec)->sec_type = sec_opd;
8016
8017           /* This seems a waste of time as input .opd sections are all
8018              zeros as generated by gcc, but I suppose there's no reason
8019              this will always be so.  We might start putting something in
8020              the third word of .opd entries.  */
8021           if ((sec->flags & SEC_IN_MEMORY) == 0)
8022             {
8023               bfd_byte *loc;
8024               if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
8025                 {
8026                   if (loc != NULL)
8027                     free (loc);
8028                 error_ret:
8029                   if (local_syms != NULL
8030                       && symtab_hdr->contents != (unsigned char *) local_syms)
8031                     free (local_syms);
8032                   if (elf_section_data (sec)->relocs != relstart)
8033                     free (relstart);
8034                   return FALSE;
8035                 }
8036               sec->contents = loc;
8037               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8038             }
8039
8040           elf_section_data (sec)->relocs = relstart;
8041
8042           new_contents = sec->contents;
8043           if (add_aux_fields)
8044             {
8045               new_contents = bfd_malloc (sec->size + cnt_16b * 8);
8046               if (new_contents == NULL)
8047                 return FALSE;
8048               need_pad = NULL;
8049             }
8050           wptr = new_contents;
8051           rptr = sec->contents;
8052           write_rel = relstart;
8053           for (rel = relstart; rel < relend; )
8054             {
8055               unsigned long r_symndx;
8056               asection *sym_sec;
8057               struct elf_link_hash_entry *h;
8058               struct ppc_link_hash_entry *fdh = NULL;
8059               Elf_Internal_Sym *sym;
8060               long opd_ent_size;
8061               Elf_Internal_Rela *next_rel;
8062               bfd_boolean skip;
8063
8064               r_symndx = ELF64_R_SYM (rel->r_info);
8065               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8066                               r_symndx, ibfd))
8067                 goto error_ret;
8068
8069               next_rel = rel + 2;
8070               if (next_rel + 1 == relend
8071                   || (next_rel + 2 < relend
8072                       && ELF64_R_TYPE (next_rel[2].r_info) == R_PPC64_TOC))
8073                 ++next_rel;
8074
8075               /* See if the .opd entry is full 24 byte or
8076                  16 byte (with fd_aux entry overlapped with next
8077                  fd_func).  */
8078               opd_ent_size = 24;
8079               if (next_rel == relend)
8080                 {
8081                   if (sec->size == rel->r_offset + 16)
8082                     opd_ent_size = 16;
8083                 }
8084               else if (next_rel->r_offset == rel->r_offset + 16)
8085                 opd_ent_size = 16;
8086
8087               if (h != NULL
8088                   && h->root.root.string[0] == '.')
8089                 {
8090                   fdh = lookup_fdh ((struct ppc_link_hash_entry *) h, htab);
8091                   if (fdh != NULL
8092                       && fdh->elf.root.type != bfd_link_hash_defined
8093                       && fdh->elf.root.type != bfd_link_hash_defweak)
8094                     fdh = NULL;
8095                 }
8096
8097               skip = (sym_sec->owner != ibfd
8098                       || sym_sec->output_section == bfd_abs_section_ptr);
8099               if (skip)
8100                 {
8101                   if (fdh != NULL && sym_sec->owner == ibfd)
8102                     {
8103                       /* Arrange for the function descriptor sym
8104                          to be dropped.  */
8105                       fdh->elf.root.u.def.value = 0;
8106                       fdh->elf.root.u.def.section = sym_sec;
8107                     }
8108                   opd->adjust[OPD_NDX (rel->r_offset)] = -1;
8109
8110                   if (NO_OPD_RELOCS || bfd_link_relocatable (info))
8111                     rel = next_rel;
8112                   else
8113                     while (1)
8114                       {
8115                         if (!dec_dynrel_count (rel->r_info, sec, info,
8116                                                NULL, h, sym))
8117                           goto error_ret;
8118
8119                         if (++rel == next_rel)
8120                           break;
8121
8122                         r_symndx = ELF64_R_SYM (rel->r_info);
8123                         if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8124                                         r_symndx, ibfd))
8125                           goto error_ret;
8126                       }
8127                 }
8128               else
8129                 {
8130                   /* We'll be keeping this opd entry.  */
8131                   long adjust;
8132
8133                   if (fdh != NULL)
8134                     {
8135                       /* Redefine the function descriptor symbol to
8136                          this location in the opd section.  It is
8137                          necessary to update the value here rather
8138                          than using an array of adjustments as we do
8139                          for local symbols, because various places
8140                          in the generic ELF code use the value
8141                          stored in u.def.value.  */
8142                       fdh->elf.root.u.def.value = wptr - new_contents;
8143                       fdh->adjust_done = 1;
8144                     }
8145
8146                   /* Local syms are a bit tricky.  We could
8147                      tweak them as they can be cached, but
8148                      we'd need to look through the local syms
8149                      for the function descriptor sym which we
8150                      don't have at the moment.  So keep an
8151                      array of adjustments.  */
8152                   adjust = (wptr - new_contents) - (rptr - sec->contents);
8153                   opd->adjust[OPD_NDX (rel->r_offset)] = adjust;
8154
8155                   if (wptr != rptr)
8156                     memcpy (wptr, rptr, opd_ent_size);
8157                   wptr += opd_ent_size;
8158                   if (add_aux_fields && opd_ent_size == 16)
8159                     {
8160                       memset (wptr, '\0', 8);
8161                       wptr += 8;
8162                     }
8163
8164                   /* We need to adjust any reloc offsets to point to the
8165                      new opd entries.  */
8166                   for ( ; rel != next_rel; ++rel)
8167                     {
8168                       rel->r_offset += adjust;
8169                       if (write_rel != rel)
8170                         memcpy (write_rel, rel, sizeof (*rel));
8171                       ++write_rel;
8172                     }
8173                 }
8174
8175               rptr += opd_ent_size;
8176             }
8177
8178           sec->size = wptr - new_contents;
8179           sec->reloc_count = write_rel - relstart;
8180           if (add_aux_fields)
8181             {
8182               free (sec->contents);
8183               sec->contents = new_contents;
8184             }
8185
8186           /* Fudge the header size too, as this is used later in
8187              elf_bfd_final_link if we are emitting relocs.  */
8188           rel_hdr = _bfd_elf_single_rel_hdr (sec);
8189           rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
8190           some_edited = TRUE;
8191         }
8192       else if (elf_section_data (sec)->relocs != relstart)
8193         free (relstart);
8194
8195       if (local_syms != NULL
8196           && symtab_hdr->contents != (unsigned char *) local_syms)
8197         {
8198           if (!info->keep_memory)
8199             free (local_syms);
8200           else
8201             symtab_hdr->contents = (unsigned char *) local_syms;
8202         }
8203     }
8204
8205   if (some_edited)
8206     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
8207
8208   /* If we are doing a final link and the last .opd entry is just 16 byte
8209      long, add a 8 byte padding after it.  */
8210   if (need_pad != NULL && !bfd_link_relocatable (info))
8211     {
8212       bfd_byte *p;
8213
8214       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
8215         {
8216           BFD_ASSERT (need_pad->size > 0);
8217
8218           p = bfd_malloc (need_pad->size + 8);
8219           if (p == NULL)
8220             return FALSE;
8221
8222           if (! bfd_get_section_contents (need_pad->owner, need_pad,
8223                                           p, 0, need_pad->size))
8224             return FALSE;
8225
8226           need_pad->contents = p;
8227           need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8228         }
8229       else
8230         {
8231           p = bfd_realloc (need_pad->contents, need_pad->size + 8);
8232           if (p == NULL)
8233             return FALSE;
8234
8235           need_pad->contents = p;
8236         }
8237
8238       memset (need_pad->contents + need_pad->size, 0, 8);
8239       need_pad->size += 8;
8240     }
8241
8242   return TRUE;
8243 }
8244
8245 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
8246
8247 asection *
8248 ppc64_elf_tls_setup (struct bfd_link_info *info)
8249 {
8250   struct ppc_link_hash_table *htab;
8251
8252   htab = ppc_hash_table (info);
8253   if (htab == NULL)
8254     return NULL;
8255
8256   if (abiversion (info->output_bfd) == 1)
8257     htab->opd_abi = 1;
8258
8259   if (htab->params->no_multi_toc)
8260     htab->do_multi_toc = 0;
8261   else if (!htab->do_multi_toc)
8262     htab->params->no_multi_toc = 1;
8263
8264   htab->tls_get_addr = ((struct ppc_link_hash_entry *)
8265                         elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
8266                                               FALSE, FALSE, TRUE));
8267   /* Move dynamic linking info to the function descriptor sym.  */
8268   if (htab->tls_get_addr != NULL)
8269     func_desc_adjust (&htab->tls_get_addr->elf, info);
8270   htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
8271                            elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
8272                                                  FALSE, FALSE, TRUE));
8273   if (htab->params->tls_get_addr_opt)
8274     {
8275       struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
8276
8277       opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
8278                                   FALSE, FALSE, TRUE);
8279       if (opt != NULL)
8280         func_desc_adjust (opt, info);
8281       opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
8282                                      FALSE, FALSE, TRUE);
8283       if (opt_fd != NULL
8284           && (opt_fd->root.type == bfd_link_hash_defined
8285               || opt_fd->root.type == bfd_link_hash_defweak))
8286         {
8287           /* If glibc supports an optimized __tls_get_addr call stub,
8288              signalled by the presence of __tls_get_addr_opt, and we'll
8289              be calling __tls_get_addr via a plt call stub, then
8290              make __tls_get_addr point to __tls_get_addr_opt.  */
8291           tga_fd = &htab->tls_get_addr_fd->elf;
8292           if (htab->elf.dynamic_sections_created
8293               && tga_fd != NULL
8294               && (tga_fd->type == STT_FUNC
8295                   || tga_fd->needs_plt)
8296               && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
8297                    || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
8298                        && tga_fd->root.type == bfd_link_hash_undefweak)))
8299             {
8300               struct plt_entry *ent;
8301
8302               for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
8303                 if (ent->plt.refcount > 0)
8304                   break;
8305               if (ent != NULL)
8306                 {
8307                   tga_fd->root.type = bfd_link_hash_indirect;
8308                   tga_fd->root.u.i.link = &opt_fd->root;
8309                   ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
8310                   opt_fd->forced_local = 0;
8311                   if (opt_fd->dynindx != -1)
8312                     {
8313                       /* Use __tls_get_addr_opt in dynamic relocations.  */
8314                       opt_fd->dynindx = -1;
8315                       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8316                                               opt_fd->dynstr_index);
8317                       if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8318                         return NULL;
8319                     }
8320                   htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8321                   tga = &htab->tls_get_addr->elf;
8322                   if (opt != NULL && tga != NULL)
8323                     {
8324                       tga->root.type = bfd_link_hash_indirect;
8325                       tga->root.u.i.link = &opt->root;
8326                       ppc64_elf_copy_indirect_symbol (info, opt, tga);
8327                       opt->forced_local = 0;
8328                       _bfd_elf_link_hash_hide_symbol (info, opt,
8329                                                       tga->forced_local);
8330                       htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8331                     }
8332                   htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8333                   htab->tls_get_addr_fd->is_func_descriptor = 1;
8334                   if (htab->tls_get_addr != NULL)
8335                     {
8336                       htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8337                       htab->tls_get_addr->is_func = 1;
8338                     }
8339                 }
8340             }
8341         }
8342       else if (htab->params->tls_get_addr_opt < 0)
8343         htab->params->tls_get_addr_opt = 0;
8344     }
8345   return _bfd_elf_tls_setup (info->output_bfd, info);
8346 }
8347
8348 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8349    HASH1 or HASH2.  */
8350
8351 static bfd_boolean
8352 branch_reloc_hash_match (const bfd *ibfd,
8353                          const Elf_Internal_Rela *rel,
8354                          const struct ppc_link_hash_entry *hash1,
8355                          const struct ppc_link_hash_entry *hash2)
8356 {
8357   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8358   enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8359   unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8360
8361   if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8362     {
8363       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8364       struct elf_link_hash_entry *h;
8365
8366       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8367       h = elf_follow_link (h);
8368       if (h == &hash1->elf || h == &hash2->elf)
8369         return TRUE;
8370     }
8371   return FALSE;
8372 }
8373
8374 /* Run through all the TLS relocs looking for optimization
8375    opportunities.  The linker has been hacked (see ppc64elf.em) to do
8376    a preliminary section layout so that we know the TLS segment
8377    offsets.  We can't optimize earlier because some optimizations need
8378    to know the tp offset, and we need to optimize before allocating
8379    dynamic relocations.  */
8380
8381 bfd_boolean
8382 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8383 {
8384   bfd *ibfd;
8385   asection *sec;
8386   struct ppc_link_hash_table *htab;
8387   unsigned char *toc_ref;
8388   int pass;
8389
8390   if (!bfd_link_executable (info))
8391     return TRUE;
8392
8393   htab = ppc_hash_table (info);
8394   if (htab == NULL)
8395     return FALSE;
8396
8397   /* Make two passes over the relocs.  On the first pass, mark toc
8398      entries involved with tls relocs, and check that tls relocs
8399      involved in setting up a tls_get_addr call are indeed followed by
8400      such a call.  If they are not, we can't do any tls optimization.
8401      On the second pass twiddle tls_mask flags to notify
8402      relocate_section that optimization can be done, and adjust got
8403      and plt refcounts.  */
8404   toc_ref = NULL;
8405   for (pass = 0; pass < 2; ++pass)
8406     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8407       {
8408         Elf_Internal_Sym *locsyms = NULL;
8409         asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8410
8411         for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8412           if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8413             {
8414               Elf_Internal_Rela *relstart, *rel, *relend;
8415               bfd_boolean found_tls_get_addr_arg = 0;
8416
8417               /* Read the relocations.  */
8418               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8419                                                     info->keep_memory);
8420               if (relstart == NULL)
8421                 {
8422                   free (toc_ref);
8423                   return FALSE;
8424                 }
8425
8426               relend = relstart + sec->reloc_count;
8427               for (rel = relstart; rel < relend; rel++)
8428                 {
8429                   enum elf_ppc64_reloc_type r_type;
8430                   unsigned long r_symndx;
8431                   struct elf_link_hash_entry *h;
8432                   Elf_Internal_Sym *sym;
8433                   asection *sym_sec;
8434                   unsigned char *tls_mask;
8435                   unsigned char tls_set, tls_clear, tls_type = 0;
8436                   bfd_vma value;
8437                   bfd_boolean ok_tprel, is_local;
8438                   long toc_ref_index = 0;
8439                   int expecting_tls_get_addr = 0;
8440                   bfd_boolean ret = FALSE;
8441
8442                   r_symndx = ELF64_R_SYM (rel->r_info);
8443                   if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8444                                   r_symndx, ibfd))
8445                     {
8446                     err_free_rel:
8447                       if (elf_section_data (sec)->relocs != relstart)
8448                         free (relstart);
8449                       if (toc_ref != NULL)
8450                         free (toc_ref);
8451                       if (locsyms != NULL
8452                           && (elf_symtab_hdr (ibfd).contents
8453                               != (unsigned char *) locsyms))
8454                         free (locsyms);
8455                       return ret;
8456                     }
8457
8458                   if (h != NULL)
8459                     {
8460                       if (h->root.type == bfd_link_hash_defined
8461                           || h->root.type == bfd_link_hash_defweak)
8462                         value = h->root.u.def.value;
8463                       else if (h->root.type == bfd_link_hash_undefweak)
8464                         value = 0;
8465                       else
8466                         {
8467                           found_tls_get_addr_arg = 0;
8468                           continue;
8469                         }
8470                     }
8471                   else
8472                     /* Symbols referenced by TLS relocs must be of type
8473                        STT_TLS.  So no need for .opd local sym adjust.  */
8474                     value = sym->st_value;
8475
8476                   ok_tprel = FALSE;
8477                   is_local = FALSE;
8478                   if (h == NULL
8479                       || !h->def_dynamic)
8480                     {
8481                       is_local = TRUE;
8482                       if (h != NULL
8483                           && h->root.type == bfd_link_hash_undefweak)
8484                         ok_tprel = TRUE;
8485                       else if (sym_sec != NULL
8486                                && sym_sec->output_section != NULL)
8487                         {
8488                           value += sym_sec->output_offset;
8489                           value += sym_sec->output_section->vma;
8490                           value -= htab->elf.tls_sec->vma;
8491                           ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8492                                       < (bfd_vma) 1 << 32);
8493                         }
8494                     }
8495
8496                   r_type = ELF64_R_TYPE (rel->r_info);
8497                   /* If this section has old-style __tls_get_addr calls
8498                      without marker relocs, then check that each
8499                      __tls_get_addr call reloc is preceded by a reloc
8500                      that conceivably belongs to the __tls_get_addr arg
8501                      setup insn.  If we don't find matching arg setup
8502                      relocs, don't do any tls optimization.  */
8503                   if (pass == 0
8504                       && sec->has_tls_get_addr_call
8505                       && h != NULL
8506                       && (h == &htab->tls_get_addr->elf
8507                           || h == &htab->tls_get_addr_fd->elf)
8508                       && !found_tls_get_addr_arg
8509                       && is_branch_reloc (r_type))
8510                     {
8511                       info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8512                                                 "TLS optimization disabled\n"),
8513                                               ibfd, sec, rel->r_offset);
8514                       ret = TRUE;
8515                       goto err_free_rel;
8516                     }
8517
8518                   found_tls_get_addr_arg = 0;
8519                   switch (r_type)
8520                     {
8521                     case R_PPC64_GOT_TLSLD16:
8522                     case R_PPC64_GOT_TLSLD16_LO:
8523                       expecting_tls_get_addr = 1;
8524                       found_tls_get_addr_arg = 1;
8525                       /* Fall thru */
8526
8527                     case R_PPC64_GOT_TLSLD16_HI:
8528                     case R_PPC64_GOT_TLSLD16_HA:
8529                       /* These relocs should never be against a symbol
8530                          defined in a shared lib.  Leave them alone if
8531                          that turns out to be the case.  */
8532                       if (!is_local)
8533                         continue;
8534
8535                       /* LD -> LE */
8536                       tls_set = 0;
8537                       tls_clear = TLS_LD;
8538                       tls_type = TLS_TLS | TLS_LD;
8539                       break;
8540
8541                     case R_PPC64_GOT_TLSGD16:
8542                     case R_PPC64_GOT_TLSGD16_LO:
8543                       expecting_tls_get_addr = 1;
8544                       found_tls_get_addr_arg = 1;
8545                       /* Fall thru */
8546
8547                     case R_PPC64_GOT_TLSGD16_HI:
8548                     case R_PPC64_GOT_TLSGD16_HA:
8549                       if (ok_tprel)
8550                         /* GD -> LE */
8551                         tls_set = 0;
8552                       else
8553                         /* GD -> IE */
8554                         tls_set = TLS_TLS | TLS_TPRELGD;
8555                       tls_clear = TLS_GD;
8556                       tls_type = TLS_TLS | TLS_GD;
8557                       break;
8558
8559                     case R_PPC64_GOT_TPREL16_DS:
8560                     case R_PPC64_GOT_TPREL16_LO_DS:
8561                     case R_PPC64_GOT_TPREL16_HI:
8562                     case R_PPC64_GOT_TPREL16_HA:
8563                       if (ok_tprel)
8564                         {
8565                           /* IE -> LE */
8566                           tls_set = 0;
8567                           tls_clear = TLS_TPREL;
8568                           tls_type = TLS_TLS | TLS_TPREL;
8569                           break;
8570                         }
8571                       continue;
8572
8573                     case R_PPC64_TLSGD:
8574                     case R_PPC64_TLSLD:
8575                       found_tls_get_addr_arg = 1;
8576                       /* Fall thru */
8577
8578                     case R_PPC64_TLS:
8579                     case R_PPC64_TOC16:
8580                     case R_PPC64_TOC16_LO:
8581                       if (sym_sec == NULL || sym_sec != toc)
8582                         continue;
8583
8584                       /* Mark this toc entry as referenced by a TLS
8585                          code sequence.  We can do that now in the
8586                          case of R_PPC64_TLS, and after checking for
8587                          tls_get_addr for the TOC16 relocs.  */
8588                       if (toc_ref == NULL)
8589                         toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8590                       if (toc_ref == NULL)
8591                         goto err_free_rel;
8592
8593                       if (h != NULL)
8594                         value = h->root.u.def.value;
8595                       else
8596                         value = sym->st_value;
8597                       value += rel->r_addend;
8598                       if (value % 8 != 0)
8599                         continue;
8600                       BFD_ASSERT (value < toc->size
8601                                   && toc->output_offset % 8 == 0);
8602                       toc_ref_index = (value + toc->output_offset) / 8;
8603                       if (r_type == R_PPC64_TLS
8604                           || r_type == R_PPC64_TLSGD
8605                           || r_type == R_PPC64_TLSLD)
8606                         {
8607                           toc_ref[toc_ref_index] = 1;
8608                           continue;
8609                         }
8610
8611                       if (pass != 0 && toc_ref[toc_ref_index] == 0)
8612                         continue;
8613
8614                       tls_set = 0;
8615                       tls_clear = 0;
8616                       expecting_tls_get_addr = 2;
8617                       break;
8618
8619                     case R_PPC64_TPREL64:
8620                       if (pass == 0
8621                           || sec != toc
8622                           || toc_ref == NULL
8623                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8624                         continue;
8625                       if (ok_tprel)
8626                         {
8627                           /* IE -> LE */
8628                           tls_set = TLS_EXPLICIT;
8629                           tls_clear = TLS_TPREL;
8630                           break;
8631                         }
8632                       continue;
8633
8634                     case R_PPC64_DTPMOD64:
8635                       if (pass == 0
8636                           || sec != toc
8637                           || toc_ref == NULL
8638                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8639                         continue;
8640                       if (rel + 1 < relend
8641                           && (rel[1].r_info
8642                               == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8643                           && rel[1].r_offset == rel->r_offset + 8)
8644                         {
8645                           if (ok_tprel)
8646                             /* GD -> LE */
8647                             tls_set = TLS_EXPLICIT | TLS_GD;
8648                           else
8649                             /* GD -> IE */
8650                             tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8651                           tls_clear = TLS_GD;
8652                         }
8653                       else
8654                         {
8655                           if (!is_local)
8656                             continue;
8657
8658                           /* LD -> LE */
8659                           tls_set = TLS_EXPLICIT;
8660                           tls_clear = TLS_LD;
8661                         }
8662                       break;
8663
8664                     default:
8665                       continue;
8666                     }
8667
8668                   if (pass == 0)
8669                     {
8670                       if (!expecting_tls_get_addr
8671                           || !sec->has_tls_get_addr_call)
8672                         continue;
8673
8674                       if (rel + 1 < relend
8675                           && branch_reloc_hash_match (ibfd, rel + 1,
8676                                                       htab->tls_get_addr,
8677                                                       htab->tls_get_addr_fd))
8678                         {
8679                           if (expecting_tls_get_addr == 2)
8680                             {
8681                               /* Check for toc tls entries.  */
8682                               unsigned char *toc_tls;
8683                               int retval;
8684
8685                               retval = get_tls_mask (&toc_tls, NULL, NULL,
8686                                                      &locsyms,
8687                                                      rel, ibfd);
8688                               if (retval == 0)
8689                                 goto err_free_rel;
8690                               if (toc_tls != NULL)
8691                                 {
8692                                   if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8693                                     found_tls_get_addr_arg = 1;
8694                                   if (retval > 1)
8695                                     toc_ref[toc_ref_index] = 1;
8696                                 }
8697                             }
8698                           continue;
8699                         }
8700
8701                       if (expecting_tls_get_addr != 1)
8702                         continue;
8703
8704                       /* Uh oh, we didn't find the expected call.  We
8705                          could just mark this symbol to exclude it
8706                          from tls optimization but it's safer to skip
8707                          the entire optimization.  */
8708                       info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8709                                                 "TLS optimization disabled\n"),
8710                                               ibfd, sec, rel->r_offset);
8711                       ret = TRUE;
8712                       goto err_free_rel;
8713                     }
8714
8715                   if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8716                     {
8717                       struct plt_entry *ent;
8718                       for (ent = htab->tls_get_addr->elf.plt.plist;
8719                            ent != NULL;
8720                            ent = ent->next)
8721                         if (ent->addend == 0)
8722                           {
8723                             if (ent->plt.refcount > 0)
8724                               {
8725                                 ent->plt.refcount -= 1;
8726                                 expecting_tls_get_addr = 0;
8727                               }
8728                             break;
8729                           }
8730                     }
8731
8732                   if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8733                     {
8734                       struct plt_entry *ent;
8735                       for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8736                            ent != NULL;
8737                            ent = ent->next)
8738                         if (ent->addend == 0)
8739                           {
8740                             if (ent->plt.refcount > 0)
8741                               ent->plt.refcount -= 1;
8742                             break;
8743                           }
8744                     }
8745
8746                   if (tls_clear == 0)
8747                     continue;
8748
8749                   if ((tls_set & TLS_EXPLICIT) == 0)
8750                     {
8751                       struct got_entry *ent;
8752
8753                       /* Adjust got entry for this reloc.  */
8754                       if (h != NULL)
8755                         ent = h->got.glist;
8756                       else
8757                         ent = elf_local_got_ents (ibfd)[r_symndx];
8758
8759                       for (; ent != NULL; ent = ent->next)
8760                         if (ent->addend == rel->r_addend
8761                             && ent->owner == ibfd
8762                             && ent->tls_type == tls_type)
8763                           break;
8764                       if (ent == NULL)
8765                         abort ();
8766
8767                       if (tls_set == 0)
8768                         {
8769                           /* We managed to get rid of a got entry.  */
8770                           if (ent->got.refcount > 0)
8771                             ent->got.refcount -= 1;
8772                         }
8773                     }
8774                   else
8775                     {
8776                       /* If we got rid of a DTPMOD/DTPREL reloc pair then
8777                          we'll lose one or two dyn relocs.  */
8778                       if (!dec_dynrel_count (rel->r_info, sec, info,
8779                                              NULL, h, sym))
8780                         return FALSE;
8781
8782                       if (tls_set == (TLS_EXPLICIT | TLS_GD))
8783                         {
8784                           if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8785                                                  NULL, h, sym))
8786                             return FALSE;
8787                         }
8788                     }
8789
8790                   *tls_mask |= tls_set;
8791                   *tls_mask &= ~tls_clear;
8792                 }
8793
8794               if (elf_section_data (sec)->relocs != relstart)
8795                 free (relstart);
8796             }
8797
8798         if (locsyms != NULL
8799             && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8800           {
8801             if (!info->keep_memory)
8802               free (locsyms);
8803             else
8804               elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8805           }
8806       }
8807
8808   if (toc_ref != NULL)
8809     free (toc_ref);
8810   return TRUE;
8811 }
8812
8813 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8814    the values of any global symbols in a toc section that has been
8815    edited.  Globals in toc sections should be a rarity, so this function
8816    sets a flag if any are found in toc sections other than the one just
8817    edited, so that futher hash table traversals can be avoided.  */
8818
8819 struct adjust_toc_info
8820 {
8821   asection *toc;
8822   unsigned long *skip;
8823   bfd_boolean global_toc_syms;
8824 };
8825
8826 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8827
8828 static bfd_boolean
8829 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8830 {
8831   struct ppc_link_hash_entry *eh;
8832   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8833   unsigned long i;
8834
8835   if (h->root.type != bfd_link_hash_defined
8836       && h->root.type != bfd_link_hash_defweak)
8837     return TRUE;
8838
8839   eh = (struct ppc_link_hash_entry *) h;
8840   if (eh->adjust_done)
8841     return TRUE;
8842
8843   if (eh->elf.root.u.def.section == toc_inf->toc)
8844     {
8845       if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8846         i = toc_inf->toc->rawsize >> 3;
8847       else
8848         i = eh->elf.root.u.def.value >> 3;
8849
8850       if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8851         {
8852           (*_bfd_error_handler)
8853             (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8854           do
8855             ++i;
8856           while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8857           eh->elf.root.u.def.value = (bfd_vma) i << 3;
8858         }
8859
8860       eh->elf.root.u.def.value -= toc_inf->skip[i];
8861       eh->adjust_done = 1;
8862     }
8863   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8864     toc_inf->global_toc_syms = TRUE;
8865
8866   return TRUE;
8867 }
8868
8869 /* Return TRUE iff INSN is one we expect on a _LO variety toc/got reloc.  */
8870
8871 static bfd_boolean
8872 ok_lo_toc_insn (unsigned int insn)
8873 {
8874   return ((insn & (0x3f << 26)) == 14u << 26 /* addi */
8875           || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8876           || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8877           || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8878           || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8879           || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8880           || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8881           || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8882           || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8883           || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8884           || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8885           || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8886           || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8887           || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8888           || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
8889               && (insn & 3) != 1)
8890           || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
8891               && ((insn & 3) == 0 || (insn & 3) == 3))
8892           || (insn & (0x3f << 26)) == 12u << 26 /* addic */);
8893 }
8894
8895 /* Examine all relocs referencing .toc sections in order to remove
8896    unused .toc entries.  */
8897
8898 bfd_boolean
8899 ppc64_elf_edit_toc (struct bfd_link_info *info)
8900 {
8901   bfd *ibfd;
8902   struct adjust_toc_info toc_inf;
8903   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8904
8905   htab->do_toc_opt = 1;
8906   toc_inf.global_toc_syms = TRUE;
8907   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8908     {
8909       asection *toc, *sec;
8910       Elf_Internal_Shdr *symtab_hdr;
8911       Elf_Internal_Sym *local_syms;
8912       Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8913       unsigned long *skip, *drop;
8914       unsigned char *used;
8915       unsigned char *keep, last, some_unused;
8916
8917       if (!is_ppc64_elf (ibfd))
8918         continue;
8919
8920       toc = bfd_get_section_by_name (ibfd, ".toc");
8921       if (toc == NULL
8922           || toc->size == 0
8923           || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8924           || discarded_section (toc))
8925         continue;
8926
8927       toc_relocs = NULL;
8928       local_syms = NULL;
8929       symtab_hdr = &elf_symtab_hdr (ibfd);
8930
8931       /* Look at sections dropped from the final link.  */
8932       skip = NULL;
8933       relstart = NULL;
8934       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8935         {
8936           if (sec->reloc_count == 0
8937               || !discarded_section (sec)
8938               || get_opd_info (sec)
8939               || (sec->flags & SEC_ALLOC) == 0
8940               || (sec->flags & SEC_DEBUGGING) != 0)
8941             continue;
8942
8943           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8944           if (relstart == NULL)
8945             goto error_ret;
8946
8947           /* Run through the relocs to see which toc entries might be
8948              unused.  */
8949           for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8950             {
8951               enum elf_ppc64_reloc_type r_type;
8952               unsigned long r_symndx;
8953               asection *sym_sec;
8954               struct elf_link_hash_entry *h;
8955               Elf_Internal_Sym *sym;
8956               bfd_vma val;
8957
8958               r_type = ELF64_R_TYPE (rel->r_info);
8959               switch (r_type)
8960                 {
8961                 default:
8962                   continue;
8963
8964                 case R_PPC64_TOC16:
8965                 case R_PPC64_TOC16_LO:
8966                 case R_PPC64_TOC16_HI:
8967                 case R_PPC64_TOC16_HA:
8968                 case R_PPC64_TOC16_DS:
8969                 case R_PPC64_TOC16_LO_DS:
8970                   break;
8971                 }
8972
8973               r_symndx = ELF64_R_SYM (rel->r_info);
8974               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8975                               r_symndx, ibfd))
8976                 goto error_ret;
8977
8978               if (sym_sec != toc)
8979                 continue;
8980
8981               if (h != NULL)
8982                 val = h->root.u.def.value;
8983               else
8984                 val = sym->st_value;
8985               val += rel->r_addend;
8986
8987               if (val >= toc->size)
8988                 continue;
8989
8990               /* Anything in the toc ought to be aligned to 8 bytes.
8991                  If not, don't mark as unused.  */
8992               if (val & 7)
8993                 continue;
8994
8995               if (skip == NULL)
8996                 {
8997                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8998                   if (skip == NULL)
8999                     goto error_ret;
9000                 }
9001
9002               skip[val >> 3] = ref_from_discarded;
9003             }
9004
9005           if (elf_section_data (sec)->relocs != relstart)
9006             free (relstart);
9007         }
9008
9009       /* For largetoc loads of address constants, we can convert
9010          .  addis rx,2,addr@got@ha
9011          .  ld ry,addr@got@l(rx)
9012          to
9013          .  addis rx,2,addr@toc@ha
9014          .  addi ry,rx,addr@toc@l
9015          when addr is within 2G of the toc pointer.  This then means
9016          that the word storing "addr" in the toc is no longer needed.  */
9017
9018       if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
9019           && toc->output_section->rawsize < (bfd_vma) 1 << 31
9020           && toc->reloc_count != 0)
9021         {
9022           /* Read toc relocs.  */
9023           toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9024                                                   info->keep_memory);
9025           if (toc_relocs == NULL)
9026             goto error_ret;
9027
9028           for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9029             {
9030               enum elf_ppc64_reloc_type r_type;
9031               unsigned long r_symndx;
9032               asection *sym_sec;
9033               struct elf_link_hash_entry *h;
9034               Elf_Internal_Sym *sym;
9035               bfd_vma val, addr;
9036
9037               r_type = ELF64_R_TYPE (rel->r_info);
9038               if (r_type != R_PPC64_ADDR64)
9039                 continue;
9040
9041               r_symndx = ELF64_R_SYM (rel->r_info);
9042               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9043                               r_symndx, ibfd))
9044                 goto error_ret;
9045
9046               if (sym_sec == NULL
9047                   || sym_sec->output_section == NULL
9048                   || discarded_section (sym_sec))
9049                 continue;
9050
9051               if (!SYMBOL_REFERENCES_LOCAL (info, h))
9052                 continue;
9053
9054               if (h != NULL)
9055                 {
9056                   if (h->type == STT_GNU_IFUNC)
9057                     continue;
9058                   val = h->root.u.def.value;
9059                 }
9060               else
9061                 {
9062                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
9063                     continue;
9064                   val = sym->st_value;
9065                 }
9066               val += rel->r_addend;
9067               val += sym_sec->output_section->vma + sym_sec->output_offset;
9068
9069               /* We don't yet know the exact toc pointer value, but we
9070                  know it will be somewhere in the toc section.  Don't
9071                  optimize if the difference from any possible toc
9072                  pointer is outside [ff..f80008000, 7fff7fff].  */
9073               addr = toc->output_section->vma + TOC_BASE_OFF;
9074               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9075                 continue;
9076
9077               addr = toc->output_section->vma + toc->output_section->rawsize;
9078               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9079                 continue;
9080
9081               if (skip == NULL)
9082                 {
9083                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9084                   if (skip == NULL)
9085                     goto error_ret;
9086                 }
9087
9088               skip[rel->r_offset >> 3]
9089                 |= can_optimize | ((rel - toc_relocs) << 2);
9090             }
9091         }
9092
9093       if (skip == NULL)
9094         continue;
9095
9096       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
9097       if (used == NULL)
9098         {
9099         error_ret:
9100           if (local_syms != NULL
9101               && symtab_hdr->contents != (unsigned char *) local_syms)
9102             free (local_syms);
9103           if (sec != NULL
9104               && relstart != NULL
9105               && elf_section_data (sec)->relocs != relstart)
9106             free (relstart);
9107           if (toc_relocs != NULL
9108               && elf_section_data (toc)->relocs != toc_relocs)
9109             free (toc_relocs);
9110           if (skip != NULL)
9111             free (skip);
9112           return FALSE;
9113         }
9114
9115       /* Now check all kept sections that might reference the toc.
9116          Check the toc itself last.  */
9117       for (sec = (ibfd->sections == toc && toc->next ? toc->next
9118                   : ibfd->sections);
9119            sec != NULL;
9120            sec = (sec == toc ? NULL
9121                   : sec->next == NULL ? toc
9122                   : sec->next == toc && toc->next ? toc->next
9123                   : sec->next))
9124         {
9125           int repeat;
9126
9127           if (sec->reloc_count == 0
9128               || discarded_section (sec)
9129               || get_opd_info (sec)
9130               || (sec->flags & SEC_ALLOC) == 0
9131               || (sec->flags & SEC_DEBUGGING) != 0)
9132             continue;
9133
9134           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9135                                                 info->keep_memory);
9136           if (relstart == NULL)
9137             {
9138               free (used);
9139               goto error_ret;
9140             }
9141
9142           /* Mark toc entries referenced as used.  */
9143           do
9144             {
9145               repeat = 0;
9146               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9147                 {
9148                   enum elf_ppc64_reloc_type r_type;
9149                   unsigned long r_symndx;
9150                   asection *sym_sec;
9151                   struct elf_link_hash_entry *h;
9152                   Elf_Internal_Sym *sym;
9153                   bfd_vma val;
9154                   enum {no_check, check_lo, check_ha} insn_check;
9155
9156                   r_type = ELF64_R_TYPE (rel->r_info);
9157                   switch (r_type)
9158                     {
9159                     default:
9160                       insn_check = no_check;
9161                       break;
9162
9163                     case R_PPC64_GOT_TLSLD16_HA:
9164                     case R_PPC64_GOT_TLSGD16_HA:
9165                     case R_PPC64_GOT_TPREL16_HA:
9166                     case R_PPC64_GOT_DTPREL16_HA:
9167                     case R_PPC64_GOT16_HA:
9168                     case R_PPC64_TOC16_HA:
9169                       insn_check = check_ha;
9170                       break;
9171
9172                     case R_PPC64_GOT_TLSLD16_LO:
9173                     case R_PPC64_GOT_TLSGD16_LO:
9174                     case R_PPC64_GOT_TPREL16_LO_DS:
9175                     case R_PPC64_GOT_DTPREL16_LO_DS:
9176                     case R_PPC64_GOT16_LO:
9177                     case R_PPC64_GOT16_LO_DS:
9178                     case R_PPC64_TOC16_LO:
9179                     case R_PPC64_TOC16_LO_DS:
9180                       insn_check = check_lo;
9181                       break;
9182                     }
9183
9184                   if (insn_check != no_check)
9185                     {
9186                       bfd_vma off = rel->r_offset & ~3;
9187                       unsigned char buf[4];
9188                       unsigned int insn;
9189
9190                       if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
9191                         {
9192                           free (used);
9193                           goto error_ret;
9194                         }
9195                       insn = bfd_get_32 (ibfd, buf);
9196                       if (insn_check == check_lo
9197                           ? !ok_lo_toc_insn (insn)
9198                           : ((insn & ((0x3f << 26) | 0x1f << 16))
9199                              != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9200                         {
9201                           char str[12];
9202
9203                           ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
9204                           sprintf (str, "%#08x", insn);
9205                           info->callbacks->einfo
9206                             (_("%P: %H: toc optimization is not supported for"
9207                                " %s instruction.\n"),
9208                              ibfd, sec, rel->r_offset & ~3, str);
9209                         }
9210                     }
9211
9212                   switch (r_type)
9213                     {
9214                     case R_PPC64_TOC16:
9215                     case R_PPC64_TOC16_LO:
9216                     case R_PPC64_TOC16_HI:
9217                     case R_PPC64_TOC16_HA:
9218                     case R_PPC64_TOC16_DS:
9219                     case R_PPC64_TOC16_LO_DS:
9220                       /* In case we're taking addresses of toc entries.  */
9221                     case R_PPC64_ADDR64:
9222                       break;
9223
9224                     default:
9225                       continue;
9226                     }
9227
9228                   r_symndx = ELF64_R_SYM (rel->r_info);
9229                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9230                                   r_symndx, ibfd))
9231                     {
9232                       free (used);
9233                       goto error_ret;
9234                     }
9235
9236                   if (sym_sec != toc)
9237                     continue;
9238
9239                   if (h != NULL)
9240                     val = h->root.u.def.value;
9241                   else
9242                     val = sym->st_value;
9243                   val += rel->r_addend;
9244
9245                   if (val >= toc->size)
9246                     continue;
9247
9248                   if ((skip[val >> 3] & can_optimize) != 0)
9249                     {
9250                       bfd_vma off;
9251                       unsigned char opc;
9252
9253                       switch (r_type)
9254                         {
9255                         case R_PPC64_TOC16_HA:
9256                           break;
9257
9258                         case R_PPC64_TOC16_LO_DS:
9259                           off = rel->r_offset;
9260                           off += (bfd_big_endian (ibfd) ? -2 : 3);
9261                           if (!bfd_get_section_contents (ibfd, sec, &opc,
9262                                                          off, 1))
9263                             {
9264                               free (used);
9265                               goto error_ret;
9266                             }
9267                           if ((opc & (0x3f << 2)) == (58u << 2))
9268                             break;
9269                           /* Fall thru */
9270
9271                         default:
9272                           /* Wrong sort of reloc, or not a ld.  We may
9273                              as well clear ref_from_discarded too.  */
9274                           skip[val >> 3] = 0;
9275                         }
9276                     }
9277
9278                   if (sec != toc)
9279                     used[val >> 3] = 1;
9280                   /* For the toc section, we only mark as used if this
9281                      entry itself isn't unused.  */
9282                   else if ((used[rel->r_offset >> 3]
9283                             || !(skip[rel->r_offset >> 3] & ref_from_discarded))
9284                            && !used[val >> 3])
9285                     {
9286                       /* Do all the relocs again, to catch reference
9287                          chains.  */
9288                       repeat = 1;
9289                       used[val >> 3] = 1;
9290                     }
9291                 }
9292             }
9293           while (repeat);
9294
9295           if (elf_section_data (sec)->relocs != relstart)
9296             free (relstart);
9297         }
9298
9299       /* Merge the used and skip arrays.  Assume that TOC
9300          doublewords not appearing as either used or unused belong
9301          to to an entry more than one doubleword in size.  */
9302       for (drop = skip, keep = used, last = 0, some_unused = 0;
9303            drop < skip + (toc->size + 7) / 8;
9304            ++drop, ++keep)
9305         {
9306           if (*keep)
9307             {
9308               *drop &= ~ref_from_discarded;
9309               if ((*drop & can_optimize) != 0)
9310                 some_unused = 1;
9311               last = 0;
9312             }
9313           else if ((*drop & ref_from_discarded) != 0)
9314             {
9315               some_unused = 1;
9316               last = ref_from_discarded;
9317             }
9318           else
9319             *drop = last;
9320         }
9321
9322       free (used);
9323
9324       if (some_unused)
9325         {
9326           bfd_byte *contents, *src;
9327           unsigned long off;
9328           Elf_Internal_Sym *sym;
9329           bfd_boolean local_toc_syms = FALSE;
9330
9331           /* Shuffle the toc contents, and at the same time convert the
9332              skip array from booleans into offsets.  */
9333           if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9334             goto error_ret;
9335
9336           elf_section_data (toc)->this_hdr.contents = contents;
9337
9338           for (src = contents, off = 0, drop = skip;
9339                src < contents + toc->size;
9340                src += 8, ++drop)
9341             {
9342               if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9343                 off += 8;
9344               else if (off != 0)
9345                 {
9346                   *drop = off;
9347                   memcpy (src - off, src, 8);
9348                 }
9349             }
9350           *drop = off;
9351           toc->rawsize = toc->size;
9352           toc->size = src - contents - off;
9353
9354           /* Adjust addends for relocs against the toc section sym,
9355              and optimize any accesses we can.  */
9356           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9357             {
9358               if (sec->reloc_count == 0
9359                   || discarded_section (sec))
9360                 continue;
9361
9362               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9363                                                     info->keep_memory);
9364               if (relstart == NULL)
9365                 goto error_ret;
9366
9367               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9368                 {
9369                   enum elf_ppc64_reloc_type r_type;
9370                   unsigned long r_symndx;
9371                   asection *sym_sec;
9372                   struct elf_link_hash_entry *h;
9373                   bfd_vma val;
9374
9375                   r_type = ELF64_R_TYPE (rel->r_info);
9376                   switch (r_type)
9377                     {
9378                     default:
9379                       continue;
9380
9381                     case R_PPC64_TOC16:
9382                     case R_PPC64_TOC16_LO:
9383                     case R_PPC64_TOC16_HI:
9384                     case R_PPC64_TOC16_HA:
9385                     case R_PPC64_TOC16_DS:
9386                     case R_PPC64_TOC16_LO_DS:
9387                     case R_PPC64_ADDR64:
9388                       break;
9389                     }
9390
9391                   r_symndx = ELF64_R_SYM (rel->r_info);
9392                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9393                                   r_symndx, ibfd))
9394                     goto error_ret;
9395
9396                   if (sym_sec != toc)
9397                     continue;
9398
9399                   if (h != NULL)
9400                     val = h->root.u.def.value;
9401                   else
9402                     {
9403                       val = sym->st_value;
9404                       if (val != 0)
9405                         local_toc_syms = TRUE;
9406                     }
9407
9408                   val += rel->r_addend;
9409
9410                   if (val > toc->rawsize)
9411                     val = toc->rawsize;
9412                   else if ((skip[val >> 3] & ref_from_discarded) != 0)
9413                     continue;
9414                   else if ((skip[val >> 3] & can_optimize) != 0)
9415                     {
9416                       Elf_Internal_Rela *tocrel
9417                         = toc_relocs + (skip[val >> 3] >> 2);
9418                       unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9419
9420                       switch (r_type)
9421                         {
9422                         case R_PPC64_TOC16_HA:
9423                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9424                           break;
9425
9426                         case R_PPC64_TOC16_LO_DS:
9427                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9428                           break;
9429
9430                         default:
9431                           if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9432                             ppc_howto_init ();
9433                           info->callbacks->einfo
9434                             (_("%P: %H: %s references "
9435                                "optimized away TOC entry\n"),
9436                              ibfd, sec, rel->r_offset,
9437                              ppc64_elf_howto_table[r_type]->name);
9438                           bfd_set_error (bfd_error_bad_value);
9439                           goto error_ret;
9440                         }
9441                       rel->r_addend = tocrel->r_addend;
9442                       elf_section_data (sec)->relocs = relstart;
9443                       continue;
9444                     }
9445
9446                   if (h != NULL || sym->st_value != 0)
9447                     continue;
9448
9449                   rel->r_addend -= skip[val >> 3];
9450                   elf_section_data (sec)->relocs = relstart;
9451                 }
9452
9453               if (elf_section_data (sec)->relocs != relstart)
9454                 free (relstart);
9455             }
9456
9457           /* We shouldn't have local or global symbols defined in the TOC,
9458              but handle them anyway.  */
9459           if (local_syms != NULL)
9460             for (sym = local_syms;
9461                  sym < local_syms + symtab_hdr->sh_info;
9462                  ++sym)
9463               if (sym->st_value != 0
9464                   && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9465                 {
9466                   unsigned long i;
9467
9468                   if (sym->st_value > toc->rawsize)
9469                     i = toc->rawsize >> 3;
9470                   else
9471                     i = sym->st_value >> 3;
9472
9473                   if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9474                     {
9475                       if (local_toc_syms)
9476                         (*_bfd_error_handler)
9477                           (_("%s defined on removed toc entry"),
9478                            bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9479                       do
9480                         ++i;
9481                       while ((skip[i] & (ref_from_discarded | can_optimize)));
9482                       sym->st_value = (bfd_vma) i << 3;
9483                     }
9484
9485                   sym->st_value -= skip[i];
9486                   symtab_hdr->contents = (unsigned char *) local_syms;
9487                 }
9488
9489           /* Adjust any global syms defined in this toc input section.  */
9490           if (toc_inf.global_toc_syms)
9491             {
9492               toc_inf.toc = toc;
9493               toc_inf.skip = skip;
9494               toc_inf.global_toc_syms = FALSE;
9495               elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9496                                       &toc_inf);
9497             }
9498
9499           if (toc->reloc_count != 0)
9500             {
9501               Elf_Internal_Shdr *rel_hdr;
9502               Elf_Internal_Rela *wrel;
9503               bfd_size_type sz;
9504
9505               /* Remove unused toc relocs, and adjust those we keep.  */
9506               if (toc_relocs == NULL)
9507                 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9508                                                         info->keep_memory);
9509               if (toc_relocs == NULL)
9510                 goto error_ret;
9511
9512               wrel = toc_relocs;
9513               for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9514                 if ((skip[rel->r_offset >> 3]
9515                      & (ref_from_discarded | can_optimize)) == 0)
9516                   {
9517                     wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9518                     wrel->r_info = rel->r_info;
9519                     wrel->r_addend = rel->r_addend;
9520                     ++wrel;
9521                   }
9522                 else if (!dec_dynrel_count (rel->r_info, toc, info,
9523                                             &local_syms, NULL, NULL))
9524                   goto error_ret;
9525
9526               elf_section_data (toc)->relocs = toc_relocs;
9527               toc->reloc_count = wrel - toc_relocs;
9528               rel_hdr = _bfd_elf_single_rel_hdr (toc);
9529               sz = rel_hdr->sh_entsize;
9530               rel_hdr->sh_size = toc->reloc_count * sz;
9531             }
9532         }
9533       else if (toc_relocs != NULL
9534                && elf_section_data (toc)->relocs != toc_relocs)
9535         free (toc_relocs);
9536
9537       if (local_syms != NULL
9538           && symtab_hdr->contents != (unsigned char *) local_syms)
9539         {
9540           if (!info->keep_memory)
9541             free (local_syms);
9542           else
9543             symtab_hdr->contents = (unsigned char *) local_syms;
9544         }
9545       free (skip);
9546     }
9547
9548   return TRUE;
9549 }
9550
9551 /* Return true iff input section I references the TOC using
9552    instructions limited to +/-32k offsets.  */
9553
9554 bfd_boolean
9555 ppc64_elf_has_small_toc_reloc (asection *i)
9556 {
9557   return (is_ppc64_elf (i->owner)
9558           && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9559 }
9560
9561 /* Allocate space for one GOT entry.  */
9562
9563 static void
9564 allocate_got (struct elf_link_hash_entry *h,
9565               struct bfd_link_info *info,
9566               struct got_entry *gent)
9567 {
9568   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9569   bfd_boolean dyn;
9570   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9571   int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9572                  ? 16 : 8);
9573   int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9574                   ? 2 : 1) * sizeof (Elf64_External_Rela);
9575   asection *got = ppc64_elf_tdata (gent->owner)->got;
9576
9577   gent->got.offset = got->size;
9578   got->size += entsize;
9579
9580   dyn = htab->elf.dynamic_sections_created;
9581   if (h->type == STT_GNU_IFUNC)
9582     {
9583       htab->elf.irelplt->size += rentsize;
9584       htab->got_reli_size += rentsize;
9585     }
9586   else if ((bfd_link_pic (info)
9587             || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
9588            && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9589                || h->root.type != bfd_link_hash_undefweak))
9590     {
9591       asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9592       relgot->size += rentsize;
9593     }
9594 }
9595
9596 /* This function merges got entries in the same toc group.  */
9597
9598 static void
9599 merge_got_entries (struct got_entry **pent)
9600 {
9601   struct got_entry *ent, *ent2;
9602
9603   for (ent = *pent; ent != NULL; ent = ent->next)
9604     if (!ent->is_indirect)
9605       for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9606         if (!ent2->is_indirect
9607             && ent2->addend == ent->addend
9608             && ent2->tls_type == ent->tls_type
9609             && elf_gp (ent2->owner) == elf_gp (ent->owner))
9610           {
9611             ent2->is_indirect = TRUE;
9612             ent2->got.ent = ent;
9613           }
9614 }
9615
9616 /* Allocate space in .plt, .got and associated reloc sections for
9617    dynamic relocs.  */
9618
9619 static bfd_boolean
9620 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9621 {
9622   struct bfd_link_info *info;
9623   struct ppc_link_hash_table *htab;
9624   asection *s;
9625   struct ppc_link_hash_entry *eh;
9626   struct got_entry **pgent, *gent;
9627
9628   if (h->root.type == bfd_link_hash_indirect)
9629     return TRUE;
9630
9631   info = (struct bfd_link_info *) inf;
9632   htab = ppc_hash_table (info);
9633   if (htab == NULL)
9634     return FALSE;
9635
9636   eh = (struct ppc_link_hash_entry *) h;
9637   /* Run through the TLS GD got entries first if we're changing them
9638      to TPREL.  */
9639   if ((eh->tls_mask & TLS_TPRELGD) != 0)
9640     for (gent = h->got.glist; gent != NULL; gent = gent->next)
9641       if (gent->got.refcount > 0
9642           && (gent->tls_type & TLS_GD) != 0)
9643         {
9644           /* This was a GD entry that has been converted to TPREL.  If
9645              there happens to be a TPREL entry we can use that one.  */
9646           struct got_entry *ent;
9647           for (ent = h->got.glist; ent != NULL; ent = ent->next)
9648             if (ent->got.refcount > 0
9649                 && (ent->tls_type & TLS_TPREL) != 0
9650                 && ent->addend == gent->addend
9651                 && ent->owner == gent->owner)
9652               {
9653                 gent->got.refcount = 0;
9654                 break;
9655               }
9656
9657           /* If not, then we'll be using our own TPREL entry.  */
9658           if (gent->got.refcount != 0)
9659             gent->tls_type = TLS_TLS | TLS_TPREL;
9660         }
9661
9662   /* Remove any list entry that won't generate a word in the GOT before
9663      we call merge_got_entries.  Otherwise we risk merging to empty
9664      entries.  */
9665   pgent = &h->got.glist;
9666   while ((gent = *pgent) != NULL)
9667     if (gent->got.refcount > 0)
9668       {
9669         if ((gent->tls_type & TLS_LD) != 0
9670             && !h->def_dynamic)
9671           {
9672             ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9673             *pgent = gent->next;
9674           }
9675         else
9676           pgent = &gent->next;
9677       }
9678     else
9679       *pgent = gent->next;
9680
9681   if (!htab->do_multi_toc)
9682     merge_got_entries (&h->got.glist);
9683
9684   for (gent = h->got.glist; gent != NULL; gent = gent->next)
9685     if (!gent->is_indirect)
9686       {
9687         /* Make sure this symbol is output as a dynamic symbol.
9688            Undefined weak syms won't yet be marked as dynamic,
9689            nor will all TLS symbols.  */
9690         if (h->dynindx == -1
9691             && !h->forced_local
9692             && h->type != STT_GNU_IFUNC
9693             && htab->elf.dynamic_sections_created)
9694           {
9695             if (! bfd_elf_link_record_dynamic_symbol (info, h))
9696               return FALSE;
9697           }
9698
9699         if (!is_ppc64_elf (gent->owner))
9700           abort ();
9701
9702         allocate_got (h, info, gent);
9703       }
9704
9705   if (!htab->elf.dynamic_sections_created
9706       && h->type != STT_GNU_IFUNC)
9707     eh->dyn_relocs = NULL;
9708
9709   if (eh->dyn_relocs != NULL)
9710     {
9711       struct elf_dyn_relocs *p, **pp;
9712
9713       /* In the shared -Bsymbolic case, discard space allocated for
9714          dynamic pc-relative relocs against symbols which turn out to
9715          be defined in regular objects.  For the normal shared case,
9716          discard space for relocs that have become local due to symbol
9717          visibility changes.  */
9718
9719       if (bfd_link_pic (info))
9720         {
9721           /* Relocs that use pc_count are those that appear on a call
9722              insn, or certain REL relocs (see must_be_dyn_reloc) that
9723              can be generated via assembly.  We want calls to
9724              protected symbols to resolve directly to the function
9725              rather than going via the plt.  If people want function
9726              pointer comparisons to work as expected then they should
9727              avoid writing weird assembly.  */
9728           if (SYMBOL_CALLS_LOCAL (info, h))
9729             {
9730               for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9731                 {
9732                   p->count -= p->pc_count;
9733                   p->pc_count = 0;
9734                   if (p->count == 0)
9735                     *pp = p->next;
9736                   else
9737                     pp = &p->next;
9738                 }
9739             }
9740
9741           /* Also discard relocs on undefined weak syms with
9742              non-default visibility.  */
9743           if (eh->dyn_relocs != NULL
9744               && h->root.type == bfd_link_hash_undefweak)
9745             {
9746               if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9747                 eh->dyn_relocs = NULL;
9748
9749               /* Make sure this symbol is output as a dynamic symbol.
9750                  Undefined weak syms won't yet be marked as dynamic.  */
9751               else if (h->dynindx == -1
9752                        && !h->forced_local)
9753                 {
9754                   if (! bfd_elf_link_record_dynamic_symbol (info, h))
9755                     return FALSE;
9756                 }
9757             }
9758         }
9759       else if (h->type == STT_GNU_IFUNC)
9760         {
9761           /* A plt entry is always created when making direct calls to
9762              an ifunc, even when building a static executable, but
9763              that doesn't cover all cases.  We may have only an ifunc
9764              initialised function pointer for a given ifunc symbol.
9765
9766              For ELFv2, dynamic relocations are not required when
9767              generating a global entry PLT stub.  */
9768           if (abiversion (info->output_bfd) >= 2)
9769             {
9770               if (global_entry_stub (h))
9771                 eh->dyn_relocs = NULL;
9772             }
9773
9774           /* For ELFv1 we have function descriptors.  Descriptors need
9775              to be treated like PLT entries and thus have dynamic
9776              relocations.  One exception is when the function
9777              descriptor is copied into .dynbss (which should only
9778              happen with ancient versions of gcc).  */
9779           else if (h->needs_copy)
9780             eh->dyn_relocs = NULL;
9781         }
9782       else if (ELIMINATE_COPY_RELOCS)
9783         {
9784           /* For the non-pic case, discard space for relocs against
9785              symbols which turn out to need copy relocs or are not
9786              dynamic.  */
9787
9788           /* First make sure this symbol is output as a dynamic symbol.
9789              Undefined weak syms won't yet be marked as dynamic.  */
9790           if (h->root.type == bfd_link_hash_undefweak
9791               && !h->non_got_ref
9792               && !h->def_regular
9793               && h->dynindx == -1
9794               && !h->forced_local
9795               && !bfd_elf_link_record_dynamic_symbol (info, h))
9796             return FALSE;
9797
9798           if (h->non_got_ref
9799               || h->def_regular
9800               || h->dynindx == -1)
9801             eh->dyn_relocs = NULL;
9802         }
9803
9804       /* Finally, allocate space.  */
9805       for (p = eh->dyn_relocs; p != NULL; p = p->next)
9806         {
9807           asection *sreloc = elf_section_data (p->sec)->sreloc;
9808           if (eh->elf.type == STT_GNU_IFUNC)
9809             sreloc = htab->elf.irelplt;
9810           sreloc->size += p->count * sizeof (Elf64_External_Rela);
9811         }
9812     }
9813
9814   if ((htab->elf.dynamic_sections_created
9815        && h->dynindx != -1
9816        && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
9817       || h->type == STT_GNU_IFUNC)
9818     {
9819       struct plt_entry *pent;
9820       bfd_boolean doneone = FALSE;
9821       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9822         if (pent->plt.refcount > 0)
9823           {
9824             if (!htab->elf.dynamic_sections_created
9825                 || h->dynindx == -1)
9826               {
9827                 s = htab->elf.iplt;
9828                 pent->plt.offset = s->size;
9829                 s->size += PLT_ENTRY_SIZE (htab);
9830                 s = htab->elf.irelplt;
9831               }
9832             else
9833               {
9834                 /* If this is the first .plt entry, make room for the special
9835                    first entry.  */
9836                 s = htab->elf.splt;
9837                 if (s->size == 0)
9838                   s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9839
9840                 pent->plt.offset = s->size;
9841
9842                 /* Make room for this entry.  */
9843                 s->size += PLT_ENTRY_SIZE (htab);
9844
9845                 /* Make room for the .glink code.  */
9846                 s = htab->glink;
9847                 if (s->size == 0)
9848                   s->size += GLINK_CALL_STUB_SIZE;
9849                 if (htab->opd_abi)
9850                   {
9851                     /* We need bigger stubs past index 32767.  */
9852                     if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9853                       s->size += 4;
9854                     s->size += 2*4;
9855                   }
9856                 else
9857                   s->size += 4;
9858
9859                 /* We also need to make an entry in the .rela.plt section.  */
9860                 s = htab->elf.srelplt;
9861               }
9862             s->size += sizeof (Elf64_External_Rela);
9863             doneone = TRUE;
9864           }
9865         else
9866           pent->plt.offset = (bfd_vma) -1;
9867       if (!doneone)
9868         {
9869           h->plt.plist = NULL;
9870           h->needs_plt = 0;
9871         }
9872     }
9873   else
9874     {
9875       h->plt.plist = NULL;
9876       h->needs_plt = 0;
9877     }
9878
9879   return TRUE;
9880 }
9881
9882 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9883    to set up space for global entry stubs.  These are put in glink,
9884    after the branch table.  */
9885
9886 static bfd_boolean
9887 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
9888 {
9889   struct bfd_link_info *info;
9890   struct ppc_link_hash_table *htab;
9891   struct plt_entry *pent;
9892   asection *s;
9893
9894   if (h->root.type == bfd_link_hash_indirect)
9895     return TRUE;
9896
9897   if (!h->pointer_equality_needed)
9898     return TRUE;
9899
9900   if (h->def_regular)
9901     return TRUE;
9902
9903   info = inf;
9904   htab = ppc_hash_table (info);
9905   if (htab == NULL)
9906     return FALSE;
9907
9908   s = htab->glink;
9909   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9910     if (pent->plt.offset != (bfd_vma) -1
9911         && pent->addend == 0)
9912       {
9913         /* For ELFv2, if this symbol is not defined in a regular file
9914            and we are not generating a shared library or pie, then we
9915            need to define the symbol in the executable on a call stub.
9916            This is to avoid text relocations.  */
9917         s->size = (s->size + 15) & -16;
9918         h->root.type = bfd_link_hash_defined;
9919         h->root.u.def.section = s;
9920         h->root.u.def.value = s->size;
9921         s->size += 16;
9922         break;
9923       }
9924   return TRUE;
9925 }
9926
9927 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9928    read-only sections.  */
9929
9930 static bfd_boolean
9931 maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
9932 {
9933   if (h->root.type == bfd_link_hash_indirect)
9934     return TRUE;
9935
9936   if (readonly_dynrelocs (h))
9937     {
9938       ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
9939
9940       /* Not an error, just cut short the traversal.  */
9941       return FALSE;
9942     }
9943   return TRUE;
9944 }
9945
9946 /* Set the sizes of the dynamic sections.  */
9947
9948 static bfd_boolean
9949 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
9950                                  struct bfd_link_info *info)
9951 {
9952   struct ppc_link_hash_table *htab;
9953   bfd *dynobj;
9954   asection *s;
9955   bfd_boolean relocs;
9956   bfd *ibfd;
9957   struct got_entry *first_tlsld;
9958
9959   htab = ppc_hash_table (info);
9960   if (htab == NULL)
9961     return FALSE;
9962
9963   dynobj = htab->elf.dynobj;
9964   if (dynobj == NULL)
9965     abort ();
9966
9967   if (htab->elf.dynamic_sections_created)
9968     {
9969       /* Set the contents of the .interp section to the interpreter.  */
9970       if (bfd_link_executable (info) && !info->nointerp)
9971         {
9972           s = bfd_get_linker_section (dynobj, ".interp");
9973           if (s == NULL)
9974             abort ();
9975           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
9976           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
9977         }
9978     }
9979
9980   /* Set up .got offsets for local syms, and space for local dynamic
9981      relocs.  */
9982   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9983     {
9984       struct got_entry **lgot_ents;
9985       struct got_entry **end_lgot_ents;
9986       struct plt_entry **local_plt;
9987       struct plt_entry **end_local_plt;
9988       unsigned char *lgot_masks;
9989       bfd_size_type locsymcount;
9990       Elf_Internal_Shdr *symtab_hdr;
9991
9992       if (!is_ppc64_elf (ibfd))
9993         continue;
9994
9995       for (s = ibfd->sections; s != NULL; s = s->next)
9996         {
9997           struct ppc_dyn_relocs *p;
9998
9999           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
10000             {
10001               if (!bfd_is_abs_section (p->sec)
10002                   && bfd_is_abs_section (p->sec->output_section))
10003                 {
10004                   /* Input section has been discarded, either because
10005                      it is a copy of a linkonce section or due to
10006                      linker script /DISCARD/, so we'll be discarding
10007                      the relocs too.  */
10008                 }
10009               else if (p->count != 0)
10010                 {
10011                   asection *srel = elf_section_data (p->sec)->sreloc;
10012                   if (p->ifunc)
10013                     srel = htab->elf.irelplt;
10014                   srel->size += p->count * sizeof (Elf64_External_Rela);
10015                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
10016                     info->flags |= DF_TEXTREL;
10017                 }
10018             }
10019         }
10020
10021       lgot_ents = elf_local_got_ents (ibfd);
10022       if (!lgot_ents)
10023         continue;
10024
10025       symtab_hdr = &elf_symtab_hdr (ibfd);
10026       locsymcount = symtab_hdr->sh_info;
10027       end_lgot_ents = lgot_ents + locsymcount;
10028       local_plt = (struct plt_entry **) end_lgot_ents;
10029       end_local_plt = local_plt + locsymcount;
10030       lgot_masks = (unsigned char *) end_local_plt;
10031       s = ppc64_elf_tdata (ibfd)->got;
10032       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
10033         {
10034           struct got_entry **pent, *ent;
10035
10036           pent = lgot_ents;
10037           while ((ent = *pent) != NULL)
10038             if (ent->got.refcount > 0)
10039               {
10040                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
10041                   {
10042                     ppc64_tlsld_got (ibfd)->got.refcount += 1;
10043                     *pent = ent->next;
10044                   }
10045                 else
10046                   {
10047                     unsigned int ent_size = 8;
10048                     unsigned int rel_size = sizeof (Elf64_External_Rela);
10049
10050                     ent->got.offset = s->size;
10051                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
10052                       {
10053                         ent_size *= 2;
10054                         rel_size *= 2;
10055                       }
10056                     s->size += ent_size;
10057                     if ((*lgot_masks & PLT_IFUNC) != 0)
10058                       {
10059                         htab->elf.irelplt->size += rel_size;
10060                         htab->got_reli_size += rel_size;
10061                       }
10062                     else if (bfd_link_pic (info))
10063                       {
10064                         asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10065                         srel->size += rel_size;
10066                       }
10067                     pent = &ent->next;
10068                   }
10069               }
10070             else
10071               *pent = ent->next;
10072         }
10073
10074       /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt.  */
10075       for (; local_plt < end_local_plt; ++local_plt)
10076         {
10077           struct plt_entry *ent;
10078
10079           for (ent = *local_plt; ent != NULL; ent = ent->next)
10080             if (ent->plt.refcount > 0)
10081               {
10082                 s = htab->elf.iplt;
10083                 ent->plt.offset = s->size;
10084                 s->size += PLT_ENTRY_SIZE (htab);
10085
10086                 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
10087               }
10088             else
10089               ent->plt.offset = (bfd_vma) -1;
10090         }
10091     }
10092
10093   /* Allocate global sym .plt and .got entries, and space for global
10094      sym dynamic relocs.  */
10095   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
10096   /* Stash the end of glink branch table.  */
10097   if (htab->glink != NULL)
10098     htab->glink->rawsize = htab->glink->size;
10099
10100   if (!htab->opd_abi && !bfd_link_pic (info))
10101     elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
10102
10103   first_tlsld = NULL;
10104   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10105     {
10106       struct got_entry *ent;
10107
10108       if (!is_ppc64_elf (ibfd))
10109         continue;
10110
10111       ent = ppc64_tlsld_got (ibfd);
10112       if (ent->got.refcount > 0)
10113         {
10114           if (!htab->do_multi_toc && first_tlsld != NULL)
10115             {
10116               ent->is_indirect = TRUE;
10117               ent->got.ent = first_tlsld;
10118             }
10119           else
10120             {
10121               if (first_tlsld == NULL)
10122                 first_tlsld = ent;
10123               s = ppc64_elf_tdata (ibfd)->got;
10124               ent->got.offset = s->size;
10125               ent->owner = ibfd;
10126               s->size += 16;
10127               if (bfd_link_pic (info))
10128                 {
10129                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10130                   srel->size += sizeof (Elf64_External_Rela);
10131                 }
10132             }
10133         }
10134       else
10135         ent->got.offset = (bfd_vma) -1;
10136     }
10137
10138   /* We now have determined the sizes of the various dynamic sections.
10139      Allocate memory for them.  */
10140   relocs = FALSE;
10141   for (s = dynobj->sections; s != NULL; s = s->next)
10142     {
10143       if ((s->flags & SEC_LINKER_CREATED) == 0)
10144         continue;
10145
10146       if (s == htab->brlt || s == htab->relbrlt)
10147         /* These haven't been allocated yet;  don't strip.  */
10148         continue;
10149       else if (s == htab->elf.sgot
10150                || s == htab->elf.splt
10151                || s == htab->elf.iplt
10152                || s == htab->glink
10153                || s == htab->dynbss)
10154         {
10155           /* Strip this section if we don't need it; see the
10156              comment below.  */
10157         }
10158       else if (s == htab->glink_eh_frame)
10159         {
10160           if (!bfd_is_abs_section (s->output_section))
10161             /* Not sized yet.  */
10162             continue;
10163         }
10164       else if (CONST_STRNEQ (s->name, ".rela"))
10165         {
10166           if (s->size != 0)
10167             {
10168               if (s != htab->elf.srelplt)
10169                 relocs = TRUE;
10170
10171               /* We use the reloc_count field as a counter if we need
10172                  to copy relocs into the output file.  */
10173               s->reloc_count = 0;
10174             }
10175         }
10176       else
10177         {
10178           /* It's not one of our sections, so don't allocate space.  */
10179           continue;
10180         }
10181
10182       if (s->size == 0)
10183         {
10184           /* If we don't need this section, strip it from the
10185              output file.  This is mostly to handle .rela.bss and
10186              .rela.plt.  We must create both sections in
10187              create_dynamic_sections, because they must be created
10188              before the linker maps input sections to output
10189              sections.  The linker does that before
10190              adjust_dynamic_symbol is called, and it is that
10191              function which decides whether anything needs to go
10192              into these sections.  */
10193           s->flags |= SEC_EXCLUDE;
10194           continue;
10195         }
10196
10197       if ((s->flags & SEC_HAS_CONTENTS) == 0)
10198         continue;
10199
10200       /* Allocate memory for the section contents.  We use bfd_zalloc
10201          here in case unused entries are not reclaimed before the
10202          section's contents are written out.  This should not happen,
10203          but this way if it does we get a R_PPC64_NONE reloc in .rela
10204          sections instead of garbage.
10205          We also rely on the section contents being zero when writing
10206          the GOT.  */
10207       s->contents = bfd_zalloc (dynobj, s->size);
10208       if (s->contents == NULL)
10209         return FALSE;
10210     }
10211
10212   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10213     {
10214       if (!is_ppc64_elf (ibfd))
10215         continue;
10216
10217       s = ppc64_elf_tdata (ibfd)->got;
10218       if (s != NULL && s != htab->elf.sgot)
10219         {
10220           if (s->size == 0)
10221             s->flags |= SEC_EXCLUDE;
10222           else
10223             {
10224               s->contents = bfd_zalloc (ibfd, s->size);
10225               if (s->contents == NULL)
10226                 return FALSE;
10227             }
10228         }
10229       s = ppc64_elf_tdata (ibfd)->relgot;
10230       if (s != NULL)
10231         {
10232           if (s->size == 0)
10233             s->flags |= SEC_EXCLUDE;
10234           else
10235             {
10236               s->contents = bfd_zalloc (ibfd, s->size);
10237               if (s->contents == NULL)
10238                 return FALSE;
10239               relocs = TRUE;
10240               s->reloc_count = 0;
10241             }
10242         }
10243     }
10244
10245   if (htab->elf.dynamic_sections_created)
10246     {
10247       bfd_boolean tls_opt;
10248
10249       /* Add some entries to the .dynamic section.  We fill in the
10250          values later, in ppc64_elf_finish_dynamic_sections, but we
10251          must add the entries now so that we get the correct size for
10252          the .dynamic section.  The DT_DEBUG entry is filled in by the
10253          dynamic linker and used by the debugger.  */
10254 #define add_dynamic_entry(TAG, VAL) \
10255   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10256
10257       if (bfd_link_executable (info))
10258         {
10259           if (!add_dynamic_entry (DT_DEBUG, 0))
10260             return FALSE;
10261         }
10262
10263       if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
10264         {
10265           if (!add_dynamic_entry (DT_PLTGOT, 0)
10266               || !add_dynamic_entry (DT_PLTRELSZ, 0)
10267               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
10268               || !add_dynamic_entry (DT_JMPREL, 0)
10269               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
10270             return FALSE;
10271         }
10272
10273       if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
10274         {
10275           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
10276               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
10277             return FALSE;
10278         }
10279
10280       tls_opt = (htab->params->tls_get_addr_opt
10281                  && htab->tls_get_addr_fd != NULL
10282                  && htab->tls_get_addr_fd->elf.plt.plist != NULL);
10283       if (tls_opt || !htab->opd_abi)
10284         {
10285           if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
10286             return FALSE;
10287         }
10288
10289       if (relocs)
10290         {
10291           if (!add_dynamic_entry (DT_RELA, 0)
10292               || !add_dynamic_entry (DT_RELASZ, 0)
10293               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
10294             return FALSE;
10295
10296           /* If any dynamic relocs apply to a read-only section,
10297              then we need a DT_TEXTREL entry.  */
10298           if ((info->flags & DF_TEXTREL) == 0)
10299             elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
10300
10301           if ((info->flags & DF_TEXTREL) != 0)
10302             {
10303               if (!add_dynamic_entry (DT_TEXTREL, 0))
10304                 return FALSE;
10305             }
10306         }
10307     }
10308 #undef add_dynamic_entry
10309
10310   return TRUE;
10311 }
10312
10313 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
10314
10315 static bfd_boolean
10316 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
10317 {
10318   if (h->plt.plist != NULL
10319       && !h->def_regular
10320       && !h->pointer_equality_needed)
10321     return FALSE;
10322
10323   return _bfd_elf_hash_symbol (h);
10324 }
10325
10326 /* Determine the type of stub needed, if any, for a call.  */
10327
10328 static inline enum ppc_stub_type
10329 ppc_type_of_stub (asection *input_sec,
10330                   const Elf_Internal_Rela *rel,
10331                   struct ppc_link_hash_entry **hash,
10332                   struct plt_entry **plt_ent,
10333                   bfd_vma destination,
10334                   unsigned long local_off)
10335 {
10336   struct ppc_link_hash_entry *h = *hash;
10337   bfd_vma location;
10338   bfd_vma branch_offset;
10339   bfd_vma max_branch_offset;
10340   enum elf_ppc64_reloc_type r_type;
10341
10342   if (h != NULL)
10343     {
10344       struct plt_entry *ent;
10345       struct ppc_link_hash_entry *fdh = h;
10346       if (h->oh != NULL
10347           && h->oh->is_func_descriptor)
10348         {
10349           fdh = ppc_follow_link (h->oh);
10350           *hash = fdh;
10351         }
10352
10353       for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10354         if (ent->addend == rel->r_addend
10355             && ent->plt.offset != (bfd_vma) -1)
10356           {
10357             *plt_ent = ent;
10358             return ppc_stub_plt_call;
10359           }
10360
10361       /* Here, we know we don't have a plt entry.  If we don't have a
10362          either a defined function descriptor or a defined entry symbol
10363          in a regular object file, then it is pointless trying to make
10364          any other type of stub.  */
10365       if (!is_static_defined (&fdh->elf)
10366           && !is_static_defined (&h->elf))
10367         return ppc_stub_none;
10368     }
10369   else if (elf_local_got_ents (input_sec->owner) != NULL)
10370     {
10371       Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10372       struct plt_entry **local_plt = (struct plt_entry **)
10373         elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10374       unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10375
10376       if (local_plt[r_symndx] != NULL)
10377         {
10378           struct plt_entry *ent;
10379
10380           for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10381             if (ent->addend == rel->r_addend
10382                 && ent->plt.offset != (bfd_vma) -1)
10383               {
10384                 *plt_ent = ent;
10385                 return ppc_stub_plt_call;
10386               }
10387         }
10388     }
10389
10390   /* Determine where the call point is.  */
10391   location = (input_sec->output_offset
10392               + input_sec->output_section->vma
10393               + rel->r_offset);
10394
10395   branch_offset = destination - location;
10396   r_type = ELF64_R_TYPE (rel->r_info);
10397
10398   /* Determine if a long branch stub is needed.  */
10399   max_branch_offset = 1 << 25;
10400   if (r_type != R_PPC64_REL24)
10401     max_branch_offset = 1 << 15;
10402
10403   if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10404     /* We need a stub.  Figure out whether a long_branch or plt_branch
10405        is needed later.  */
10406     return ppc_stub_long_branch;
10407
10408   return ppc_stub_none;
10409 }
10410
10411 /* With power7 weakly ordered memory model, it is possible for ld.so
10412    to update a plt entry in one thread and have another thread see a
10413    stale zero toc entry.  To avoid this we need some sort of acquire
10414    barrier in the call stub.  One solution is to make the load of the
10415    toc word seem to appear to depend on the load of the function entry
10416    word.  Another solution is to test for r2 being zero, and branch to
10417    the appropriate glink entry if so.
10418
10419    .    fake dep barrier        compare
10420    .    ld 12,xxx(2)            ld 12,xxx(2)
10421    .    mtctr 12                mtctr 12
10422    .    xor 11,12,12            ld 2,xxx+8(2)
10423    .    add 2,2,11              cmpldi 2,0
10424    .    ld 2,xxx+8(2)           bnectr+
10425    .    bctr                    b <glink_entry>
10426
10427    The solution involving the compare turns out to be faster, so
10428    that's what we use unless the branch won't reach.  */
10429
10430 #define ALWAYS_USE_FAKE_DEP 0
10431 #define ALWAYS_EMIT_R2SAVE 0
10432
10433 #define PPC_LO(v) ((v) & 0xffff)
10434 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10435 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10436
10437 static inline unsigned int
10438 plt_stub_size (struct ppc_link_hash_table *htab,
10439                struct ppc_stub_hash_entry *stub_entry,
10440                bfd_vma off)
10441 {
10442   unsigned size = 12;
10443
10444   if (ALWAYS_EMIT_R2SAVE
10445       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10446     size += 4;
10447   if (PPC_HA (off) != 0)
10448     size += 4;
10449   if (htab->opd_abi)
10450     {
10451       size += 4;
10452       if (htab->params->plt_static_chain)
10453         size += 4;
10454       if (htab->params->plt_thread_safe
10455           && htab->elf.dynamic_sections_created
10456           && stub_entry->h != NULL
10457           && stub_entry->h->elf.dynindx != -1)
10458         size += 8;
10459       if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
10460         size += 4;
10461     }
10462   if (stub_entry->h != NULL
10463       && (stub_entry->h == htab->tls_get_addr_fd
10464           || stub_entry->h == htab->tls_get_addr)
10465       && htab->params->tls_get_addr_opt)
10466     size += 13 * 4;
10467   return size;
10468 }
10469
10470 /* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
10471    then return the padding needed to do so.  */
10472 static inline unsigned int
10473 plt_stub_pad (struct ppc_link_hash_table *htab,
10474               struct ppc_stub_hash_entry *stub_entry,
10475               bfd_vma plt_off)
10476 {
10477   int stub_align = 1 << htab->params->plt_stub_align;
10478   unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10479   bfd_vma stub_off = stub_entry->group->stub_sec->size;
10480
10481   if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10482       > ((stub_size - 1) & -stub_align))
10483     return stub_align - (stub_off & (stub_align - 1));
10484   return 0;
10485 }
10486
10487 /* Build a .plt call stub.  */
10488
10489 static inline bfd_byte *
10490 build_plt_stub (struct ppc_link_hash_table *htab,
10491                 struct ppc_stub_hash_entry *stub_entry,
10492                 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10493 {
10494   bfd *obfd = htab->params->stub_bfd;
10495   bfd_boolean plt_load_toc = htab->opd_abi;
10496   bfd_boolean plt_static_chain = htab->params->plt_static_chain;
10497   bfd_boolean plt_thread_safe = (htab->params->plt_thread_safe
10498                                  && htab->elf.dynamic_sections_created
10499                                  && stub_entry->h != NULL
10500                                  && stub_entry->h->elf.dynindx != -1);
10501   bfd_boolean use_fake_dep = plt_thread_safe;
10502   bfd_vma cmp_branch_off = 0;
10503
10504   if (!ALWAYS_USE_FAKE_DEP
10505       && plt_load_toc
10506       && plt_thread_safe
10507       && !((stub_entry->h == htab->tls_get_addr_fd
10508             || stub_entry->h == htab->tls_get_addr)
10509            && htab->params->tls_get_addr_opt))
10510     {
10511       bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10512       bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10513                           / PLT_ENTRY_SIZE (htab));
10514       bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10515       bfd_vma to, from;
10516
10517       if (pltindex > 32768)
10518         glinkoff += (pltindex - 32768) * 4;
10519       to = (glinkoff
10520             + htab->glink->output_offset
10521             + htab->glink->output_section->vma);
10522       from = (p - stub_entry->group->stub_sec->contents
10523               + 4 * (ALWAYS_EMIT_R2SAVE
10524                      || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10525               + 4 * (PPC_HA (offset) != 0)
10526               + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10527                      != PPC_HA (offset))
10528               + 4 * (plt_static_chain != 0)
10529               + 20
10530               + stub_entry->group->stub_sec->output_offset
10531               + stub_entry->group->stub_sec->output_section->vma);
10532       cmp_branch_off = to - from;
10533       use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10534     }
10535
10536   if (PPC_HA (offset) != 0)
10537     {
10538       if (r != NULL)
10539         {
10540           if (ALWAYS_EMIT_R2SAVE
10541               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10542             r[0].r_offset += 4;
10543           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10544           r[1].r_offset = r[0].r_offset + 4;
10545           r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10546           r[1].r_addend = r[0].r_addend;
10547           if (plt_load_toc)
10548             {
10549               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10550                 {
10551                   r[2].r_offset = r[1].r_offset + 4;
10552                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10553                   r[2].r_addend = r[0].r_addend;
10554                 }
10555               else
10556                 {
10557                   r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10558                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10559                   r[2].r_addend = r[0].r_addend + 8;
10560                   if (plt_static_chain)
10561                     {
10562                       r[3].r_offset = r[2].r_offset + 4;
10563                       r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10564                       r[3].r_addend = r[0].r_addend + 16;
10565                     }
10566                 }
10567             }
10568         }
10569       if (ALWAYS_EMIT_R2SAVE
10570           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10571         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10572       if (plt_load_toc)
10573         {
10574           bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10575           bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p),  p += 4;
10576         }
10577       else
10578         {
10579           bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
10580           bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p),  p += 4;
10581         }
10582       if (plt_load_toc
10583           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10584         {
10585           bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10586           offset = 0;
10587         }
10588       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10589       if (plt_load_toc)
10590         {
10591           if (use_fake_dep)
10592             {
10593               bfd_put_32 (obfd, XOR_R2_R12_R12, p),             p += 4;
10594               bfd_put_32 (obfd, ADD_R11_R11_R2, p),             p += 4;
10595             }
10596           bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10597           if (plt_static_chain)
10598             bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10599         }
10600     }
10601   else
10602     {
10603       if (r != NULL)
10604         {
10605           if (ALWAYS_EMIT_R2SAVE
10606               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10607             r[0].r_offset += 4;
10608           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10609           if (plt_load_toc)
10610             {
10611               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10612                 {
10613                   r[1].r_offset = r[0].r_offset + 4;
10614                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10615                   r[1].r_addend = r[0].r_addend;
10616                 }
10617               else
10618                 {
10619                   r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10620                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10621                   r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10622                   if (plt_static_chain)
10623                     {
10624                       r[2].r_offset = r[1].r_offset + 4;
10625                       r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10626                       r[2].r_addend = r[0].r_addend + 8;
10627                     }
10628                 }
10629             }
10630         }
10631       if (ALWAYS_EMIT_R2SAVE
10632           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10633         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10634       bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p),       p += 4;
10635       if (plt_load_toc
10636           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10637         {
10638           bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),   p += 4;
10639           offset = 0;
10640         }
10641       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10642       if (plt_load_toc)
10643         {
10644           if (use_fake_dep)
10645             {
10646               bfd_put_32 (obfd, XOR_R11_R12_R12, p),            p += 4;
10647               bfd_put_32 (obfd, ADD_R2_R2_R11, p),              p += 4;
10648             }
10649           if (plt_static_chain)
10650             bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10651           bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10652         }
10653     }
10654   if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10655     {
10656       bfd_put_32 (obfd, CMPLDI_R2_0, p),                        p += 4;
10657       bfd_put_32 (obfd, BNECTR_P4, p),                          p += 4;
10658       bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10659     }
10660   else
10661     bfd_put_32 (obfd, BCTR, p),                                 p += 4;
10662   return p;
10663 }
10664
10665 /* Build a special .plt call stub for __tls_get_addr.  */
10666
10667 #define LD_R11_0R3      0xe9630000
10668 #define LD_R12_0R3      0xe9830000
10669 #define MR_R0_R3        0x7c601b78
10670 #define CMPDI_R11_0     0x2c2b0000
10671 #define ADD_R3_R12_R13  0x7c6c6a14
10672 #define BEQLR           0x4d820020
10673 #define MR_R3_R0        0x7c030378
10674 #define STD_R11_0R1     0xf9610000
10675 #define BCTRL           0x4e800421
10676 #define LD_R11_0R1      0xe9610000
10677 #define MTLR_R11        0x7d6803a6
10678
10679 static inline bfd_byte *
10680 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10681                          struct ppc_stub_hash_entry *stub_entry,
10682                          bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10683 {
10684   bfd *obfd = htab->params->stub_bfd;
10685
10686   bfd_put_32 (obfd, LD_R11_0R3 + 0, p),         p += 4;
10687   bfd_put_32 (obfd, LD_R12_0R3 + 8, p),         p += 4;
10688   bfd_put_32 (obfd, MR_R0_R3, p),               p += 4;
10689   bfd_put_32 (obfd, CMPDI_R11_0, p),            p += 4;
10690   bfd_put_32 (obfd, ADD_R3_R12_R13, p),         p += 4;
10691   bfd_put_32 (obfd, BEQLR, p),                  p += 4;
10692   bfd_put_32 (obfd, MR_R3_R0, p),               p += 4;
10693   bfd_put_32 (obfd, MFLR_R11, p),               p += 4;
10694   bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10695
10696   if (r != NULL)
10697     r[0].r_offset += 9 * 4;
10698   p = build_plt_stub (htab, stub_entry, p, offset, r);
10699   bfd_put_32 (obfd, BCTRL, p - 4);
10700
10701   bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p),     p += 4;
10702   bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10703   bfd_put_32 (obfd, MTLR_R11, p),               p += 4;
10704   bfd_put_32 (obfd, BLR, p),                    p += 4;
10705
10706   return p;
10707 }
10708
10709 static Elf_Internal_Rela *
10710 get_relocs (asection *sec, int count)
10711 {
10712   Elf_Internal_Rela *relocs;
10713   struct bfd_elf_section_data *elfsec_data;
10714
10715   elfsec_data = elf_section_data (sec);
10716   relocs = elfsec_data->relocs;
10717   if (relocs == NULL)
10718     {
10719       bfd_size_type relsize;
10720       relsize = sec->reloc_count * sizeof (*relocs);
10721       relocs = bfd_alloc (sec->owner, relsize);
10722       if (relocs == NULL)
10723         return NULL;
10724       elfsec_data->relocs = relocs;
10725       elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10726                                           sizeof (Elf_Internal_Shdr));
10727       if (elfsec_data->rela.hdr == NULL)
10728         return NULL;
10729       elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10730                                         * sizeof (Elf64_External_Rela));
10731       elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10732       sec->reloc_count = 0;
10733     }
10734   relocs += sec->reloc_count;
10735   sec->reloc_count += count;
10736   return relocs;
10737 }
10738
10739 static bfd_vma
10740 get_r2off (struct bfd_link_info *info,
10741            struct ppc_stub_hash_entry *stub_entry)
10742 {
10743   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10744   bfd_vma r2off = htab->sec_info[stub_entry->target_section->id].toc_off;
10745
10746   if (r2off == 0)
10747     {
10748       /* Support linking -R objects.  Get the toc pointer from the
10749          opd entry.  */
10750       char buf[8];
10751       if (!htab->opd_abi)
10752         return r2off;
10753       asection *opd = stub_entry->h->elf.root.u.def.section;
10754       bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10755
10756       if (strcmp (opd->name, ".opd") != 0
10757           || opd->reloc_count != 0)
10758         {
10759           info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
10760                                   stub_entry->h->elf.root.root.string);
10761           bfd_set_error (bfd_error_bad_value);
10762           return (bfd_vma) -1;
10763         }
10764       if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10765         return (bfd_vma) -1;
10766       r2off = bfd_get_64 (opd->owner, buf);
10767       r2off -= elf_gp (info->output_bfd);
10768     }
10769   r2off -= htab->sec_info[stub_entry->group->link_sec->id].toc_off;
10770   return r2off;
10771 }
10772
10773 static bfd_boolean
10774 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10775 {
10776   struct ppc_stub_hash_entry *stub_entry;
10777   struct ppc_branch_hash_entry *br_entry;
10778   struct bfd_link_info *info;
10779   struct ppc_link_hash_table *htab;
10780   bfd_byte *loc;
10781   bfd_byte *p;
10782   bfd_vma dest, off;
10783   int size;
10784   Elf_Internal_Rela *r;
10785   asection *plt;
10786
10787   /* Massage our args to the form they really have.  */
10788   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10789   info = in_arg;
10790
10791   htab = ppc_hash_table (info);
10792   if (htab == NULL)
10793     return FALSE;
10794
10795   /* Make a note of the offset within the stubs for this entry.  */
10796   stub_entry->stub_offset = stub_entry->group->stub_sec->size;
10797   loc = stub_entry->group->stub_sec->contents + stub_entry->stub_offset;
10798
10799   htab->stub_count[stub_entry->stub_type - 1] += 1;
10800   switch (stub_entry->stub_type)
10801     {
10802     case ppc_stub_long_branch:
10803     case ppc_stub_long_branch_r2off:
10804       /* Branches are relative.  This is where we are going to.  */
10805       dest = (stub_entry->target_value
10806               + stub_entry->target_section->output_offset
10807               + stub_entry->target_section->output_section->vma);
10808       dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10809       off = dest;
10810
10811       /* And this is where we are coming from.  */
10812       off -= (stub_entry->stub_offset
10813               + stub_entry->group->stub_sec->output_offset
10814               + stub_entry->group->stub_sec->output_section->vma);
10815
10816       size = 4;
10817       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10818         {
10819           bfd_vma r2off = get_r2off (info, stub_entry);
10820
10821           if (r2off == (bfd_vma) -1)
10822             {
10823               htab->stub_error = TRUE;
10824               return FALSE;
10825             }
10826           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10827           loc += 4;
10828           size = 8;
10829           if (PPC_HA (r2off) != 0)
10830             {
10831               bfd_put_32 (htab->params->stub_bfd,
10832                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
10833               loc += 4;
10834               size += 4;
10835             }
10836           if (PPC_LO (r2off) != 0)
10837             {
10838               bfd_put_32 (htab->params->stub_bfd,
10839                           ADDI_R2_R2 | PPC_LO (r2off), loc);
10840               loc += 4;
10841               size += 4;
10842             }
10843           off -= size - 4;
10844         }
10845       bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10846
10847       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10848         {
10849           info->callbacks->einfo
10850             (_("%P: long branch stub `%s' offset overflow\n"),
10851              stub_entry->root.string);
10852           htab->stub_error = TRUE;
10853           return FALSE;
10854         }
10855
10856       if (info->emitrelocations)
10857         {
10858           r = get_relocs (stub_entry->group->stub_sec, 1);
10859           if (r == NULL)
10860             return FALSE;
10861           r->r_offset = loc - stub_entry->group->stub_sec->contents;
10862           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10863           r->r_addend = dest;
10864           if (stub_entry->h != NULL)
10865             {
10866               struct elf_link_hash_entry **hashes;
10867               unsigned long symndx;
10868               struct ppc_link_hash_entry *h;
10869
10870               hashes = elf_sym_hashes (htab->params->stub_bfd);
10871               if (hashes == NULL)
10872                 {
10873                   bfd_size_type hsize;
10874
10875                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10876                   hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
10877                   if (hashes == NULL)
10878                     return FALSE;
10879                   elf_sym_hashes (htab->params->stub_bfd) = hashes;
10880                   htab->stub_globals = 1;
10881                 }
10882               symndx = htab->stub_globals++;
10883               h = stub_entry->h;
10884               hashes[symndx] = &h->elf;
10885               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10886               if (h->oh != NULL && h->oh->is_func)
10887                 h = ppc_follow_link (h->oh);
10888               if (h->elf.root.u.def.section != stub_entry->target_section)
10889                 /* H is an opd symbol.  The addend must be zero.  */
10890                 r->r_addend = 0;
10891               else
10892                 {
10893                   off = (h->elf.root.u.def.value
10894                          + h->elf.root.u.def.section->output_offset
10895                          + h->elf.root.u.def.section->output_section->vma);
10896                   r->r_addend -= off;
10897                 }
10898             }
10899         }
10900       break;
10901
10902     case ppc_stub_plt_branch:
10903     case ppc_stub_plt_branch_r2off:
10904       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10905                                          stub_entry->root.string + 9,
10906                                          FALSE, FALSE);
10907       if (br_entry == NULL)
10908         {
10909           info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
10910                                   stub_entry->root.string);
10911           htab->stub_error = TRUE;
10912           return FALSE;
10913         }
10914
10915       dest = (stub_entry->target_value
10916               + stub_entry->target_section->output_offset
10917               + stub_entry->target_section->output_section->vma);
10918       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10919         dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10920
10921       bfd_put_64 (htab->brlt->owner, dest,
10922                   htab->brlt->contents + br_entry->offset);
10923
10924       if (br_entry->iter == htab->stub_iteration)
10925         {
10926           br_entry->iter = 0;
10927
10928           if (htab->relbrlt != NULL)
10929             {
10930               /* Create a reloc for the branch lookup table entry.  */
10931               Elf_Internal_Rela rela;
10932               bfd_byte *rl;
10933
10934               rela.r_offset = (br_entry->offset
10935                                + htab->brlt->output_offset
10936                                + htab->brlt->output_section->vma);
10937               rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10938               rela.r_addend = dest;
10939
10940               rl = htab->relbrlt->contents;
10941               rl += (htab->relbrlt->reloc_count++
10942                      * sizeof (Elf64_External_Rela));
10943               bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
10944             }
10945           else if (info->emitrelocations)
10946             {
10947               r = get_relocs (htab->brlt, 1);
10948               if (r == NULL)
10949                 return FALSE;
10950               /* brlt, being SEC_LINKER_CREATED does not go through the
10951                  normal reloc processing.  Symbols and offsets are not
10952                  translated from input file to output file form, so
10953                  set up the offset per the output file.  */
10954               r->r_offset = (br_entry->offset
10955                              + htab->brlt->output_offset
10956                              + htab->brlt->output_section->vma);
10957               r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10958               r->r_addend = dest;
10959             }
10960         }
10961
10962       dest = (br_entry->offset
10963               + htab->brlt->output_offset
10964               + htab->brlt->output_section->vma);
10965
10966       off = (dest
10967              - elf_gp (htab->brlt->output_section->owner)
10968              - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
10969
10970       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10971         {
10972           info->callbacks->einfo
10973             (_("%P: linkage table error against `%T'\n"),
10974              stub_entry->root.string);
10975           bfd_set_error (bfd_error_bad_value);
10976           htab->stub_error = TRUE;
10977           return FALSE;
10978         }
10979
10980       if (info->emitrelocations)
10981         {
10982           r = get_relocs (stub_entry->group->stub_sec, 1 + (PPC_HA (off) != 0));
10983           if (r == NULL)
10984             return FALSE;
10985           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
10986           if (bfd_big_endian (info->output_bfd))
10987             r[0].r_offset += 2;
10988           if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
10989             r[0].r_offset += 4;
10990           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10991           r[0].r_addend = dest;
10992           if (PPC_HA (off) != 0)
10993             {
10994               r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10995               r[1].r_offset = r[0].r_offset + 4;
10996               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10997               r[1].r_addend = r[0].r_addend;
10998             }
10999         }
11000
11001       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11002         {
11003           if (PPC_HA (off) != 0)
11004             {
11005               size = 16;
11006               bfd_put_32 (htab->params->stub_bfd,
11007                           ADDIS_R12_R2 | PPC_HA (off), loc);
11008               loc += 4;
11009               bfd_put_32 (htab->params->stub_bfd,
11010                           LD_R12_0R12 | PPC_LO (off), loc);
11011             }
11012           else
11013             {
11014               size = 12;
11015               bfd_put_32 (htab->params->stub_bfd,
11016                           LD_R12_0R2 | PPC_LO (off), loc);
11017             }
11018         }
11019       else
11020         {
11021           bfd_vma r2off = get_r2off (info, stub_entry);
11022
11023           if (r2off == (bfd_vma) -1)
11024             {
11025               htab->stub_error = TRUE;
11026               return FALSE;
11027             }
11028
11029           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
11030           loc += 4;
11031           size = 16;
11032           if (PPC_HA (off) != 0)
11033             {
11034               size += 4;
11035               bfd_put_32 (htab->params->stub_bfd,
11036                           ADDIS_R12_R2 | PPC_HA (off), loc);
11037               loc += 4;
11038               bfd_put_32 (htab->params->stub_bfd,
11039                           LD_R12_0R12 | PPC_LO (off), loc);
11040             }
11041           else
11042             bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
11043
11044           if (PPC_HA (r2off) != 0)
11045             {
11046               size += 4;
11047               loc += 4;
11048               bfd_put_32 (htab->params->stub_bfd,
11049                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
11050             }
11051           if (PPC_LO (r2off) != 0)
11052             {
11053               size += 4;
11054               loc += 4;
11055               bfd_put_32 (htab->params->stub_bfd,
11056                           ADDI_R2_R2 | PPC_LO (r2off), loc);
11057             }
11058         }
11059       loc += 4;
11060       bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, loc);
11061       loc += 4;
11062       bfd_put_32 (htab->params->stub_bfd, BCTR, loc);
11063       break;
11064
11065     case ppc_stub_plt_call:
11066     case ppc_stub_plt_call_r2save:
11067       if (stub_entry->h != NULL
11068           && stub_entry->h->is_func_descriptor
11069           && stub_entry->h->oh != NULL)
11070         {
11071           struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
11072
11073           /* If the old-ABI "dot-symbol" is undefined make it weak so
11074              we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.  */
11075           if (fh->elf.root.type == bfd_link_hash_undefined)
11076             fh->elf.root.type = bfd_link_hash_undefweak;
11077           /* Stop undo_symbol_twiddle changing it back to undefined.  */
11078           fh->was_undefined = 0;
11079         }
11080
11081       /* Now build the stub.  */
11082       dest = stub_entry->plt_ent->plt.offset & ~1;
11083       if (dest >= (bfd_vma) -2)
11084         abort ();
11085
11086       plt = htab->elf.splt;
11087       if (!htab->elf.dynamic_sections_created
11088           || stub_entry->h == NULL
11089           || stub_entry->h->elf.dynindx == -1)
11090         plt = htab->elf.iplt;
11091
11092       dest += plt->output_offset + plt->output_section->vma;
11093
11094       if (stub_entry->h == NULL
11095           && (stub_entry->plt_ent->plt.offset & 1) == 0)
11096         {
11097           Elf_Internal_Rela rela;
11098           bfd_byte *rl;
11099
11100           rela.r_offset = dest;
11101           if (htab->opd_abi)
11102             rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
11103           else
11104             rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
11105           rela.r_addend = (stub_entry->target_value
11106                            + stub_entry->target_section->output_offset
11107                            + stub_entry->target_section->output_section->vma);
11108
11109           rl = (htab->elf.irelplt->contents
11110                 + (htab->elf.irelplt->reloc_count++
11111                    * sizeof (Elf64_External_Rela)));
11112           bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
11113           stub_entry->plt_ent->plt.offset |= 1;
11114         }
11115
11116       off = (dest
11117              - elf_gp (plt->output_section->owner)
11118              - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11119
11120       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11121         {
11122           info->callbacks->einfo
11123             (_("%P: linkage table error against `%T'\n"),
11124              stub_entry->h != NULL
11125              ? stub_entry->h->elf.root.root.string
11126              : "<local sym>");
11127           bfd_set_error (bfd_error_bad_value);
11128           htab->stub_error = TRUE;
11129           return FALSE;
11130         }
11131
11132       if (htab->params->plt_stub_align != 0)
11133         {
11134           unsigned pad = plt_stub_pad (htab, stub_entry, off);
11135
11136           stub_entry->group->stub_sec->size += pad;
11137           stub_entry->stub_offset = stub_entry->group->stub_sec->size;
11138           loc += pad;
11139         }
11140
11141       r = NULL;
11142       if (info->emitrelocations)
11143         {
11144           r = get_relocs (stub_entry->group->stub_sec,
11145                           ((PPC_HA (off) != 0)
11146                            + (htab->opd_abi
11147                               ? 2 + (htab->params->plt_static_chain
11148                                      && PPC_HA (off + 16) == PPC_HA (off))
11149                               : 1)));
11150           if (r == NULL)
11151             return FALSE;
11152           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11153           if (bfd_big_endian (info->output_bfd))
11154             r[0].r_offset += 2;
11155           r[0].r_addend = dest;
11156         }
11157       if (stub_entry->h != NULL
11158           && (stub_entry->h == htab->tls_get_addr_fd
11159               || stub_entry->h == htab->tls_get_addr)
11160           && htab->params->tls_get_addr_opt)
11161         p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
11162       else
11163         p = build_plt_stub (htab, stub_entry, loc, off, r);
11164       size = p - loc;
11165       break;
11166
11167     case ppc_stub_save_res:
11168       return TRUE;
11169
11170     default:
11171       BFD_FAIL ();
11172       return FALSE;
11173     }
11174
11175   stub_entry->group->stub_sec->size += size;
11176
11177   if (htab->params->emit_stub_syms)
11178     {
11179       struct elf_link_hash_entry *h;
11180       size_t len1, len2;
11181       char *name;
11182       const char *const stub_str[] = { "long_branch",
11183                                        "long_branch_r2off",
11184                                        "plt_branch",
11185                                        "plt_branch_r2off",
11186                                        "plt_call",
11187                                        "plt_call" };
11188
11189       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
11190       len2 = strlen (stub_entry->root.string);
11191       name = bfd_malloc (len1 + len2 + 2);
11192       if (name == NULL)
11193         return FALSE;
11194       memcpy (name, stub_entry->root.string, 9);
11195       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
11196       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
11197       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
11198       if (h == NULL)
11199         return FALSE;
11200       if (h->root.type == bfd_link_hash_new)
11201         {
11202           h->root.type = bfd_link_hash_defined;
11203           h->root.u.def.section = stub_entry->group->stub_sec;
11204           h->root.u.def.value = stub_entry->stub_offset;
11205           h->ref_regular = 1;
11206           h->def_regular = 1;
11207           h->ref_regular_nonweak = 1;
11208           h->forced_local = 1;
11209           h->non_elf = 0;
11210           h->root.linker_def = 1;
11211         }
11212     }
11213
11214   return TRUE;
11215 }
11216
11217 /* As above, but don't actually build the stub.  Just bump offset so
11218    we know stub section sizes, and select plt_branch stubs where
11219    long_branch stubs won't do.  */
11220
11221 static bfd_boolean
11222 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11223 {
11224   struct ppc_stub_hash_entry *stub_entry;
11225   struct bfd_link_info *info;
11226   struct ppc_link_hash_table *htab;
11227   bfd_vma off;
11228   int size;
11229
11230   /* Massage our args to the form they really have.  */
11231   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11232   info = in_arg;
11233
11234   htab = ppc_hash_table (info);
11235   if (htab == NULL)
11236     return FALSE;
11237
11238   if (stub_entry->h != NULL
11239       && stub_entry->h->save_res
11240       && stub_entry->h->elf.root.type == bfd_link_hash_defined
11241       && stub_entry->h->elf.root.u.def.section == htab->sfpr)
11242     {
11243       /* Don't make stubs to out-of-line register save/restore
11244          functions.  Instead, emit copies of the functions.  */
11245       stub_entry->group->needs_save_res = 1;
11246       stub_entry->stub_type = ppc_stub_save_res;
11247       return TRUE;
11248     }
11249
11250   if (stub_entry->stub_type == ppc_stub_plt_call
11251       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11252     {
11253       asection *plt;
11254       off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
11255       if (off >= (bfd_vma) -2)
11256         abort ();
11257       plt = htab->elf.splt;
11258       if (!htab->elf.dynamic_sections_created
11259           || stub_entry->h == NULL
11260           || stub_entry->h->elf.dynindx == -1)
11261         plt = htab->elf.iplt;
11262       off += (plt->output_offset
11263               + plt->output_section->vma
11264               - elf_gp (plt->output_section->owner)
11265               - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11266
11267       size = plt_stub_size (htab, stub_entry, off);
11268       if (htab->params->plt_stub_align)
11269         size += plt_stub_pad (htab, stub_entry, off);
11270       if (info->emitrelocations)
11271         {
11272           stub_entry->group->stub_sec->reloc_count
11273             += ((PPC_HA (off) != 0)
11274                 + (htab->opd_abi
11275                    ? 2 + (htab->params->plt_static_chain
11276                           && PPC_HA (off + 16) == PPC_HA (off))
11277                    : 1));
11278           stub_entry->group->stub_sec->flags |= SEC_RELOC;
11279         }
11280     }
11281   else
11282     {
11283       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
11284          variants.  */
11285       bfd_vma r2off = 0;
11286       bfd_vma local_off = 0;
11287
11288       off = (stub_entry->target_value
11289              + stub_entry->target_section->output_offset
11290              + stub_entry->target_section->output_section->vma);
11291       off -= (stub_entry->group->stub_sec->size
11292               + stub_entry->group->stub_sec->output_offset
11293               + stub_entry->group->stub_sec->output_section->vma);
11294
11295       /* Reset the stub type from the plt variant in case we now
11296          can reach with a shorter stub.  */
11297       if (stub_entry->stub_type >= ppc_stub_plt_branch)
11298         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
11299
11300       size = 4;
11301       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11302         {
11303           r2off = get_r2off (info, stub_entry);
11304           if (r2off == (bfd_vma) -1)
11305             {
11306               htab->stub_error = TRUE;
11307               return FALSE;
11308             }
11309           size = 8;
11310           if (PPC_HA (r2off) != 0)
11311             size += 4;
11312           if (PPC_LO (r2off) != 0)
11313             size += 4;
11314           off -= size - 4;
11315         }
11316
11317       local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11318
11319       /* If the branch offset if too big, use a ppc_stub_plt_branch.
11320          Do the same for -R objects without function descriptors.  */
11321       if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
11322           || (stub_entry->stub_type == ppc_stub_long_branch_r2off
11323               && r2off == 0
11324               && htab->sec_info[stub_entry->target_section->id].toc_off == 0))
11325         {
11326           struct ppc_branch_hash_entry *br_entry;
11327
11328           br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11329                                              stub_entry->root.string + 9,
11330                                              TRUE, FALSE);
11331           if (br_entry == NULL)
11332             {
11333               info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
11334                                       stub_entry->root.string);
11335               htab->stub_error = TRUE;
11336               return FALSE;
11337             }
11338
11339           if (br_entry->iter != htab->stub_iteration)
11340             {
11341               br_entry->iter = htab->stub_iteration;
11342               br_entry->offset = htab->brlt->size;
11343               htab->brlt->size += 8;
11344
11345               if (htab->relbrlt != NULL)
11346                 htab->relbrlt->size += sizeof (Elf64_External_Rela);
11347               else if (info->emitrelocations)
11348                 {
11349                   htab->brlt->reloc_count += 1;
11350                   htab->brlt->flags |= SEC_RELOC;
11351                 }
11352             }
11353
11354           stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
11355           off = (br_entry->offset
11356                  + htab->brlt->output_offset
11357                  + htab->brlt->output_section->vma
11358                  - elf_gp (htab->brlt->output_section->owner)
11359                  - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11360
11361           if (info->emitrelocations)
11362             {
11363               stub_entry->group->stub_sec->reloc_count
11364                 += 1 + (PPC_HA (off) != 0);
11365               stub_entry->group->stub_sec->flags |= SEC_RELOC;
11366             }
11367
11368           if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11369             {
11370               size = 12;
11371               if (PPC_HA (off) != 0)
11372                 size = 16;
11373             }
11374           else
11375             {
11376               size = 16;
11377               if (PPC_HA (off) != 0)
11378                 size += 4;
11379
11380               if (PPC_HA (r2off) != 0)
11381                 size += 4;
11382               if (PPC_LO (r2off) != 0)
11383                 size += 4;
11384             }
11385         }
11386       else if (info->emitrelocations)
11387         {
11388           stub_entry->group->stub_sec->reloc_count += 1;
11389           stub_entry->group->stub_sec->flags |= SEC_RELOC;
11390         }
11391     }
11392
11393   stub_entry->group->stub_sec->size += size;
11394   return TRUE;
11395 }
11396
11397 /* Set up various things so that we can make a list of input sections
11398    for each output section included in the link.  Returns -1 on error,
11399    0 when no stubs will be needed, and 1 on success.  */
11400
11401 int
11402 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
11403 {
11404   unsigned int id;
11405   bfd_size_type amt;
11406   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11407
11408   if (htab == NULL)
11409     return -1;
11410
11411   htab->sec_info_arr_size = bfd_get_next_section_id ();
11412   amt = sizeof (*htab->sec_info) * (htab->sec_info_arr_size);
11413   htab->sec_info = bfd_zmalloc (amt);
11414   if (htab->sec_info == NULL)
11415     return -1;
11416
11417   /* Set toc_off for com, und, abs and ind sections.  */
11418   for (id = 0; id < 3; id++)
11419     htab->sec_info[id].toc_off = TOC_BASE_OFF;
11420
11421   return 1;
11422 }
11423
11424 /* Set up for first pass at multitoc partitioning.  */
11425
11426 void
11427 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11428 {
11429   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11430
11431   htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11432   htab->toc_bfd = NULL;
11433   htab->toc_first_sec = NULL;
11434 }
11435
11436 /* The linker repeatedly calls this function for each TOC input section
11437    and linker generated GOT section.  Group input bfds such that the toc
11438    within a group is less than 64k in size.  */
11439
11440 bfd_boolean
11441 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11442 {
11443   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11444   bfd_vma addr, off, limit;
11445
11446   if (htab == NULL)
11447     return FALSE;
11448
11449   if (!htab->second_toc_pass)
11450     {
11451       /* Keep track of the first .toc or .got section for this input bfd.  */
11452       bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11453
11454       if (new_bfd)
11455         {
11456           htab->toc_bfd = isec->owner;
11457           htab->toc_first_sec = isec;
11458         }
11459
11460       addr = isec->output_offset + isec->output_section->vma;
11461       off = addr - htab->toc_curr;
11462       limit = 0x80008000;
11463       if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11464         limit = 0x10000;
11465       if (off + isec->size > limit)
11466         {
11467           addr = (htab->toc_first_sec->output_offset
11468                   + htab->toc_first_sec->output_section->vma);
11469           htab->toc_curr = addr;
11470           htab->toc_curr &= -TOC_BASE_ALIGN;
11471         }
11472
11473       /* toc_curr is the base address of this toc group.  Set elf_gp
11474          for the input section to be the offset relative to the
11475          output toc base plus 0x8000.  Making the input elf_gp an
11476          offset allows us to move the toc as a whole without
11477          recalculating input elf_gp.  */
11478       off = htab->toc_curr - elf_gp (isec->output_section->owner);
11479       off += TOC_BASE_OFF;
11480
11481       /* Die if someone uses a linker script that doesn't keep input
11482          file .toc and .got together.  */
11483       if (new_bfd
11484           && elf_gp (isec->owner) != 0
11485           && elf_gp (isec->owner) != off)
11486         return FALSE;
11487
11488       elf_gp (isec->owner) = off;
11489       return TRUE;
11490     }
11491
11492   /* During the second pass toc_first_sec points to the start of
11493      a toc group, and toc_curr is used to track the old elf_gp.
11494      We use toc_bfd to ensure we only look at each bfd once.  */
11495   if (htab->toc_bfd == isec->owner)
11496     return TRUE;
11497   htab->toc_bfd = isec->owner;
11498
11499   if (htab->toc_first_sec == NULL
11500       || htab->toc_curr != elf_gp (isec->owner))
11501     {
11502       htab->toc_curr = elf_gp (isec->owner);
11503       htab->toc_first_sec = isec;
11504     }
11505   addr = (htab->toc_first_sec->output_offset
11506           + htab->toc_first_sec->output_section->vma);
11507   off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
11508   elf_gp (isec->owner) = off;
11509
11510   return TRUE;
11511 }
11512
11513 /* Called via elf_link_hash_traverse to merge GOT entries for global
11514    symbol H.  */
11515
11516 static bfd_boolean
11517 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11518 {
11519   if (h->root.type == bfd_link_hash_indirect)
11520     return TRUE;
11521
11522   merge_got_entries (&h->got.glist);
11523
11524   return TRUE;
11525 }
11526
11527 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11528    symbol H.  */
11529
11530 static bfd_boolean
11531 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11532 {
11533   struct got_entry *gent;
11534
11535   if (h->root.type == bfd_link_hash_indirect)
11536     return TRUE;
11537
11538   for (gent = h->got.glist; gent != NULL; gent = gent->next)
11539     if (!gent->is_indirect)
11540       allocate_got (h, (struct bfd_link_info *) inf, gent);
11541   return TRUE;
11542 }
11543
11544 /* Called on the first multitoc pass after the last call to
11545    ppc64_elf_next_toc_section.  This function removes duplicate GOT
11546    entries.  */
11547
11548 bfd_boolean
11549 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11550 {
11551   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11552   struct bfd *ibfd, *ibfd2;
11553   bfd_boolean done_something;
11554
11555   htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11556
11557   if (!htab->do_multi_toc)
11558     return FALSE;
11559
11560   /* Merge global sym got entries within a toc group.  */
11561   elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11562
11563   /* And tlsld_got.  */
11564   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11565     {
11566       struct got_entry *ent, *ent2;
11567
11568       if (!is_ppc64_elf (ibfd))
11569         continue;
11570
11571       ent = ppc64_tlsld_got (ibfd);
11572       if (!ent->is_indirect
11573           && ent->got.offset != (bfd_vma) -1)
11574         {
11575           for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
11576             {
11577               if (!is_ppc64_elf (ibfd2))
11578                 continue;
11579
11580               ent2 = ppc64_tlsld_got (ibfd2);
11581               if (!ent2->is_indirect
11582                   && ent2->got.offset != (bfd_vma) -1
11583                   && elf_gp (ibfd2) == elf_gp (ibfd))
11584                 {
11585                   ent2->is_indirect = TRUE;
11586                   ent2->got.ent = ent;
11587                 }
11588             }
11589         }
11590     }
11591
11592   /* Zap sizes of got sections.  */
11593   htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11594   htab->elf.irelplt->size -= htab->got_reli_size;
11595   htab->got_reli_size = 0;
11596
11597   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11598     {
11599       asection *got, *relgot;
11600
11601       if (!is_ppc64_elf (ibfd))
11602         continue;
11603
11604       got = ppc64_elf_tdata (ibfd)->got;
11605       if (got != NULL)
11606         {
11607           got->rawsize = got->size;
11608           got->size = 0;
11609           relgot = ppc64_elf_tdata (ibfd)->relgot;
11610           relgot->rawsize = relgot->size;
11611           relgot->size = 0;
11612         }
11613     }
11614
11615   /* Now reallocate the got, local syms first.  We don't need to
11616      allocate section contents again since we never increase size.  */
11617   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11618     {
11619       struct got_entry **lgot_ents;
11620       struct got_entry **end_lgot_ents;
11621       struct plt_entry **local_plt;
11622       struct plt_entry **end_local_plt;
11623       unsigned char *lgot_masks;
11624       bfd_size_type locsymcount;
11625       Elf_Internal_Shdr *symtab_hdr;
11626       asection *s;
11627
11628       if (!is_ppc64_elf (ibfd))
11629         continue;
11630
11631       lgot_ents = elf_local_got_ents (ibfd);
11632       if (!lgot_ents)
11633         continue;
11634
11635       symtab_hdr = &elf_symtab_hdr (ibfd);
11636       locsymcount = symtab_hdr->sh_info;
11637       end_lgot_ents = lgot_ents + locsymcount;
11638       local_plt = (struct plt_entry **) end_lgot_ents;
11639       end_local_plt = local_plt + locsymcount;
11640       lgot_masks = (unsigned char *) end_local_plt;
11641       s = ppc64_elf_tdata (ibfd)->got;
11642       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11643         {
11644           struct got_entry *ent;
11645
11646           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11647             {
11648               unsigned int ent_size = 8;
11649               unsigned int rel_size = sizeof (Elf64_External_Rela);
11650
11651               ent->got.offset = s->size;
11652               if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11653                 {
11654                   ent_size *= 2;
11655                   rel_size *= 2;
11656                 }
11657               s->size += ent_size;
11658               if ((*lgot_masks & PLT_IFUNC) != 0)
11659                 {
11660                   htab->elf.irelplt->size += rel_size;
11661                   htab->got_reli_size += rel_size;
11662                 }
11663               else if (bfd_link_pic (info))
11664                 {
11665                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11666                   srel->size += rel_size;
11667                 }
11668             }
11669         }
11670     }
11671
11672   elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11673
11674   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11675     {
11676       struct got_entry *ent;
11677
11678       if (!is_ppc64_elf (ibfd))
11679         continue;
11680
11681       ent = ppc64_tlsld_got (ibfd);
11682       if (!ent->is_indirect
11683           && ent->got.offset != (bfd_vma) -1)
11684         {
11685           asection *s = ppc64_elf_tdata (ibfd)->got;
11686           ent->got.offset = s->size;
11687           s->size += 16;
11688           if (bfd_link_pic (info))
11689             {
11690               asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11691               srel->size += sizeof (Elf64_External_Rela);
11692             }
11693         }
11694     }
11695
11696   done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11697   if (!done_something)
11698     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11699       {
11700         asection *got;
11701
11702         if (!is_ppc64_elf (ibfd))
11703           continue;
11704
11705         got = ppc64_elf_tdata (ibfd)->got;
11706         if (got != NULL)
11707           {
11708             done_something = got->rawsize != got->size;
11709             if (done_something)
11710               break;
11711           }
11712       }
11713
11714   if (done_something)
11715     (*htab->params->layout_sections_again) ();
11716
11717   /* Set up for second pass over toc sections to recalculate elf_gp
11718      on input sections.  */
11719   htab->toc_bfd = NULL;
11720   htab->toc_first_sec = NULL;
11721   htab->second_toc_pass = TRUE;
11722   return done_something;
11723 }
11724
11725 /* Called after second pass of multitoc partitioning.  */
11726
11727 void
11728 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11729 {
11730   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11731
11732   /* After the second pass, toc_curr tracks the TOC offset used
11733      for code sections below in ppc64_elf_next_input_section.  */
11734   htab->toc_curr = TOC_BASE_OFF;
11735 }
11736
11737 /* No toc references were found in ISEC.  If the code in ISEC makes no
11738    calls, then there's no need to use toc adjusting stubs when branching
11739    into ISEC.  Actually, indirect calls from ISEC are OK as they will
11740    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
11741    needed, and 2 if a cyclical call-graph was found but no other reason
11742    for a stub was detected.  If called from the top level, a return of
11743    2 means the same as a return of 0.  */
11744
11745 static int
11746 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11747 {
11748   int ret;
11749
11750   /* Mark this section as checked.  */
11751   isec->call_check_done = 1;
11752
11753   /* We know none of our code bearing sections will need toc stubs.  */
11754   if ((isec->flags & SEC_LINKER_CREATED) != 0)
11755     return 0;
11756
11757   if (isec->size == 0)
11758     return 0;
11759
11760   if (isec->output_section == NULL)
11761     return 0;
11762
11763   ret = 0;
11764   if (isec->reloc_count != 0)
11765     {
11766       Elf_Internal_Rela *relstart, *rel;
11767       Elf_Internal_Sym *local_syms;
11768       struct ppc_link_hash_table *htab;
11769
11770       relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11771                                             info->keep_memory);
11772       if (relstart == NULL)
11773         return -1;
11774
11775       /* Look for branches to outside of this section.  */
11776       local_syms = NULL;
11777       htab = ppc_hash_table (info);
11778       if (htab == NULL)
11779         return -1;
11780
11781       for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11782         {
11783           enum elf_ppc64_reloc_type r_type;
11784           unsigned long r_symndx;
11785           struct elf_link_hash_entry *h;
11786           struct ppc_link_hash_entry *eh;
11787           Elf_Internal_Sym *sym;
11788           asection *sym_sec;
11789           struct _opd_sec_data *opd;
11790           bfd_vma sym_value;
11791           bfd_vma dest;
11792
11793           r_type = ELF64_R_TYPE (rel->r_info);
11794           if (r_type != R_PPC64_REL24
11795               && r_type != R_PPC64_REL14
11796               && r_type != R_PPC64_REL14_BRTAKEN
11797               && r_type != R_PPC64_REL14_BRNTAKEN)
11798             continue;
11799
11800           r_symndx = ELF64_R_SYM (rel->r_info);
11801           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11802                           isec->owner))
11803             {
11804               ret = -1;
11805               break;
11806             }
11807
11808           /* Calls to dynamic lib functions go through a plt call stub
11809              that uses r2.  */
11810           eh = (struct ppc_link_hash_entry *) h;
11811           if (eh != NULL
11812               && (eh->elf.plt.plist != NULL
11813                   || (eh->oh != NULL
11814                       && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11815             {
11816               ret = 1;
11817               break;
11818             }
11819
11820           if (sym_sec == NULL)
11821             /* Ignore other undefined symbols.  */
11822             continue;
11823
11824           /* Assume branches to other sections not included in the
11825              link need stubs too, to cover -R and absolute syms.  */
11826           if (sym_sec->output_section == NULL)
11827             {
11828               ret = 1;
11829               break;
11830             }
11831
11832           if (h == NULL)
11833             sym_value = sym->st_value;
11834           else
11835             {
11836               if (h->root.type != bfd_link_hash_defined
11837                   && h->root.type != bfd_link_hash_defweak)
11838                 abort ();
11839               sym_value = h->root.u.def.value;
11840             }
11841           sym_value += rel->r_addend;
11842
11843           /* If this branch reloc uses an opd sym, find the code section.  */
11844           opd = get_opd_info (sym_sec);
11845           if (opd != NULL)
11846             {
11847               if (h == NULL && opd->adjust != NULL)
11848                 {
11849                   long adjust;
11850
11851                   adjust = opd->adjust[OPD_NDX (sym_value)];
11852                   if (adjust == -1)
11853                     /* Assume deleted functions won't ever be called.  */
11854                     continue;
11855                   sym_value += adjust;
11856                 }
11857
11858               dest = opd_entry_value (sym_sec, sym_value,
11859                                       &sym_sec, NULL, FALSE);
11860               if (dest == (bfd_vma) -1)
11861                 continue;
11862             }
11863           else
11864             dest = (sym_value
11865                     + sym_sec->output_offset
11866                     + sym_sec->output_section->vma);
11867
11868           /* Ignore branch to self.  */
11869           if (sym_sec == isec)
11870             continue;
11871
11872           /* If the called function uses the toc, we need a stub.  */
11873           if (sym_sec->has_toc_reloc
11874               || sym_sec->makes_toc_func_call)
11875             {
11876               ret = 1;
11877               break;
11878             }
11879
11880           /* Assume any branch that needs a long branch stub might in fact
11881              need a plt_branch stub.  A plt_branch stub uses r2.  */
11882           else if (dest - (isec->output_offset
11883                            + isec->output_section->vma
11884                            + rel->r_offset) + (1 << 25)
11885                    >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
11886                                                              ? h->other
11887                                                              : sym->st_other))
11888             {
11889               ret = 1;
11890               break;
11891             }
11892
11893           /* If calling back to a section in the process of being
11894              tested, we can't say for sure that no toc adjusting stubs
11895              are needed, so don't return zero.  */
11896           else if (sym_sec->call_check_in_progress)
11897             ret = 2;
11898
11899           /* Branches to another section that itself doesn't have any TOC
11900              references are OK.  Recursively call ourselves to check.  */
11901           else if (!sym_sec->call_check_done)
11902             {
11903               int recur;
11904
11905               /* Mark current section as indeterminate, so that other
11906                  sections that call back to current won't be marked as
11907                  known.  */
11908               isec->call_check_in_progress = 1;
11909               recur = toc_adjusting_stub_needed (info, sym_sec);
11910               isec->call_check_in_progress = 0;
11911
11912               if (recur != 0)
11913                 {
11914                   ret = recur;
11915                   if (recur != 2)
11916                     break;
11917                 }
11918             }
11919         }
11920
11921       if (local_syms != NULL
11922           && (elf_symtab_hdr (isec->owner).contents
11923               != (unsigned char *) local_syms))
11924         free (local_syms);
11925       if (elf_section_data (isec)->relocs != relstart)
11926         free (relstart);
11927     }
11928
11929   if ((ret & 1) == 0
11930       && isec->map_head.s != NULL
11931       && (strcmp (isec->output_section->name, ".init") == 0
11932           || strcmp (isec->output_section->name, ".fini") == 0))
11933     {
11934       if (isec->map_head.s->has_toc_reloc
11935           || isec->map_head.s->makes_toc_func_call)
11936         ret = 1;
11937       else if (!isec->map_head.s->call_check_done)
11938         {
11939           int recur;
11940           isec->call_check_in_progress = 1;
11941           recur = toc_adjusting_stub_needed (info, isec->map_head.s);
11942           isec->call_check_in_progress = 0;
11943           if (recur != 0)
11944             ret = recur;
11945         }
11946     }
11947
11948   if (ret == 1)
11949     isec->makes_toc_func_call = 1;
11950
11951   return ret;
11952 }
11953
11954 /* The linker repeatedly calls this function for each input section,
11955    in the order that input sections are linked into output sections.
11956    Build lists of input sections to determine groupings between which
11957    we may insert linker stubs.  */
11958
11959 bfd_boolean
11960 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
11961 {
11962   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11963
11964   if (htab == NULL)
11965     return FALSE;
11966
11967   if ((isec->output_section->flags & SEC_CODE) != 0
11968       && isec->output_section->id < htab->sec_info_arr_size)
11969     {
11970       /* This happens to make the list in reverse order,
11971          which is what we want.  */
11972       htab->sec_info[isec->id].u.list
11973         = htab->sec_info[isec->output_section->id].u.list;
11974       htab->sec_info[isec->output_section->id].u.list = isec;
11975     }
11976
11977   if (htab->multi_toc_needed)
11978     {
11979       /* Analyse sections that aren't already flagged as needing a
11980          valid toc pointer.  Exclude .fixup for the linux kernel.
11981          .fixup contains branches, but only back to the function that
11982          hit an exception.  */
11983       if (!(isec->has_toc_reloc
11984             || (isec->flags & SEC_CODE) == 0
11985             || strcmp (isec->name, ".fixup") == 0
11986             || isec->call_check_done))
11987         {
11988           if (toc_adjusting_stub_needed (info, isec) < 0)
11989             return FALSE;
11990         }
11991       /* Make all sections use the TOC assigned for this object file.
11992          This will be wrong for pasted sections;  We fix that in
11993          check_pasted_section().  */
11994       if (elf_gp (isec->owner) != 0)
11995         htab->toc_curr = elf_gp (isec->owner);
11996     }
11997
11998   htab->sec_info[isec->id].toc_off = htab->toc_curr;
11999   return TRUE;
12000 }
12001
12002 /* Check that all .init and .fini sections use the same toc, if they
12003    have toc relocs.  */
12004
12005 static bfd_boolean
12006 check_pasted_section (struct bfd_link_info *info, const char *name)
12007 {
12008   asection *o = bfd_get_section_by_name (info->output_bfd, name);
12009
12010   if (o != NULL)
12011     {
12012       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12013       bfd_vma toc_off = 0;
12014       asection *i;
12015
12016       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12017         if (i->has_toc_reloc)
12018           {
12019             if (toc_off == 0)
12020               toc_off = htab->sec_info[i->id].toc_off;
12021             else if (toc_off != htab->sec_info[i->id].toc_off)
12022               return FALSE;
12023           }
12024
12025       if (toc_off == 0)
12026         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12027           if (i->makes_toc_func_call)
12028             {
12029               toc_off = htab->sec_info[i->id].toc_off;
12030               break;
12031             }
12032
12033       /* Make sure the whole pasted function uses the same toc offset.  */
12034       if (toc_off != 0)
12035         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12036           htab->sec_info[i->id].toc_off = toc_off;
12037     }
12038   return TRUE;
12039 }
12040
12041 bfd_boolean
12042 ppc64_elf_check_init_fini (struct bfd_link_info *info)
12043 {
12044   return (check_pasted_section (info, ".init")
12045           & check_pasted_section (info, ".fini"));
12046 }
12047
12048 /* See whether we can group stub sections together.  Grouping stub
12049    sections may result in fewer stubs.  More importantly, we need to
12050    put all .init* and .fini* stubs at the beginning of the .init or
12051    .fini output sections respectively, because glibc splits the
12052    _init and _fini functions into multiple parts.  Putting a stub in
12053    the middle of a function is not a good idea.  */
12054
12055 static bfd_boolean
12056 group_sections (struct bfd_link_info *info,
12057                 bfd_size_type stub_group_size,
12058                 bfd_boolean stubs_always_before_branch)
12059 {
12060   struct ppc_link_hash_table *htab;
12061   asection *osec;
12062   bfd_boolean suppress_size_errors;
12063
12064   htab = ppc_hash_table (info);
12065   if (htab == NULL)
12066     return FALSE;
12067
12068   suppress_size_errors = FALSE;
12069   if (stub_group_size == 1)
12070     {
12071       /* Default values.  */
12072       if (stubs_always_before_branch)
12073         stub_group_size = 0x1e00000;
12074       else
12075         stub_group_size = 0x1c00000;
12076       suppress_size_errors = TRUE;
12077     }
12078
12079   for (osec = info->output_bfd->sections; osec != NULL; osec = osec->next)
12080     {
12081       asection *tail;
12082
12083       if (osec->id >= htab->sec_info_arr_size)
12084         continue;
12085
12086       tail = htab->sec_info[osec->id].u.list;
12087       while (tail != NULL)
12088         {
12089           asection *curr;
12090           asection *prev;
12091           bfd_size_type total;
12092           bfd_boolean big_sec;
12093           bfd_vma curr_toc;
12094           struct map_stub *group;
12095           bfd_size_type group_size;
12096
12097           curr = tail;
12098           total = tail->size;
12099           group_size = (ppc64_elf_section_data (tail) != NULL
12100                         && ppc64_elf_section_data (tail)->has_14bit_branch
12101                         ? stub_group_size >> 10 : stub_group_size);
12102
12103           big_sec = total > group_size;
12104           if (big_sec && !suppress_size_errors)
12105             (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
12106                                      tail->owner, tail);
12107           curr_toc = htab->sec_info[tail->id].toc_off;
12108
12109           while ((prev = htab->sec_info[curr->id].u.list) != NULL
12110                  && ((total += curr->output_offset - prev->output_offset)
12111                      < (ppc64_elf_section_data (prev) != NULL
12112                         && ppc64_elf_section_data (prev)->has_14bit_branch
12113                         ? (group_size = stub_group_size >> 10) : group_size))
12114                  && htab->sec_info[prev->id].toc_off == curr_toc)
12115             curr = prev;
12116
12117           /* OK, the size from the start of CURR to the end is less
12118              than group_size and thus can be handled by one stub
12119              section.  (or the tail section is itself larger than
12120              group_size, in which case we may be toast.)  We should
12121              really be keeping track of the total size of stubs added
12122              here, as stubs contribute to the final output section
12123              size.  That's a little tricky, and this way will only
12124              break if stubs added make the total size more than 2^25,
12125              ie. for the default stub_group_size, if stubs total more
12126              than 2097152 bytes, or nearly 75000 plt call stubs.  */
12127           group = bfd_alloc (curr->owner, sizeof (*group));
12128           if (group == NULL)
12129             return FALSE;
12130           group->link_sec = curr;
12131           group->stub_sec = NULL;
12132           group->needs_save_res = 0;
12133           group->next = htab->group;
12134           htab->group = group;
12135           do
12136             {
12137               prev = htab->sec_info[tail->id].u.list;
12138               /* Set up this stub group.  */
12139               htab->sec_info[tail->id].u.group = group;
12140             }
12141           while (tail != curr && (tail = prev) != NULL);
12142
12143           /* But wait, there's more!  Input sections up to group_size
12144              bytes before the stub section can be handled by it too.
12145              Don't do this if we have a really large section after the
12146              stubs, as adding more stubs increases the chance that
12147              branches may not reach into the stub section.  */
12148           if (!stubs_always_before_branch && !big_sec)
12149             {
12150               total = 0;
12151               while (prev != NULL
12152                      && ((total += tail->output_offset - prev->output_offset)
12153                          < (ppc64_elf_section_data (prev) != NULL
12154                             && ppc64_elf_section_data (prev)->has_14bit_branch
12155                             ? (group_size = stub_group_size >> 10) : group_size))
12156                      && htab->sec_info[prev->id].toc_off == curr_toc)
12157                 {
12158                   tail = prev;
12159                   prev = htab->sec_info[tail->id].u.list;
12160                   htab->sec_info[tail->id].u.group = group;
12161                 }
12162             }
12163           tail = prev;
12164         }
12165     }
12166   return TRUE;
12167 }
12168
12169 static const unsigned char glink_eh_frame_cie[] =
12170 {
12171   0, 0, 0, 16,                          /* length.  */
12172   0, 0, 0, 0,                           /* id.  */
12173   1,                                    /* CIE version.  */
12174   'z', 'R', 0,                          /* Augmentation string.  */
12175   4,                                    /* Code alignment.  */
12176   0x78,                                 /* Data alignment.  */
12177   65,                                   /* RA reg.  */
12178   1,                                    /* Augmentation size.  */
12179   DW_EH_PE_pcrel | DW_EH_PE_sdata4,     /* FDE encoding.  */
12180   DW_CFA_def_cfa, 1, 0,                 /* def_cfa: r1 offset 0.  */
12181   0, 0, 0, 0
12182 };
12183
12184 /* Stripping output sections is normally done before dynamic section
12185    symbols have been allocated.  This function is called later, and
12186    handles cases like htab->brlt which is mapped to its own output
12187    section.  */
12188
12189 static void
12190 maybe_strip_output (struct bfd_link_info *info, asection *isec)
12191 {
12192   if (isec->size == 0
12193       && isec->output_section->size == 0
12194       && !(isec->output_section->flags & SEC_KEEP)
12195       && !bfd_section_removed_from_list (info->output_bfd,
12196                                          isec->output_section)
12197       && elf_section_data (isec->output_section)->dynindx == 0)
12198     {
12199       isec->output_section->flags |= SEC_EXCLUDE;
12200       bfd_section_list_remove (info->output_bfd, isec->output_section);
12201       info->output_bfd->section_count--;
12202     }
12203 }
12204
12205 /* Determine and set the size of the stub section for a final link.
12206
12207    The basic idea here is to examine all the relocations looking for
12208    PC-relative calls to a target that is unreachable with a "bl"
12209    instruction.  */
12210
12211 bfd_boolean
12212 ppc64_elf_size_stubs (struct bfd_link_info *info)
12213 {
12214   bfd_size_type stub_group_size;
12215   bfd_boolean stubs_always_before_branch;
12216   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12217
12218   if (htab == NULL)
12219     return FALSE;
12220
12221   if (htab->params->plt_thread_safe == -1 && !bfd_link_executable (info))
12222     htab->params->plt_thread_safe = 1;
12223   if (!htab->opd_abi)
12224     htab->params->plt_thread_safe = 0;
12225   else if (htab->params->plt_thread_safe == -1)
12226     {
12227       static const char *const thread_starter[] =
12228         {
12229           "pthread_create",
12230           /* libstdc++ */
12231           "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
12232           /* librt */
12233           "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
12234           "mq_notify", "create_timer",
12235           /* libanl */
12236           "getaddrinfo_a",
12237           /* libgomp */
12238           "GOMP_parallel",
12239           "GOMP_parallel_start",
12240           "GOMP_parallel_loop_static",
12241           "GOMP_parallel_loop_static_start",
12242           "GOMP_parallel_loop_dynamic",
12243           "GOMP_parallel_loop_dynamic_start",
12244           "GOMP_parallel_loop_guided",
12245           "GOMP_parallel_loop_guided_start",
12246           "GOMP_parallel_loop_runtime",
12247           "GOMP_parallel_loop_runtime_start",
12248           "GOMP_parallel_sections",
12249           "GOMP_parallel_sections_start",
12250           /* libgo */
12251           "__go_go",
12252         };
12253       unsigned i;
12254
12255       for (i = 0; i < ARRAY_SIZE (thread_starter); i++)
12256         {
12257           struct elf_link_hash_entry *h;
12258           h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
12259                                     FALSE, FALSE, TRUE);
12260           htab->params->plt_thread_safe = h != NULL && h->ref_regular;
12261           if (htab->params->plt_thread_safe)
12262             break;
12263         }
12264     }
12265   stubs_always_before_branch = htab->params->group_size < 0;
12266   if (htab->params->group_size < 0)
12267     stub_group_size = -htab->params->group_size;
12268   else
12269     stub_group_size = htab->params->group_size;
12270
12271   if (!group_sections (info, stub_group_size, stubs_always_before_branch))
12272     return FALSE;
12273
12274 #define STUB_SHRINK_ITER 20
12275   /* Loop until no stubs added.  After iteration 20 of this loop we may
12276      exit on a stub section shrinking.  This is to break out of a
12277      pathological case where adding stubs on one iteration decreases
12278      section gaps (perhaps due to alignment), which then requires
12279      fewer or smaller stubs on the next iteration.  */
12280
12281   while (1)
12282     {
12283       bfd *input_bfd;
12284       unsigned int bfd_indx;
12285       struct map_stub *group;
12286       asection *stub_sec;
12287
12288       htab->stub_iteration += 1;
12289
12290       for (input_bfd = info->input_bfds, bfd_indx = 0;
12291            input_bfd != NULL;
12292            input_bfd = input_bfd->link.next, bfd_indx++)
12293         {
12294           Elf_Internal_Shdr *symtab_hdr;
12295           asection *section;
12296           Elf_Internal_Sym *local_syms = NULL;
12297
12298           if (!is_ppc64_elf (input_bfd))
12299             continue;
12300
12301           /* We'll need the symbol table in a second.  */
12302           symtab_hdr = &elf_symtab_hdr (input_bfd);
12303           if (symtab_hdr->sh_info == 0)
12304             continue;
12305
12306           /* Walk over each section attached to the input bfd.  */
12307           for (section = input_bfd->sections;
12308                section != NULL;
12309                section = section->next)
12310             {
12311               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
12312
12313               /* If there aren't any relocs, then there's nothing more
12314                  to do.  */
12315               if ((section->flags & SEC_RELOC) == 0
12316                   || (section->flags & SEC_ALLOC) == 0
12317                   || (section->flags & SEC_LOAD) == 0
12318                   || (section->flags & SEC_CODE) == 0
12319                   || section->reloc_count == 0)
12320                 continue;
12321
12322               /* If this section is a link-once section that will be
12323                  discarded, then don't create any stubs.  */
12324               if (section->output_section == NULL
12325                   || section->output_section->owner != info->output_bfd)
12326                 continue;
12327
12328               /* Get the relocs.  */
12329               internal_relocs
12330                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
12331                                              info->keep_memory);
12332               if (internal_relocs == NULL)
12333                 goto error_ret_free_local;
12334
12335               /* Now examine each relocation.  */
12336               irela = internal_relocs;
12337               irelaend = irela + section->reloc_count;
12338               for (; irela < irelaend; irela++)
12339                 {
12340                   enum elf_ppc64_reloc_type r_type;
12341                   unsigned int r_indx;
12342                   enum ppc_stub_type stub_type;
12343                   struct ppc_stub_hash_entry *stub_entry;
12344                   asection *sym_sec, *code_sec;
12345                   bfd_vma sym_value, code_value;
12346                   bfd_vma destination;
12347                   unsigned long local_off;
12348                   bfd_boolean ok_dest;
12349                   struct ppc_link_hash_entry *hash;
12350                   struct ppc_link_hash_entry *fdh;
12351                   struct elf_link_hash_entry *h;
12352                   Elf_Internal_Sym *sym;
12353                   char *stub_name;
12354                   const asection *id_sec;
12355                   struct _opd_sec_data *opd;
12356                   struct plt_entry *plt_ent;
12357
12358                   r_type = ELF64_R_TYPE (irela->r_info);
12359                   r_indx = ELF64_R_SYM (irela->r_info);
12360
12361                   if (r_type >= R_PPC64_max)
12362                     {
12363                       bfd_set_error (bfd_error_bad_value);
12364                       goto error_ret_free_internal;
12365                     }
12366
12367                   /* Only look for stubs on branch instructions.  */
12368                   if (r_type != R_PPC64_REL24
12369                       && r_type != R_PPC64_REL14
12370                       && r_type != R_PPC64_REL14_BRTAKEN
12371                       && r_type != R_PPC64_REL14_BRNTAKEN)
12372                     continue;
12373
12374                   /* Now determine the call target, its name, value,
12375                      section.  */
12376                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12377                                   r_indx, input_bfd))
12378                     goto error_ret_free_internal;
12379                   hash = (struct ppc_link_hash_entry *) h;
12380
12381                   ok_dest = FALSE;
12382                   fdh = NULL;
12383                   sym_value = 0;
12384                   if (hash == NULL)
12385                     {
12386                       sym_value = sym->st_value;
12387                       if (sym_sec != NULL
12388                           && sym_sec->output_section != NULL)
12389                         ok_dest = TRUE;
12390                     }
12391                   else if (hash->elf.root.type == bfd_link_hash_defined
12392                            || hash->elf.root.type == bfd_link_hash_defweak)
12393                     {
12394                       sym_value = hash->elf.root.u.def.value;
12395                       if (sym_sec->output_section != NULL)
12396                         ok_dest = TRUE;
12397                     }
12398                   else if (hash->elf.root.type == bfd_link_hash_undefweak
12399                            || hash->elf.root.type == bfd_link_hash_undefined)
12400                     {
12401                       /* Recognise an old ABI func code entry sym, and
12402                          use the func descriptor sym instead if it is
12403                          defined.  */
12404                       if (hash->elf.root.root.string[0] == '.'
12405                           && (fdh = lookup_fdh (hash, htab)) != NULL)
12406                         {
12407                           if (fdh->elf.root.type == bfd_link_hash_defined
12408                               || fdh->elf.root.type == bfd_link_hash_defweak)
12409                             {
12410                               sym_sec = fdh->elf.root.u.def.section;
12411                               sym_value = fdh->elf.root.u.def.value;
12412                               if (sym_sec->output_section != NULL)
12413                                 ok_dest = TRUE;
12414                             }
12415                           else
12416                             fdh = NULL;
12417                         }
12418                     }
12419                   else
12420                     {
12421                       bfd_set_error (bfd_error_bad_value);
12422                       goto error_ret_free_internal;
12423                     }
12424
12425                   destination = 0;
12426                   local_off = 0;
12427                   if (ok_dest)
12428                     {
12429                       sym_value += irela->r_addend;
12430                       destination = (sym_value
12431                                      + sym_sec->output_offset
12432                                      + sym_sec->output_section->vma);
12433                       local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12434                                                             ? hash->elf.other
12435                                                             : sym->st_other);
12436                     }
12437
12438                   code_sec = sym_sec;
12439                   code_value = sym_value;
12440                   opd = get_opd_info (sym_sec);
12441                   if (opd != NULL)
12442                     {
12443                       bfd_vma dest;
12444
12445                       if (hash == NULL && opd->adjust != NULL)
12446                         {
12447                           long adjust = opd->adjust[OPD_NDX (sym_value)];
12448                           if (adjust == -1)
12449                             continue;
12450                           code_value += adjust;
12451                           sym_value += adjust;
12452                         }
12453                       dest = opd_entry_value (sym_sec, sym_value,
12454                                               &code_sec, &code_value, FALSE);
12455                       if (dest != (bfd_vma) -1)
12456                         {
12457                           destination = dest;
12458                           if (fdh != NULL)
12459                             {
12460                               /* Fixup old ABI sym to point at code
12461                                  entry.  */
12462                               hash->elf.root.type = bfd_link_hash_defweak;
12463                               hash->elf.root.u.def.section = code_sec;
12464                               hash->elf.root.u.def.value = code_value;
12465                             }
12466                         }
12467                     }
12468
12469                   /* Determine what (if any) linker stub is needed.  */
12470                   plt_ent = NULL;
12471                   stub_type = ppc_type_of_stub (section, irela, &hash,
12472                                                 &plt_ent, destination,
12473                                                 local_off);
12474
12475                   if (stub_type != ppc_stub_plt_call)
12476                     {
12477                       /* Check whether we need a TOC adjusting stub.
12478                          Since the linker pastes together pieces from
12479                          different object files when creating the
12480                          _init and _fini functions, it may be that a
12481                          call to what looks like a local sym is in
12482                          fact a call needing a TOC adjustment.  */
12483                       if (code_sec != NULL
12484                           && code_sec->output_section != NULL
12485                           && (htab->sec_info[code_sec->id].toc_off
12486                               != htab->sec_info[section->id].toc_off)
12487                           && (code_sec->has_toc_reloc
12488                               || code_sec->makes_toc_func_call))
12489                         stub_type = ppc_stub_long_branch_r2off;
12490                     }
12491
12492                   if (stub_type == ppc_stub_none)
12493                     continue;
12494
12495                   /* __tls_get_addr calls might be eliminated.  */
12496                   if (stub_type != ppc_stub_plt_call
12497                       && hash != NULL
12498                       && (hash == htab->tls_get_addr
12499                           || hash == htab->tls_get_addr_fd)
12500                       && section->has_tls_reloc
12501                       && irela != internal_relocs)
12502                     {
12503                       /* Get tls info.  */
12504                       unsigned char *tls_mask;
12505
12506                       if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12507                                          irela - 1, input_bfd))
12508                         goto error_ret_free_internal;
12509                       if (*tls_mask != 0)
12510                         continue;
12511                     }
12512
12513                   if (stub_type == ppc_stub_plt_call
12514                       && irela + 1 < irelaend
12515                       && irela[1].r_offset == irela->r_offset + 4
12516                       && ELF64_R_TYPE (irela[1].r_info) == R_PPC64_TOCSAVE)
12517                     {
12518                       if (!tocsave_find (htab, INSERT,
12519                                          &local_syms, irela + 1, input_bfd))
12520                         goto error_ret_free_internal;
12521                     }
12522                   else if (stub_type == ppc_stub_plt_call)
12523                     stub_type = ppc_stub_plt_call_r2save;
12524
12525                   /* Support for grouping stub sections.  */
12526                   id_sec = htab->sec_info[section->id].u.group->link_sec;
12527
12528                   /* Get the name of this stub.  */
12529                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12530                   if (!stub_name)
12531                     goto error_ret_free_internal;
12532
12533                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12534                                                      stub_name, FALSE, FALSE);
12535                   if (stub_entry != NULL)
12536                     {
12537                       /* The proper stub has already been created.  */
12538                       free (stub_name);
12539                       if (stub_type == ppc_stub_plt_call_r2save)
12540                         stub_entry->stub_type = stub_type;
12541                       continue;
12542                     }
12543
12544                   stub_entry = ppc_add_stub (stub_name, section, info);
12545                   if (stub_entry == NULL)
12546                     {
12547                       free (stub_name);
12548                     error_ret_free_internal:
12549                       if (elf_section_data (section)->relocs == NULL)
12550                         free (internal_relocs);
12551                     error_ret_free_local:
12552                       if (local_syms != NULL
12553                           && (symtab_hdr->contents
12554                               != (unsigned char *) local_syms))
12555                         free (local_syms);
12556                       return FALSE;
12557                     }
12558
12559                   stub_entry->stub_type = stub_type;
12560                   if (stub_type != ppc_stub_plt_call
12561                       && stub_type != ppc_stub_plt_call_r2save)
12562                     {
12563                       stub_entry->target_value = code_value;
12564                       stub_entry->target_section = code_sec;
12565                     }
12566                   else
12567                     {
12568                       stub_entry->target_value = sym_value;
12569                       stub_entry->target_section = sym_sec;
12570                     }
12571                   stub_entry->h = hash;
12572                   stub_entry->plt_ent = plt_ent;
12573                   stub_entry->other = hash ? hash->elf.other : sym->st_other;
12574
12575                   if (stub_entry->h != NULL)
12576                     htab->stub_globals += 1;
12577                 }
12578
12579               /* We're done with the internal relocs, free them.  */
12580               if (elf_section_data (section)->relocs != internal_relocs)
12581                 free (internal_relocs);
12582             }
12583
12584           if (local_syms != NULL
12585               && symtab_hdr->contents != (unsigned char *) local_syms)
12586             {
12587               if (!info->keep_memory)
12588                 free (local_syms);
12589               else
12590                 symtab_hdr->contents = (unsigned char *) local_syms;
12591             }
12592         }
12593
12594       /* We may have added some stubs.  Find out the new size of the
12595          stub sections.  */
12596       for (stub_sec = htab->params->stub_bfd->sections;
12597            stub_sec != NULL;
12598            stub_sec = stub_sec->next)
12599         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12600           {
12601             stub_sec->rawsize = stub_sec->size;
12602             stub_sec->size = 0;
12603             stub_sec->reloc_count = 0;
12604             stub_sec->flags &= ~SEC_RELOC;
12605           }
12606
12607       htab->brlt->size = 0;
12608       htab->brlt->reloc_count = 0;
12609       htab->brlt->flags &= ~SEC_RELOC;
12610       if (htab->relbrlt != NULL)
12611         htab->relbrlt->size = 0;
12612
12613       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12614
12615       for (group = htab->group; group != NULL; group = group->next)
12616         if (group->needs_save_res)
12617           group->stub_sec->size += htab->sfpr->size;
12618
12619       if (info->emitrelocations
12620           && htab->glink != NULL && htab->glink->size != 0)
12621         {
12622           htab->glink->reloc_count = 1;
12623           htab->glink->flags |= SEC_RELOC;
12624         }
12625
12626       if (htab->glink_eh_frame != NULL
12627           && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12628           && htab->glink_eh_frame->output_section->size != 0)
12629         {
12630           size_t size = 0, align;
12631
12632           for (stub_sec = htab->params->stub_bfd->sections;
12633                stub_sec != NULL;
12634                stub_sec = stub_sec->next)
12635             if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12636               size += 24;
12637           if (htab->glink != NULL && htab->glink->size != 0)
12638             size += 24;
12639           if (size != 0)
12640             size += sizeof (glink_eh_frame_cie);
12641           align = 1;
12642           align <<= htab->glink_eh_frame->output_section->alignment_power;
12643           align -= 1;
12644           size = (size + align) & ~align;
12645           htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12646           htab->glink_eh_frame->size = size;
12647         }
12648
12649       if (htab->params->plt_stub_align != 0)
12650         for (stub_sec = htab->params->stub_bfd->sections;
12651              stub_sec != NULL;
12652              stub_sec = stub_sec->next)
12653           if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12654             stub_sec->size = ((stub_sec->size
12655                                + (1 << htab->params->plt_stub_align) - 1)
12656                               & -(1 << htab->params->plt_stub_align));
12657
12658       for (stub_sec = htab->params->stub_bfd->sections;
12659            stub_sec != NULL;
12660            stub_sec = stub_sec->next)
12661         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12662             && stub_sec->rawsize != stub_sec->size
12663             && (htab->stub_iteration <= STUB_SHRINK_ITER
12664                 || stub_sec->rawsize < stub_sec->size))
12665           break;
12666
12667       if (stub_sec == NULL
12668           && (htab->glink_eh_frame == NULL
12669               || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12670         break;
12671
12672       /* Ask the linker to do its stuff.  */
12673       (*htab->params->layout_sections_again) ();
12674     }
12675
12676   if (htab->glink_eh_frame != NULL
12677       && htab->glink_eh_frame->size != 0)
12678     {
12679       bfd_vma val;
12680       bfd_byte *p, *last_fde;
12681       size_t last_fde_len, size, align, pad;
12682       asection *stub_sec;
12683
12684       p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12685       if (p == NULL)
12686         return FALSE;
12687       htab->glink_eh_frame->contents = p;
12688       last_fde = p;
12689
12690       memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12691       /* CIE length (rewrite in case little-endian).  */
12692       last_fde_len = sizeof (glink_eh_frame_cie) - 4;
12693       bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12694       p += sizeof (glink_eh_frame_cie);
12695
12696       for (stub_sec = htab->params->stub_bfd->sections;
12697            stub_sec != NULL;
12698            stub_sec = stub_sec->next)
12699         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12700           {
12701             last_fde = p;
12702             last_fde_len = 20;
12703             /* FDE length.  */
12704             bfd_put_32 (htab->elf.dynobj, 20, p);
12705             p += 4;
12706             /* CIE pointer.  */
12707             val = p - htab->glink_eh_frame->contents;
12708             bfd_put_32 (htab->elf.dynobj, val, p);
12709             p += 4;
12710             /* Offset to stub section, written later.  */
12711             p += 4;
12712             /* stub section size.  */
12713             bfd_put_32 (htab->elf.dynobj, stub_sec->size, p);
12714             p += 4;
12715             /* Augmentation.  */
12716             p += 1;
12717             /* Pad.  */
12718             p += 7;
12719           }
12720       if (htab->glink != NULL && htab->glink->size != 0)
12721         {
12722           last_fde = p;
12723           last_fde_len = 20;
12724           /* FDE length.  */
12725           bfd_put_32 (htab->elf.dynobj, 20, p);
12726           p += 4;
12727           /* CIE pointer.  */
12728           val = p - htab->glink_eh_frame->contents;
12729           bfd_put_32 (htab->elf.dynobj, val, p);
12730           p += 4;
12731           /* Offset to .glink, written later.  */
12732           p += 4;
12733           /* .glink size.  */
12734           bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12735           p += 4;
12736           /* Augmentation.  */
12737           p += 1;
12738
12739           *p++ = DW_CFA_advance_loc + 1;
12740           *p++ = DW_CFA_register;
12741           *p++ = 65;
12742           *p++ = htab->opd_abi ? 12 : 0;
12743           *p++ = DW_CFA_advance_loc + 4;
12744           *p++ = DW_CFA_restore_extended;
12745           *p++ = 65;
12746         }
12747       /* Subsume any padding into the last FDE if user .eh_frame
12748          sections are aligned more than glink_eh_frame.  Otherwise any
12749          zero padding will be seen as a terminator.  */
12750       size = p - htab->glink_eh_frame->contents;
12751       align = 1;
12752       align <<= htab->glink_eh_frame->output_section->alignment_power;
12753       align -= 1;
12754       pad = ((size + align) & ~align) - size;
12755       htab->glink_eh_frame->size = size + pad;
12756       bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12757     }
12758
12759   maybe_strip_output (info, htab->brlt);
12760   if (htab->glink_eh_frame != NULL)
12761     maybe_strip_output (info, htab->glink_eh_frame);
12762
12763   return TRUE;
12764 }
12765
12766 /* Called after we have determined section placement.  If sections
12767    move, we'll be called again.  Provide a value for TOCstart.  */
12768
12769 bfd_vma
12770 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12771 {
12772   asection *s;
12773   bfd_vma TOCstart, adjust;
12774
12775   if (info != NULL)
12776     {
12777       struct elf_link_hash_entry *h;
12778       struct elf_link_hash_table *htab = elf_hash_table (info);
12779
12780       if (is_elf_hash_table (htab)
12781           && htab->hgot != NULL)
12782         h = htab->hgot;
12783       else
12784         {
12785           h = elf_link_hash_lookup (htab, ".TOC.", FALSE, FALSE, TRUE);
12786           if (is_elf_hash_table (htab))
12787             htab->hgot = h;
12788         }
12789       if (h != NULL
12790           && h->root.type == bfd_link_hash_defined
12791           && !h->root.linker_def
12792           && (!is_elf_hash_table (htab)
12793               || h->def_regular))
12794         {
12795           TOCstart = (h->root.u.def.value - TOC_BASE_OFF
12796                       + h->root.u.def.section->output_offset
12797                       + h->root.u.def.section->output_section->vma);
12798           _bfd_set_gp_value (obfd, TOCstart);
12799           return TOCstart;
12800         }
12801     }
12802
12803   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12804      order.  The TOC starts where the first of these sections starts.  */
12805   s = bfd_get_section_by_name (obfd, ".got");
12806   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12807     s = bfd_get_section_by_name (obfd, ".toc");
12808   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12809     s = bfd_get_section_by_name (obfd, ".tocbss");
12810   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12811     s = bfd_get_section_by_name (obfd, ".plt");
12812   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12813     {
12814       /* This may happen for
12815          o  references to TOC base (SYM@toc / TOC[tc0]) without a
12816          .toc directive
12817          o  bad linker script
12818          o --gc-sections and empty TOC sections
12819
12820          FIXME: Warn user?  */
12821
12822       /* Look for a likely section.  We probably won't even be
12823          using TOCstart.  */
12824       for (s = obfd->sections; s != NULL; s = s->next)
12825         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
12826                          | SEC_EXCLUDE))
12827             == (SEC_ALLOC | SEC_SMALL_DATA))
12828           break;
12829       if (s == NULL)
12830         for (s = obfd->sections; s != NULL; s = s->next)
12831           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
12832               == (SEC_ALLOC | SEC_SMALL_DATA))
12833             break;
12834       if (s == NULL)
12835         for (s = obfd->sections; s != NULL; s = s->next)
12836           if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
12837               == SEC_ALLOC)
12838             break;
12839       if (s == NULL)
12840         for (s = obfd->sections; s != NULL; s = s->next)
12841           if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
12842             break;
12843     }
12844
12845   TOCstart = 0;
12846   if (s != NULL)
12847     TOCstart = s->output_section->vma + s->output_offset;
12848
12849   /* Force alignment.  */
12850   adjust = TOCstart & (TOC_BASE_ALIGN - 1);
12851   TOCstart -= adjust;
12852   _bfd_set_gp_value (obfd, TOCstart);
12853
12854   if (info != NULL && s != NULL)
12855     {
12856       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12857
12858       if (htab != NULL)
12859         {
12860           if (htab->elf.hgot != NULL)
12861             {
12862               htab->elf.hgot->root.u.def.value = TOC_BASE_OFF - adjust;
12863               htab->elf.hgot->root.u.def.section = s;
12864             }
12865         }
12866       else
12867         {
12868           struct bfd_link_hash_entry *bh = NULL;
12869           _bfd_generic_link_add_one_symbol (info, obfd, ".TOC.", BSF_GLOBAL,
12870                                             s, TOC_BASE_OFF - adjust,
12871                                             NULL, FALSE, FALSE, &bh);
12872         }
12873     }
12874   return TOCstart;
12875 }
12876
12877 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
12878    write out any global entry stubs.  */
12879
12880 static bfd_boolean
12881 build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
12882 {
12883   struct bfd_link_info *info;
12884   struct ppc_link_hash_table *htab;
12885   struct plt_entry *pent;
12886   asection *s;
12887
12888   if (h->root.type == bfd_link_hash_indirect)
12889     return TRUE;
12890
12891   if (!h->pointer_equality_needed)
12892     return TRUE;
12893
12894   if (h->def_regular)
12895     return TRUE;
12896
12897   info = inf;
12898   htab = ppc_hash_table (info);
12899   if (htab == NULL)
12900     return FALSE;
12901
12902   s = htab->glink;
12903   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
12904     if (pent->plt.offset != (bfd_vma) -1
12905         && pent->addend == 0)
12906       {
12907         bfd_byte *p;
12908         asection *plt;
12909         bfd_vma off;
12910
12911         p = s->contents + h->root.u.def.value;
12912         plt = htab->elf.splt;
12913         if (!htab->elf.dynamic_sections_created
12914             || h->dynindx == -1)
12915           plt = htab->elf.iplt;
12916         off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
12917         off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
12918
12919         if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
12920           {
12921             info->callbacks->einfo
12922               (_("%P: linkage table error against `%T'\n"),
12923                h->root.root.string);
12924             bfd_set_error (bfd_error_bad_value);
12925             htab->stub_error = TRUE;
12926           }
12927
12928         htab->stub_count[ppc_stub_global_entry - 1] += 1;
12929         if (htab->params->emit_stub_syms)
12930           {
12931             size_t len = strlen (h->root.root.string);
12932             char *name = bfd_malloc (sizeof "12345678.global_entry." + len);
12933
12934             if (name == NULL)
12935               return FALSE;
12936
12937             sprintf (name, "%08x.global_entry.%s", s->id, h->root.root.string);
12938             h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
12939             if (h == NULL)
12940               return FALSE;
12941             if (h->root.type == bfd_link_hash_new)
12942               {
12943                 h->root.type = bfd_link_hash_defined;
12944                 h->root.u.def.section = s;
12945                 h->root.u.def.value = p - s->contents;
12946                 h->ref_regular = 1;
12947                 h->def_regular = 1;
12948                 h->ref_regular_nonweak = 1;
12949                 h->forced_local = 1;
12950                 h->non_elf = 0;
12951                 h->root.linker_def = 1;
12952               }
12953           }
12954
12955         if (PPC_HA (off) != 0)
12956           {
12957             bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
12958             p += 4;
12959           }
12960         bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
12961         p += 4;
12962         bfd_put_32 (s->owner, MTCTR_R12, p);
12963         p += 4;
12964         bfd_put_32 (s->owner, BCTR, p);
12965         break;
12966       }
12967   return TRUE;
12968 }
12969
12970 /* Build all the stubs associated with the current output file.
12971    The stubs are kept in a hash table attached to the main linker
12972    hash table.  This function is called via gldelf64ppc_finish.  */
12973
12974 bfd_boolean
12975 ppc64_elf_build_stubs (struct bfd_link_info *info,
12976                        char **stats)
12977 {
12978   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12979   struct map_stub *group;
12980   asection *stub_sec;
12981   bfd_byte *p;
12982   int stub_sec_count = 0;
12983
12984   if (htab == NULL)
12985     return FALSE;
12986
12987   /* Allocate memory to hold the linker stubs.  */
12988   for (stub_sec = htab->params->stub_bfd->sections;
12989        stub_sec != NULL;
12990        stub_sec = stub_sec->next)
12991     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12992         && stub_sec->size != 0)
12993       {
12994         stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
12995         if (stub_sec->contents == NULL)
12996           return FALSE;
12997         stub_sec->size = 0;
12998       }
12999
13000   if (htab->glink != NULL && htab->glink->size != 0)
13001     {
13002       unsigned int indx;
13003       bfd_vma plt0;
13004
13005       /* Build the .glink plt call stub.  */
13006       if (htab->params->emit_stub_syms)
13007         {
13008           struct elf_link_hash_entry *h;
13009           h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
13010                                     TRUE, FALSE, FALSE);
13011           if (h == NULL)
13012             return FALSE;
13013           if (h->root.type == bfd_link_hash_new)
13014             {
13015               h->root.type = bfd_link_hash_defined;
13016               h->root.u.def.section = htab->glink;
13017               h->root.u.def.value = 8;
13018               h->ref_regular = 1;
13019               h->def_regular = 1;
13020               h->ref_regular_nonweak = 1;
13021               h->forced_local = 1;
13022               h->non_elf = 0;
13023               h->root.linker_def = 1;
13024             }
13025         }
13026       plt0 = (htab->elf.splt->output_section->vma
13027               + htab->elf.splt->output_offset
13028               - 16);
13029       if (info->emitrelocations)
13030         {
13031           Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
13032           if (r == NULL)
13033             return FALSE;
13034           r->r_offset = (htab->glink->output_offset
13035                          + htab->glink->output_section->vma);
13036           r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
13037           r->r_addend = plt0;
13038         }
13039       p = htab->glink->contents;
13040       plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
13041       bfd_put_64 (htab->glink->owner, plt0, p);
13042       p += 8;
13043       if (htab->opd_abi)
13044         {
13045           bfd_put_32 (htab->glink->owner, MFLR_R12, p);
13046           p += 4;
13047           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13048           p += 4;
13049           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13050           p += 4;
13051           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13052           p += 4;
13053           bfd_put_32 (htab->glink->owner, MTLR_R12, p);
13054           p += 4;
13055           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13056           p += 4;
13057           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13058           p += 4;
13059           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
13060           p += 4;
13061           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13062           p += 4;
13063           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
13064           p += 4;
13065         }
13066       else
13067         {
13068           bfd_put_32 (htab->glink->owner, MFLR_R0, p);
13069           p += 4;
13070           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13071           p += 4;
13072           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13073           p += 4;
13074           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13075           p += 4;
13076           bfd_put_32 (htab->glink->owner, MTLR_R0, p);
13077           p += 4;
13078           bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
13079           p += 4;
13080           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13081           p += 4;
13082           bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
13083           p += 4;
13084           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13085           p += 4;
13086           bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
13087           p += 4;
13088           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13089           p += 4;
13090           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
13091           p += 4;
13092         }
13093       bfd_put_32 (htab->glink->owner, BCTR, p);
13094       p += 4;
13095       while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
13096         {
13097           bfd_put_32 (htab->glink->owner, NOP, p);
13098           p += 4;
13099         }
13100
13101       /* Build the .glink lazy link call stubs.  */
13102       indx = 0;
13103       while (p < htab->glink->contents + htab->glink->rawsize)
13104         {
13105           if (htab->opd_abi)
13106             {
13107               if (indx < 0x8000)
13108                 {
13109                   bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
13110                   p += 4;
13111                 }
13112               else
13113                 {
13114                   bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
13115                   p += 4;
13116                   bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
13117                               p);
13118                   p += 4;
13119                 }
13120             }
13121           bfd_put_32 (htab->glink->owner,
13122                       B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
13123           indx++;
13124           p += 4;
13125         }
13126
13127       /* Build .glink global entry stubs.  */
13128       if (htab->glink->size > htab->glink->rawsize)
13129         elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
13130     }
13131
13132   if (htab->brlt != NULL && htab->brlt->size != 0)
13133     {
13134       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
13135                                          htab->brlt->size);
13136       if (htab->brlt->contents == NULL)
13137         return FALSE;
13138     }
13139   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
13140     {
13141       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
13142                                             htab->relbrlt->size);
13143       if (htab->relbrlt->contents == NULL)
13144         return FALSE;
13145     }
13146
13147   /* Build the stubs as directed by the stub hash table.  */
13148   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
13149
13150   for (group = htab->group; group != NULL; group = group->next)
13151     if (group->needs_save_res)
13152       {
13153         stub_sec = group->stub_sec;
13154         memcpy (stub_sec->contents + stub_sec->size, htab->sfpr->contents,
13155                 htab->sfpr->size);
13156         if (htab->params->emit_stub_syms)
13157           {
13158             unsigned int i;
13159
13160             for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
13161               if (!sfpr_define (info, &save_res_funcs[i], stub_sec))
13162                 return FALSE;
13163           }
13164         stub_sec->size += htab->sfpr->size;
13165       }
13166
13167   if (htab->relbrlt != NULL)
13168     htab->relbrlt->reloc_count = 0;
13169
13170   if (htab->params->plt_stub_align != 0)
13171     for (stub_sec = htab->params->stub_bfd->sections;
13172          stub_sec != NULL;
13173          stub_sec = stub_sec->next)
13174       if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
13175         stub_sec->size = ((stub_sec->size
13176                            + (1 << htab->params->plt_stub_align) - 1)
13177                           & -(1 << htab->params->plt_stub_align));
13178
13179   for (stub_sec = htab->params->stub_bfd->sections;
13180        stub_sec != NULL;
13181        stub_sec = stub_sec->next)
13182     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
13183       {
13184         stub_sec_count += 1;
13185         if (stub_sec->rawsize != stub_sec->size
13186             && (htab->stub_iteration <= STUB_SHRINK_ITER
13187                 || stub_sec->rawsize < stub_sec->size))
13188           break;
13189       }
13190
13191   /* Note that the glink_eh_frame check here is not only testing that
13192      the generated size matched the calculated size but also that
13193      bfd_elf_discard_info didn't make any changes to the section.  */
13194   if (stub_sec != NULL
13195       || (htab->glink_eh_frame != NULL
13196           && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
13197     {
13198       htab->stub_error = TRUE;
13199       info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
13200     }
13201
13202   if (htab->stub_error)
13203     return FALSE;
13204
13205   if (stats != NULL)
13206     {
13207       *stats = bfd_malloc (500);
13208       if (*stats == NULL)
13209         return FALSE;
13210
13211       sprintf (*stats, _("linker stubs in %u group%s\n"
13212                          "  branch       %lu\n"
13213                          "  toc adjust   %lu\n"
13214                          "  long branch  %lu\n"
13215                          "  long toc adj %lu\n"
13216                          "  plt call     %lu\n"
13217                          "  plt call toc %lu\n"
13218                          "  global entry %lu"),
13219                stub_sec_count,
13220                stub_sec_count == 1 ? "" : "s",
13221                htab->stub_count[ppc_stub_long_branch - 1],
13222                htab->stub_count[ppc_stub_long_branch_r2off - 1],
13223                htab->stub_count[ppc_stub_plt_branch - 1],
13224                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
13225                htab->stub_count[ppc_stub_plt_call - 1],
13226                htab->stub_count[ppc_stub_plt_call_r2save - 1],
13227                htab->stub_count[ppc_stub_global_entry - 1]);
13228     }
13229   return TRUE;
13230 }
13231
13232 /* This function undoes the changes made by add_symbol_adjust.  */
13233
13234 static bfd_boolean
13235 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
13236 {
13237   struct ppc_link_hash_entry *eh;
13238
13239   if (h->root.type == bfd_link_hash_indirect)
13240     return TRUE;
13241
13242   eh = (struct ppc_link_hash_entry *) h;
13243   if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
13244     return TRUE;
13245
13246   eh->elf.root.type = bfd_link_hash_undefined;
13247   return TRUE;
13248 }
13249
13250 void
13251 ppc64_elf_restore_symbols (struct bfd_link_info *info)
13252 {
13253   struct ppc_link_hash_table *htab = ppc_hash_table (info);
13254
13255   if (htab != NULL)
13256     elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
13257 }
13258
13259 /* What to do when ld finds relocations against symbols defined in
13260    discarded sections.  */
13261
13262 static unsigned int
13263 ppc64_elf_action_discarded (asection *sec)
13264 {
13265   if (strcmp (".opd", sec->name) == 0)
13266     return 0;
13267
13268   if (strcmp (".toc", sec->name) == 0)
13269     return 0;
13270
13271   if (strcmp (".toc1", sec->name) == 0)
13272     return 0;
13273
13274   return _bfd_elf_default_action_discarded (sec);
13275 }
13276
13277 /* The RELOCATE_SECTION function is called by the ELF backend linker
13278    to handle the relocations for a section.
13279
13280    The relocs are always passed as Rela structures; if the section
13281    actually uses Rel structures, the r_addend field will always be
13282    zero.
13283
13284    This function is responsible for adjust the section contents as
13285    necessary, and (if using Rela relocs and generating a
13286    relocatable output file) adjusting the reloc addend as
13287    necessary.
13288
13289    This function does not have to worry about setting the reloc
13290    address or the reloc symbol index.
13291
13292    LOCAL_SYMS is a pointer to the swapped in local symbols.
13293
13294    LOCAL_SECTIONS is an array giving the section in the input file
13295    corresponding to the st_shndx field of each local symbol.
13296
13297    The global hash table entry for the global symbols can be found
13298    via elf_sym_hashes (input_bfd).
13299
13300    When generating relocatable output, this function must handle
13301    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
13302    going to be the section symbol corresponding to the output
13303    section, which means that the addend must be adjusted
13304    accordingly.  */
13305
13306 static bfd_boolean
13307 ppc64_elf_relocate_section (bfd *output_bfd,
13308                             struct bfd_link_info *info,
13309                             bfd *input_bfd,
13310                             asection *input_section,
13311                             bfd_byte *contents,
13312                             Elf_Internal_Rela *relocs,
13313                             Elf_Internal_Sym *local_syms,
13314                             asection **local_sections)
13315 {
13316   struct ppc_link_hash_table *htab;
13317   Elf_Internal_Shdr *symtab_hdr;
13318   struct elf_link_hash_entry **sym_hashes;
13319   Elf_Internal_Rela *rel;
13320   Elf_Internal_Rela *wrel;
13321   Elf_Internal_Rela *relend;
13322   Elf_Internal_Rela outrel;
13323   bfd_byte *loc;
13324   struct got_entry **local_got_ents;
13325   bfd_vma TOCstart;
13326   bfd_boolean ret = TRUE;
13327   bfd_boolean is_opd;
13328   /* Assume 'at' branch hints.  */
13329   bfd_boolean is_isa_v2 = TRUE;
13330   bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
13331
13332   /* Initialize howto table if needed.  */
13333   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
13334     ppc_howto_init ();
13335
13336   htab = ppc_hash_table (info);
13337   if (htab == NULL)
13338     return FALSE;
13339
13340   /* Don't relocate stub sections.  */
13341   if (input_section->owner == htab->params->stub_bfd)
13342     return TRUE;
13343
13344   BFD_ASSERT (is_ppc64_elf (input_bfd));
13345
13346   local_got_ents = elf_local_got_ents (input_bfd);
13347   TOCstart = elf_gp (output_bfd);
13348   symtab_hdr = &elf_symtab_hdr (input_bfd);
13349   sym_hashes = elf_sym_hashes (input_bfd);
13350   is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
13351
13352   rel = wrel = relocs;
13353   relend = relocs + input_section->reloc_count;
13354   for (; rel < relend; wrel++, rel++)
13355     {
13356       enum elf_ppc64_reloc_type r_type;
13357       bfd_vma addend;
13358       bfd_reloc_status_type r;
13359       Elf_Internal_Sym *sym;
13360       asection *sec;
13361       struct elf_link_hash_entry *h_elf;
13362       struct ppc_link_hash_entry *h;
13363       struct ppc_link_hash_entry *fdh;
13364       const char *sym_name;
13365       unsigned long r_symndx, toc_symndx;
13366       bfd_vma toc_addend;
13367       unsigned char tls_mask, tls_gd, tls_type;
13368       unsigned char sym_type;
13369       bfd_vma relocation;
13370       bfd_boolean unresolved_reloc;
13371       bfd_boolean warned;
13372       enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
13373       unsigned int insn;
13374       unsigned int mask;
13375       struct ppc_stub_hash_entry *stub_entry;
13376       bfd_vma max_br_offset;
13377       bfd_vma from;
13378       Elf_Internal_Rela orig_rel;
13379       reloc_howto_type *howto;
13380       struct reloc_howto_struct alt_howto;
13381
13382     again:
13383       orig_rel = *rel;
13384
13385       r_type = ELF64_R_TYPE (rel->r_info);
13386       r_symndx = ELF64_R_SYM (rel->r_info);
13387
13388       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
13389          symbol of the previous ADDR64 reloc.  The symbol gives us the
13390          proper TOC base to use.  */
13391       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
13392           && wrel != relocs
13393           && ELF64_R_TYPE (wrel[-1].r_info) == R_PPC64_ADDR64
13394           && is_opd)
13395         r_symndx = ELF64_R_SYM (wrel[-1].r_info);
13396
13397       sym = NULL;
13398       sec = NULL;
13399       h_elf = NULL;
13400       sym_name = NULL;
13401       unresolved_reloc = FALSE;
13402       warned = FALSE;
13403
13404       if (r_symndx < symtab_hdr->sh_info)
13405         {
13406           /* It's a local symbol.  */
13407           struct _opd_sec_data *opd;
13408
13409           sym = local_syms + r_symndx;
13410           sec = local_sections[r_symndx];
13411           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
13412           sym_type = ELF64_ST_TYPE (sym->st_info);
13413           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
13414           opd = get_opd_info (sec);
13415           if (opd != NULL && opd->adjust != NULL)
13416             {
13417               long adjust = opd->adjust[OPD_NDX (sym->st_value
13418                                                  + rel->r_addend)];
13419               if (adjust == -1)
13420                 relocation = 0;
13421               else
13422                 {
13423                   /* If this is a relocation against the opd section sym
13424                      and we have edited .opd, adjust the reloc addend so
13425                      that ld -r and ld --emit-relocs output is correct.
13426                      If it is a reloc against some other .opd symbol,
13427                      then the symbol value will be adjusted later.  */
13428                   if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
13429                     rel->r_addend += adjust;
13430                   else
13431                     relocation += adjust;
13432                 }
13433             }
13434         }
13435       else
13436         {
13437           bfd_boolean ignored;
13438
13439           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
13440                                    r_symndx, symtab_hdr, sym_hashes,
13441                                    h_elf, sec, relocation,
13442                                    unresolved_reloc, warned, ignored);
13443           sym_name = h_elf->root.root.string;
13444           sym_type = h_elf->type;
13445           if (sec != NULL
13446               && sec->owner == output_bfd
13447               && strcmp (sec->name, ".opd") == 0)
13448             {
13449               /* This is a symbol defined in a linker script.  All
13450                  such are defined in output sections, even those
13451                  defined by simple assignment from a symbol defined in
13452                  an input section.  Transfer the symbol to an
13453                  appropriate input .opd section, so that a branch to
13454                  this symbol will be mapped to the location specified
13455                  by the opd entry.  */
13456               struct bfd_link_order *lo;
13457               for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
13458                 if (lo->type == bfd_indirect_link_order)
13459                   {
13460                     asection *isec = lo->u.indirect.section;
13461                     if (h_elf->root.u.def.value >= isec->output_offset
13462                         && h_elf->root.u.def.value < (isec->output_offset
13463                                                       + isec->size))
13464                       {
13465                         h_elf->root.u.def.value -= isec->output_offset;
13466                         h_elf->root.u.def.section = isec;
13467                         sec = isec;
13468                         break;
13469                       }
13470                   }
13471             }
13472         }
13473       h = (struct ppc_link_hash_entry *) h_elf;
13474
13475       if (sec != NULL && discarded_section (sec))
13476         {
13477           _bfd_clear_contents (ppc64_elf_howto_table[r_type],
13478                                input_bfd, input_section,
13479                                contents + rel->r_offset);
13480           wrel->r_offset = rel->r_offset;
13481           wrel->r_info = 0;
13482           wrel->r_addend = 0;
13483
13484           /* For ld -r, remove relocations in debug sections against
13485              sections defined in discarded sections.  Not done for
13486              non-debug to preserve relocs in .eh_frame which the
13487              eh_frame editing code expects to be present.  */
13488           if (bfd_link_relocatable (info)
13489               && (input_section->flags & SEC_DEBUGGING))
13490             wrel--;
13491
13492           continue;
13493         }
13494
13495       if (bfd_link_relocatable (info))
13496         goto copy_reloc;
13497
13498       if (h != NULL && &h->elf == htab->elf.hgot)
13499         {
13500           relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
13501           sec = bfd_abs_section_ptr;
13502           unresolved_reloc = FALSE;
13503         }
13504
13505       /* TLS optimizations.  Replace instruction sequences and relocs
13506          based on information we collected in tls_optimize.  We edit
13507          RELOCS so that --emit-relocs will output something sensible
13508          for the final instruction stream.  */
13509       tls_mask = 0;
13510       tls_gd = 0;
13511       toc_symndx = 0;
13512       if (h != NULL)
13513         tls_mask = h->tls_mask;
13514       else if (local_got_ents != NULL)
13515         {
13516           struct plt_entry **local_plt = (struct plt_entry **)
13517             (local_got_ents + symtab_hdr->sh_info);
13518           unsigned char *lgot_masks = (unsigned char *)
13519             (local_plt + symtab_hdr->sh_info);
13520           tls_mask = lgot_masks[r_symndx];
13521         }
13522       if (tls_mask == 0
13523           && (r_type == R_PPC64_TLS
13524               || r_type == R_PPC64_TLSGD
13525               || r_type == R_PPC64_TLSLD))
13526         {
13527           /* Check for toc tls entries.  */
13528           unsigned char *toc_tls;
13529
13530           if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13531                              &local_syms, rel, input_bfd))
13532             return FALSE;
13533
13534           if (toc_tls)
13535             tls_mask = *toc_tls;
13536         }
13537
13538       /* Check that tls relocs are used with tls syms, and non-tls
13539          relocs are used with non-tls syms.  */
13540       if (r_symndx != STN_UNDEF
13541           && r_type != R_PPC64_NONE
13542           && (h == NULL
13543               || h->elf.root.type == bfd_link_hash_defined
13544               || h->elf.root.type == bfd_link_hash_defweak)
13545           && (IS_PPC64_TLS_RELOC (r_type)
13546               != (sym_type == STT_TLS
13547                   || (sym_type == STT_SECTION
13548                       && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13549         {
13550           if (tls_mask != 0
13551               && (r_type == R_PPC64_TLS
13552                   || r_type == R_PPC64_TLSGD
13553                   || r_type == R_PPC64_TLSLD))
13554             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
13555             ;
13556           else
13557             info->callbacks->einfo
13558               (!IS_PPC64_TLS_RELOC (r_type)
13559                ? _("%P: %H: %s used with TLS symbol `%T'\n")
13560                : _("%P: %H: %s used with non-TLS symbol `%T'\n"),
13561                input_bfd, input_section, rel->r_offset,
13562                ppc64_elf_howto_table[r_type]->name,
13563                sym_name);
13564         }
13565
13566       /* Ensure reloc mapping code below stays sane.  */
13567       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13568           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13569           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
13570           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13571           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13572           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13573           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
13574           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13575           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13576           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13577         abort ();
13578
13579       switch (r_type)
13580         {
13581         default:
13582           break;
13583
13584         case R_PPC64_LO_DS_OPT:
13585           insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13586           if ((insn & (0x3f << 26)) != 58u << 26)
13587             abort ();
13588           insn += (14u << 26) - (58u << 26);
13589           bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13590           r_type = R_PPC64_TOC16_LO;
13591           rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13592           break;
13593
13594         case R_PPC64_TOC16:
13595         case R_PPC64_TOC16_LO:
13596         case R_PPC64_TOC16_DS:
13597         case R_PPC64_TOC16_LO_DS:
13598           {
13599             /* Check for toc tls entries.  */
13600             unsigned char *toc_tls;
13601             int retval;
13602
13603             retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13604                                    &local_syms, rel, input_bfd);
13605             if (retval == 0)
13606               return FALSE;
13607
13608             if (toc_tls)
13609               {
13610                 tls_mask = *toc_tls;
13611                 if (r_type == R_PPC64_TOC16_DS
13612                     || r_type == R_PPC64_TOC16_LO_DS)
13613                   {
13614                     if (tls_mask != 0
13615                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13616                       goto toctprel;
13617                   }
13618                 else
13619                   {
13620                     /* If we found a GD reloc pair, then we might be
13621                        doing a GD->IE transition.  */
13622                     if (retval == 2)
13623                       {
13624                         tls_gd = TLS_TPRELGD;
13625                         if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13626                           goto tls_ldgd_opt;
13627                       }
13628                     else if (retval == 3)
13629                       {
13630                         if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13631                           goto tls_ldgd_opt;
13632                       }
13633                   }
13634               }
13635           }
13636           break;
13637
13638         case R_PPC64_GOT_TPREL16_HI:
13639         case R_PPC64_GOT_TPREL16_HA:
13640           if (tls_mask != 0
13641               && (tls_mask & TLS_TPREL) == 0)
13642             {
13643               rel->r_offset -= d_offset;
13644               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13645               r_type = R_PPC64_NONE;
13646               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13647             }
13648           break;
13649
13650         case R_PPC64_GOT_TPREL16_DS:
13651         case R_PPC64_GOT_TPREL16_LO_DS:
13652           if (tls_mask != 0
13653               && (tls_mask & TLS_TPREL) == 0)
13654             {
13655             toctprel:
13656               insn = bfd_get_32 (output_bfd,
13657                                  contents + rel->r_offset - d_offset);
13658               insn &= 31 << 21;
13659               insn |= 0x3c0d0000;       /* addis 0,13,0 */
13660               bfd_put_32 (output_bfd, insn,
13661                           contents + rel->r_offset - d_offset);
13662               r_type = R_PPC64_TPREL16_HA;
13663               if (toc_symndx != 0)
13664                 {
13665                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13666                   rel->r_addend = toc_addend;
13667                   /* We changed the symbol.  Start over in order to
13668                      get h, sym, sec etc. right.  */
13669                   goto again;
13670                 }
13671               else
13672                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13673             }
13674           break;
13675
13676         case R_PPC64_TLS:
13677           if (tls_mask != 0
13678               && (tls_mask & TLS_TPREL) == 0)
13679             {
13680               insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
13681               insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13682               if (insn == 0)
13683                 abort ();
13684               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13685               /* Was PPC64_TLS which sits on insn boundary, now
13686                  PPC64_TPREL16_LO which is at low-order half-word.  */
13687               rel->r_offset += d_offset;
13688               r_type = R_PPC64_TPREL16_LO;
13689               if (toc_symndx != 0)
13690                 {
13691                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13692                   rel->r_addend = toc_addend;
13693                   /* We changed the symbol.  Start over in order to
13694                      get h, sym, sec etc. right.  */
13695                   goto again;
13696                 }
13697               else
13698                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13699             }
13700           break;
13701
13702         case R_PPC64_GOT_TLSGD16_HI:
13703         case R_PPC64_GOT_TLSGD16_HA:
13704           tls_gd = TLS_TPRELGD;
13705           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13706             goto tls_gdld_hi;
13707           break;
13708
13709         case R_PPC64_GOT_TLSLD16_HI:
13710         case R_PPC64_GOT_TLSLD16_HA:
13711           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13712             {
13713             tls_gdld_hi:
13714               if ((tls_mask & tls_gd) != 0)
13715                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13716                           + R_PPC64_GOT_TPREL16_DS);
13717               else
13718                 {
13719                   rel->r_offset -= d_offset;
13720                   bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13721                   r_type = R_PPC64_NONE;
13722                 }
13723               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13724             }
13725           break;
13726
13727         case R_PPC64_GOT_TLSGD16:
13728         case R_PPC64_GOT_TLSGD16_LO:
13729           tls_gd = TLS_TPRELGD;
13730           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13731             goto tls_ldgd_opt;
13732           break;
13733
13734         case R_PPC64_GOT_TLSLD16:
13735         case R_PPC64_GOT_TLSLD16_LO:
13736           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13737             {
13738               unsigned int insn1, insn2, insn3;
13739               bfd_vma offset;
13740
13741             tls_ldgd_opt:
13742               offset = (bfd_vma) -1;
13743               /* If not using the newer R_PPC64_TLSGD/LD to mark
13744                  __tls_get_addr calls, we must trust that the call
13745                  stays with its arg setup insns, ie. that the next
13746                  reloc is the __tls_get_addr call associated with
13747                  the current reloc.  Edit both insns.  */
13748               if (input_section->has_tls_get_addr_call
13749                   && rel + 1 < relend
13750                   && branch_reloc_hash_match (input_bfd, rel + 1,
13751                                               htab->tls_get_addr,
13752                                               htab->tls_get_addr_fd))
13753                 offset = rel[1].r_offset;
13754               /* We read the low GOT_TLS (or TOC16) insn because we
13755                  need to keep the destination reg.  It may be
13756                  something other than the usual r3, and moved to r3
13757                  before the call by intervening code.  */
13758               insn1 = bfd_get_32 (output_bfd,
13759                                   contents + rel->r_offset - d_offset);
13760               if ((tls_mask & tls_gd) != 0)
13761                 {
13762                   /* IE */
13763                   insn1 &= (0x1f << 21) | (0x1f << 16);
13764                   insn1 |= 58 << 26;    /* ld */
13765                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13766                   if (offset != (bfd_vma) -1)
13767                     rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13768                   if ((tls_mask & TLS_EXPLICIT) == 0)
13769                     r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13770                               + R_PPC64_GOT_TPREL16_DS);
13771                   else
13772                     r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13773                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13774                 }
13775               else
13776                 {
13777                   /* LE */
13778                   insn1 &= 0x1f << 21;
13779                   insn1 |= 0x3c0d0000;  /* addis r,13,0 */
13780                   insn2 = 0x38630000;   /* addi 3,3,0 */
13781                   if (tls_gd == 0)
13782                     {
13783                       /* Was an LD reloc.  */
13784                       if (toc_symndx)
13785                         sec = local_sections[toc_symndx];
13786                       for (r_symndx = 0;
13787                            r_symndx < symtab_hdr->sh_info;
13788                            r_symndx++)
13789                         if (local_sections[r_symndx] == sec)
13790                           break;
13791                       if (r_symndx >= symtab_hdr->sh_info)
13792                         r_symndx = STN_UNDEF;
13793                       rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13794                       if (r_symndx != STN_UNDEF)
13795                         rel->r_addend -= (local_syms[r_symndx].st_value
13796                                           + sec->output_offset
13797                                           + sec->output_section->vma);
13798                     }
13799                   else if (toc_symndx != 0)
13800                     {
13801                       r_symndx = toc_symndx;
13802                       rel->r_addend = toc_addend;
13803                     }
13804                   r_type = R_PPC64_TPREL16_HA;
13805                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13806                   if (offset != (bfd_vma) -1)
13807                     {
13808                       rel[1].r_info = ELF64_R_INFO (r_symndx,
13809                                                     R_PPC64_TPREL16_LO);
13810                       rel[1].r_offset = offset + d_offset;
13811                       rel[1].r_addend = rel->r_addend;
13812                     }
13813                 }
13814               bfd_put_32 (output_bfd, insn1,
13815                           contents + rel->r_offset - d_offset);
13816               if (offset != (bfd_vma) -1)
13817                 {
13818                   insn3 = bfd_get_32 (output_bfd,
13819                                       contents + offset + 4);
13820                   if (insn3 == NOP
13821                       || insn3 == CROR_151515 || insn3 == CROR_313131)
13822                     {
13823                       rel[1].r_offset += 4;
13824                       bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13825                       insn2 = NOP;
13826                     }
13827                   bfd_put_32 (output_bfd, insn2, contents + offset);
13828                 }
13829               if ((tls_mask & tls_gd) == 0
13830                   && (tls_gd == 0 || toc_symndx != 0))
13831                 {
13832                   /* We changed the symbol.  Start over in order
13833                      to get h, sym, sec etc. right.  */
13834                   goto again;
13835                 }
13836             }
13837           break;
13838
13839         case R_PPC64_TLSGD:
13840           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13841             {
13842               unsigned int insn2, insn3;
13843               bfd_vma offset = rel->r_offset;
13844
13845               if ((tls_mask & TLS_TPRELGD) != 0)
13846                 {
13847                   /* IE */
13848                   r_type = R_PPC64_NONE;
13849                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13850                 }
13851               else
13852                 {
13853                   /* LE */
13854                   if (toc_symndx != 0)
13855                     {
13856                       r_symndx = toc_symndx;
13857                       rel->r_addend = toc_addend;
13858                     }
13859                   r_type = R_PPC64_TPREL16_LO;
13860                   rel->r_offset = offset + d_offset;
13861                   insn2 = 0x38630000;   /* addi 3,3,0 */
13862                 }
13863               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13864               /* Zap the reloc on the _tls_get_addr call too.  */
13865               BFD_ASSERT (offset == rel[1].r_offset);
13866               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13867               insn3 = bfd_get_32 (output_bfd,
13868                                   contents + offset + 4);
13869               if (insn3 == NOP
13870                   || insn3 == CROR_151515 || insn3 == CROR_313131)
13871                 {
13872                   rel->r_offset += 4;
13873                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13874                   insn2 = NOP;
13875                 }
13876               bfd_put_32 (output_bfd, insn2, contents + offset);
13877               if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
13878                 goto again;
13879             }
13880           break;
13881
13882         case R_PPC64_TLSLD:
13883           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13884             {
13885               unsigned int insn2, insn3;
13886               bfd_vma offset = rel->r_offset;
13887
13888               if (toc_symndx)
13889                 sec = local_sections[toc_symndx];
13890               for (r_symndx = 0;
13891                    r_symndx < symtab_hdr->sh_info;
13892                    r_symndx++)
13893                 if (local_sections[r_symndx] == sec)
13894                   break;
13895               if (r_symndx >= symtab_hdr->sh_info)
13896                 r_symndx = STN_UNDEF;
13897               rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13898               if (r_symndx != STN_UNDEF)
13899                 rel->r_addend -= (local_syms[r_symndx].st_value
13900                                   + sec->output_offset
13901                                   + sec->output_section->vma);
13902
13903               r_type = R_PPC64_TPREL16_LO;
13904               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13905               rel->r_offset = offset + d_offset;
13906               /* Zap the reloc on the _tls_get_addr call too.  */
13907               BFD_ASSERT (offset == rel[1].r_offset);
13908               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13909               insn2 = 0x38630000;       /* addi 3,3,0 */
13910               insn3 = bfd_get_32 (output_bfd,
13911                                   contents + offset + 4);
13912               if (insn3 == NOP
13913                   || insn3 == CROR_151515 || insn3 == CROR_313131)
13914                 {
13915                   rel->r_offset += 4;
13916                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13917                   insn2 = NOP;
13918                 }
13919               bfd_put_32 (output_bfd, insn2, contents + offset);
13920               goto again;
13921             }
13922           break;
13923
13924         case R_PPC64_DTPMOD64:
13925           if (rel + 1 < relend
13926               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
13927               && rel[1].r_offset == rel->r_offset + 8)
13928             {
13929               if ((tls_mask & TLS_GD) == 0)
13930                 {
13931                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
13932                   if ((tls_mask & TLS_TPRELGD) != 0)
13933                     r_type = R_PPC64_TPREL64;
13934                   else
13935                     {
13936                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13937                       r_type = R_PPC64_NONE;
13938                     }
13939                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13940                 }
13941             }
13942           else
13943             {
13944               if ((tls_mask & TLS_LD) == 0)
13945                 {
13946                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13947                   r_type = R_PPC64_NONE;
13948                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13949                 }
13950             }
13951           break;
13952
13953         case R_PPC64_TPREL64:
13954           if ((tls_mask & TLS_TPREL) == 0)
13955             {
13956               r_type = R_PPC64_NONE;
13957               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13958             }
13959           break;
13960
13961         case R_PPC64_ENTRY:
13962           relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
13963           if (!bfd_link_pic (info)
13964               && !info->traditional_format
13965               && relocation + 0x80008000 <= 0xffffffff)
13966             {
13967               unsigned int insn1, insn2;
13968
13969               insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
13970               insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
13971               if ((insn1 & ~0xfffc) == LD_R2_0R12
13972                   && insn2 == ADD_R2_R2_R12)
13973                 {
13974                   bfd_put_32 (output_bfd,
13975                               LIS_R2 + PPC_HA (relocation),
13976                               contents + rel->r_offset);
13977                   bfd_put_32 (output_bfd,
13978                               ADDI_R2_R2 + PPC_LO (relocation),
13979                               contents + rel->r_offset + 4);
13980                 }
13981             }
13982           else
13983             {
13984               relocation -= (rel->r_offset
13985                              + input_section->output_offset
13986                              + input_section->output_section->vma);
13987               if (relocation + 0x80008000 <= 0xffffffff)
13988                 {
13989                   unsigned int insn1, insn2;
13990
13991                   insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
13992                   insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
13993                   if ((insn1 & ~0xfffc) == LD_R2_0R12
13994                       && insn2 == ADD_R2_R2_R12)
13995                     {
13996                       bfd_put_32 (output_bfd,
13997                                   ADDIS_R2_R12 + PPC_HA (relocation),
13998                                   contents + rel->r_offset);
13999                       bfd_put_32 (output_bfd,
14000                                   ADDI_R2_R2 + PPC_LO (relocation),
14001                                   contents + rel->r_offset + 4);
14002                     }
14003                 }
14004             }
14005           break;
14006
14007         case R_PPC64_REL16_HA:
14008           /* If we are generating a non-PIC executable, edit
14009              .  0:      addis 2,12,.TOC.-0b@ha
14010              .          addi 2,2,.TOC.-0b@l
14011              used by ELFv2 global entry points to set up r2, to
14012              .          lis 2,.TOC.@ha
14013              .          addi 2,2,.TOC.@l
14014              if .TOC. is in range.  */
14015           if (!bfd_link_pic (info)
14016               && !info->traditional_format
14017               && !htab->opd_abi
14018               && rel->r_addend == d_offset
14019               && h != NULL && &h->elf == htab->elf.hgot
14020               && rel + 1 < relend
14021               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
14022               && rel[1].r_offset == rel->r_offset + 4
14023               && rel[1].r_addend == rel->r_addend + 4
14024               && relocation + 0x80008000 <= 0xffffffff)
14025             {
14026               unsigned int insn1, insn2;
14027               bfd_vma offset = rel->r_offset - d_offset;
14028               insn1 = bfd_get_32 (output_bfd, contents + offset);
14029               insn2 = bfd_get_32 (output_bfd, contents + offset + 4);
14030               if ((insn1 & 0xffff0000) == ADDIS_R2_R12
14031                   && (insn2 & 0xffff0000) == ADDI_R2_R2)
14032                 {
14033                   r_type = R_PPC64_ADDR16_HA;
14034                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14035                   rel->r_addend -= d_offset;
14036                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
14037                   rel[1].r_addend -= d_offset + 4;
14038                   bfd_put_32 (output_bfd, LIS_R2, contents + offset);
14039                 }
14040             }
14041           break;
14042         }
14043
14044       /* Handle other relocations that tweak non-addend part of insn.  */
14045       insn = 0;
14046       max_br_offset = 1 << 25;
14047       addend = rel->r_addend;
14048       reloc_dest = DEST_NORMAL;
14049       switch (r_type)
14050         {
14051         default:
14052           break;
14053
14054         case R_PPC64_TOCSAVE:
14055           if (relocation + addend == (rel->r_offset
14056                                       + input_section->output_offset
14057                                       + input_section->output_section->vma)
14058               && tocsave_find (htab, NO_INSERT,
14059                                &local_syms, rel, input_bfd))
14060             {
14061               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
14062               if (insn == NOP
14063                   || insn == CROR_151515 || insn == CROR_313131)
14064                 bfd_put_32 (input_bfd,
14065                             STD_R2_0R1 + STK_TOC (htab),
14066                             contents + rel->r_offset);
14067             }
14068           break;
14069
14070           /* Branch taken prediction relocations.  */
14071         case R_PPC64_ADDR14_BRTAKEN:
14072         case R_PPC64_REL14_BRTAKEN:
14073           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
14074           /* Fall thru.  */
14075
14076           /* Branch not taken prediction relocations.  */
14077         case R_PPC64_ADDR14_BRNTAKEN:
14078         case R_PPC64_REL14_BRNTAKEN:
14079           insn |= bfd_get_32 (output_bfd,
14080                               contents + rel->r_offset) & ~(0x01 << 21);
14081           /* Fall thru.  */
14082
14083         case R_PPC64_REL14:
14084           max_br_offset = 1 << 15;
14085           /* Fall thru.  */
14086
14087         case R_PPC64_REL24:
14088           /* Calls to functions with a different TOC, such as calls to
14089              shared objects, need to alter the TOC pointer.  This is
14090              done using a linkage stub.  A REL24 branching to these
14091              linkage stubs needs to be followed by a nop, as the nop
14092              will be replaced with an instruction to restore the TOC
14093              base pointer.  */
14094           fdh = h;
14095           if (h != NULL
14096               && h->oh != NULL
14097               && h->oh->is_func_descriptor)
14098             fdh = ppc_follow_link (h->oh);
14099           stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
14100                                            htab);
14101           if (stub_entry != NULL
14102               && (stub_entry->stub_type == ppc_stub_plt_call
14103                   || stub_entry->stub_type == ppc_stub_plt_call_r2save
14104                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
14105                   || stub_entry->stub_type == ppc_stub_long_branch_r2off))
14106             {
14107               bfd_boolean can_plt_call = FALSE;
14108
14109               /* All of these stubs will modify r2, so there must be a
14110                  branch and link followed by a nop.  The nop is
14111                  replaced by an insn to restore r2.  */
14112               if (rel->r_offset + 8 <= input_section->size)
14113                 {
14114                   unsigned long br;
14115
14116                   br = bfd_get_32 (input_bfd,
14117                                    contents + rel->r_offset);
14118                   if ((br & 1) != 0)
14119                     {
14120                       unsigned long nop;
14121
14122                       nop = bfd_get_32 (input_bfd,
14123                                         contents + rel->r_offset + 4);
14124                       if (nop == NOP
14125                           || nop == CROR_151515 || nop == CROR_313131)
14126                         {
14127                           if (h != NULL
14128                               && (h == htab->tls_get_addr_fd
14129                                   || h == htab->tls_get_addr)
14130                               && htab->params->tls_get_addr_opt)
14131                             {
14132                               /* Special stub used, leave nop alone.  */
14133                             }
14134                           else
14135                             bfd_put_32 (input_bfd,
14136                                         LD_R2_0R1 + STK_TOC (htab),
14137                                         contents + rel->r_offset + 4);
14138                           can_plt_call = TRUE;
14139                         }
14140                     }
14141                 }
14142
14143               if (!can_plt_call && h != NULL)
14144                 {
14145                   const char *name = h->elf.root.root.string;
14146
14147                   if (*name == '.')
14148                     ++name;
14149
14150                   if (strncmp (name, "__libc_start_main", 17) == 0
14151                       && (name[17] == 0 || name[17] == '@'))
14152                     {
14153                       /* Allow crt1 branch to go via a toc adjusting
14154                          stub.  Other calls that never return could do
14155                          the same, if we could detect such.  */
14156                       can_plt_call = TRUE;
14157                     }
14158                 }
14159
14160               if (!can_plt_call)
14161                 {
14162                   /* g++ as of 20130507 emits self-calls without a
14163                      following nop.  This is arguably wrong since we
14164                      have conflicting information.  On the one hand a
14165                      global symbol and on the other a local call
14166                      sequence, but don't error for this special case.
14167                      It isn't possible to cheaply verify we have
14168                      exactly such a call.  Allow all calls to the same
14169                      section.  */
14170                   asection *code_sec = sec;
14171
14172                   if (get_opd_info (sec) != NULL)
14173                     {
14174                       bfd_vma off = (relocation + addend
14175                                      - sec->output_section->vma
14176                                      - sec->output_offset);
14177
14178                       opd_entry_value (sec, off, &code_sec, NULL, FALSE);
14179                     }
14180                   if (code_sec == input_section)
14181                     can_plt_call = TRUE;
14182                 }
14183
14184               if (!can_plt_call)
14185                 {
14186                   if (stub_entry->stub_type == ppc_stub_plt_call
14187                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14188                     info->callbacks->einfo
14189                       (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
14190                          "recompile with -fPIC\n"),
14191                        input_bfd, input_section, rel->r_offset, sym_name);
14192                   else
14193                     info->callbacks->einfo
14194                       (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
14195                          "(-mcmodel=small toc adjust stub)\n"),
14196                        input_bfd, input_section, rel->r_offset, sym_name);
14197
14198                   bfd_set_error (bfd_error_bad_value);
14199                   ret = FALSE;
14200                 }
14201
14202               if (can_plt_call
14203                   && (stub_entry->stub_type == ppc_stub_plt_call
14204                       || stub_entry->stub_type == ppc_stub_plt_call_r2save))
14205                 unresolved_reloc = FALSE;
14206             }
14207
14208           if ((stub_entry == NULL
14209                || stub_entry->stub_type == ppc_stub_long_branch
14210                || stub_entry->stub_type == ppc_stub_plt_branch)
14211               && get_opd_info (sec) != NULL)
14212             {
14213               /* The branch destination is the value of the opd entry. */
14214               bfd_vma off = (relocation + addend
14215                              - sec->output_section->vma
14216                              - sec->output_offset);
14217               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
14218               if (dest != (bfd_vma) -1)
14219                 {
14220                   relocation = dest;
14221                   addend = 0;
14222                   reloc_dest = DEST_OPD;
14223                 }
14224             }
14225
14226           /* If the branch is out of reach we ought to have a long
14227              branch stub.  */
14228           from = (rel->r_offset
14229                   + input_section->output_offset
14230                   + input_section->output_section->vma);
14231
14232           relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
14233                                                   ? fdh->elf.other
14234                                                   : sym->st_other);
14235
14236           if (stub_entry != NULL
14237               && (stub_entry->stub_type == ppc_stub_long_branch
14238                   || stub_entry->stub_type == ppc_stub_plt_branch)
14239               && (r_type == R_PPC64_ADDR14_BRTAKEN
14240                   || r_type == R_PPC64_ADDR14_BRNTAKEN
14241                   || (relocation + addend - from + max_br_offset
14242                       < 2 * max_br_offset)))
14243             /* Don't use the stub if this branch is in range.  */
14244             stub_entry = NULL;
14245
14246           if (stub_entry != NULL)
14247             {
14248               /* Munge up the value and addend so that we call the stub
14249                  rather than the procedure directly.  */
14250               asection *stub_sec = stub_entry->group->stub_sec;
14251
14252               if (stub_entry->stub_type == ppc_stub_save_res)
14253                 relocation += (stub_sec->output_offset
14254                                + stub_sec->output_section->vma
14255                                + stub_sec->size - htab->sfpr->size
14256                                - htab->sfpr->output_offset
14257                                - htab->sfpr->output_section->vma);
14258               else
14259                 relocation = (stub_entry->stub_offset
14260                               + stub_sec->output_offset
14261                               + stub_sec->output_section->vma);
14262               addend = 0;
14263               reloc_dest = DEST_STUB;
14264
14265               if ((stub_entry->stub_type == ppc_stub_plt_call
14266                    || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14267                   && (ALWAYS_EMIT_R2SAVE
14268                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14269                   && rel + 1 < relend
14270                   && rel[1].r_offset == rel->r_offset + 4
14271                   && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
14272                 relocation += 4;
14273             }
14274
14275           if (insn != 0)
14276             {
14277               if (is_isa_v2)
14278                 {
14279                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
14280                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
14281                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
14282                   if ((insn & (0x14 << 21)) == (0x04 << 21))
14283                     insn |= 0x02 << 21;
14284                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
14285                     insn |= 0x08 << 21;
14286                   else
14287                     break;
14288                 }
14289               else
14290                 {
14291                   /* Invert 'y' bit if not the default.  */
14292                   if ((bfd_signed_vma) (relocation + addend - from) < 0)
14293                     insn ^= 0x01 << 21;
14294                 }
14295
14296               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
14297             }
14298
14299           /* NOP out calls to undefined weak functions.
14300              We can thus call a weak function without first
14301              checking whether the function is defined.  */
14302           else if (h != NULL
14303                    && h->elf.root.type == bfd_link_hash_undefweak
14304                    && h->elf.dynindx == -1
14305                    && r_type == R_PPC64_REL24
14306                    && relocation == 0
14307                    && addend == 0)
14308             {
14309               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
14310               goto copy_reloc;
14311             }
14312           break;
14313         }
14314
14315       /* Set `addend'.  */
14316       tls_type = 0;
14317       switch (r_type)
14318         {
14319         default:
14320           info->callbacks->einfo
14321             (_("%P: %B: unknown relocation type %d for `%T'\n"),
14322              input_bfd, (int) r_type, sym_name);
14323
14324           bfd_set_error (bfd_error_bad_value);
14325           ret = FALSE;
14326           goto copy_reloc;
14327
14328         case R_PPC64_NONE:
14329         case R_PPC64_TLS:
14330         case R_PPC64_TLSGD:
14331         case R_PPC64_TLSLD:
14332         case R_PPC64_TOCSAVE:
14333         case R_PPC64_GNU_VTINHERIT:
14334         case R_PPC64_GNU_VTENTRY:
14335         case R_PPC64_ENTRY:
14336           goto copy_reloc;
14337
14338           /* GOT16 relocations.  Like an ADDR16 using the symbol's
14339              address in the GOT as relocation value instead of the
14340              symbol's value itself.  Also, create a GOT entry for the
14341              symbol and put the symbol value there.  */
14342         case R_PPC64_GOT_TLSGD16:
14343         case R_PPC64_GOT_TLSGD16_LO:
14344         case R_PPC64_GOT_TLSGD16_HI:
14345         case R_PPC64_GOT_TLSGD16_HA:
14346           tls_type = TLS_TLS | TLS_GD;
14347           goto dogot;
14348
14349         case R_PPC64_GOT_TLSLD16:
14350         case R_PPC64_GOT_TLSLD16_LO:
14351         case R_PPC64_GOT_TLSLD16_HI:
14352         case R_PPC64_GOT_TLSLD16_HA:
14353           tls_type = TLS_TLS | TLS_LD;
14354           goto dogot;
14355
14356         case R_PPC64_GOT_TPREL16_DS:
14357         case R_PPC64_GOT_TPREL16_LO_DS:
14358         case R_PPC64_GOT_TPREL16_HI:
14359         case R_PPC64_GOT_TPREL16_HA:
14360           tls_type = TLS_TLS | TLS_TPREL;
14361           goto dogot;
14362
14363         case R_PPC64_GOT_DTPREL16_DS:
14364         case R_PPC64_GOT_DTPREL16_LO_DS:
14365         case R_PPC64_GOT_DTPREL16_HI:
14366         case R_PPC64_GOT_DTPREL16_HA:
14367           tls_type = TLS_TLS | TLS_DTPREL;
14368           goto dogot;
14369
14370         case R_PPC64_GOT16:
14371         case R_PPC64_GOT16_LO:
14372         case R_PPC64_GOT16_HI:
14373         case R_PPC64_GOT16_HA:
14374         case R_PPC64_GOT16_DS:
14375         case R_PPC64_GOT16_LO_DS:
14376         dogot:
14377           {
14378             /* Relocation is to the entry for this symbol in the global
14379                offset table.  */
14380             asection *got;
14381             bfd_vma *offp;
14382             bfd_vma off;
14383             unsigned long indx = 0;
14384             struct got_entry *ent;
14385
14386             if (tls_type == (TLS_TLS | TLS_LD)
14387                 && (h == NULL
14388                     || !h->elf.def_dynamic))
14389               ent = ppc64_tlsld_got (input_bfd);
14390             else
14391               {
14392
14393                 if (h != NULL)
14394                   {
14395                     bfd_boolean dyn = htab->elf.dynamic_sections_created;
14396                     if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info),
14397                                                           &h->elf)
14398                         || (bfd_link_pic (info)
14399                             && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
14400                       /* This is actually a static link, or it is a
14401                          -Bsymbolic link and the symbol is defined
14402                          locally, or the symbol was forced to be local
14403                          because of a version file.  */
14404                       ;
14405                     else
14406                       {
14407                         BFD_ASSERT (h->elf.dynindx != -1);
14408                         indx = h->elf.dynindx;
14409                         unresolved_reloc = FALSE;
14410                       }
14411                     ent = h->elf.got.glist;
14412                   }
14413                 else
14414                   {
14415                     if (local_got_ents == NULL)
14416                       abort ();
14417                     ent = local_got_ents[r_symndx];
14418                   }
14419
14420                 for (; ent != NULL; ent = ent->next)
14421                   if (ent->addend == orig_rel.r_addend
14422                       && ent->owner == input_bfd
14423                       && ent->tls_type == tls_type)
14424                     break;
14425               }
14426
14427             if (ent == NULL)
14428               abort ();
14429             if (ent->is_indirect)
14430               ent = ent->got.ent;
14431             offp = &ent->got.offset;
14432             got = ppc64_elf_tdata (ent->owner)->got;
14433             if (got == NULL)
14434               abort ();
14435
14436             /* The offset must always be a multiple of 8.  We use the
14437                least significant bit to record whether we have already
14438                processed this entry.  */
14439             off = *offp;
14440             if ((off & 1) != 0)
14441               off &= ~1;
14442             else
14443               {
14444                 /* Generate relocs for the dynamic linker, except in
14445                    the case of TLSLD where we'll use one entry per
14446                    module.  */
14447                 asection *relgot;
14448                 bfd_boolean ifunc;
14449
14450                 *offp = off | 1;
14451                 relgot = NULL;
14452                 ifunc = (h != NULL
14453                          ? h->elf.type == STT_GNU_IFUNC
14454                          : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
14455                 if (ifunc)
14456                   relgot = htab->elf.irelplt;
14457                 else if ((bfd_link_pic (info) || indx != 0)
14458                          && (h == NULL
14459                              || (tls_type == (TLS_TLS | TLS_LD)
14460                                  && !h->elf.def_dynamic)
14461                              || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14462                              || h->elf.root.type != bfd_link_hash_undefweak))
14463                   relgot = ppc64_elf_tdata (ent->owner)->relgot;
14464                 if (relgot != NULL)
14465                   {
14466                     outrel.r_offset = (got->output_section->vma
14467                                        + got->output_offset
14468                                        + off);
14469                     outrel.r_addend = addend;
14470                     if (tls_type & (TLS_LD | TLS_GD))
14471                       {
14472                         outrel.r_addend = 0;
14473                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
14474                         if (tls_type == (TLS_TLS | TLS_GD))
14475                           {
14476                             loc = relgot->contents;
14477                             loc += (relgot->reloc_count++
14478                                     * sizeof (Elf64_External_Rela));
14479                             bfd_elf64_swap_reloca_out (output_bfd,
14480                                                        &outrel, loc);
14481                             outrel.r_offset += 8;
14482                             outrel.r_addend = addend;
14483                             outrel.r_info
14484                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14485                           }
14486                       }
14487                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
14488                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14489                     else if (tls_type == (TLS_TLS | TLS_TPREL))
14490                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
14491                     else if (indx != 0)
14492                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
14493                     else
14494                       {
14495                         if (ifunc)
14496                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14497                         else
14498                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14499
14500                         /* Write the .got section contents for the sake
14501                            of prelink.  */
14502                         loc = got->contents + off;
14503                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
14504                                     loc);
14505                       }
14506
14507                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
14508                       {
14509                         outrel.r_addend += relocation;
14510                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
14511                           {
14512                             if (htab->elf.tls_sec == NULL)
14513                               outrel.r_addend = 0;
14514                             else
14515                               outrel.r_addend -= htab->elf.tls_sec->vma;
14516                           }
14517                       }
14518                     loc = relgot->contents;
14519                     loc += (relgot->reloc_count++
14520                             * sizeof (Elf64_External_Rela));
14521                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14522                   }
14523
14524                 /* Init the .got section contents here if we're not
14525                    emitting a reloc.  */
14526                 else
14527                   {
14528                     relocation += addend;
14529                     if (tls_type == (TLS_TLS | TLS_LD))
14530                       relocation = 1;
14531                     else if (tls_type != 0)
14532                       {
14533                         if (htab->elf.tls_sec == NULL)
14534                           relocation = 0;
14535                         else
14536                           {
14537                             relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
14538                             if (tls_type == (TLS_TLS | TLS_TPREL))
14539                               relocation += DTP_OFFSET - TP_OFFSET;
14540                           }
14541
14542                         if (tls_type == (TLS_TLS | TLS_GD))
14543                           {
14544                             bfd_put_64 (output_bfd, relocation,
14545                                         got->contents + off + 8);
14546                             relocation = 1;
14547                           }
14548                       }
14549
14550                     bfd_put_64 (output_bfd, relocation,
14551                                 got->contents + off);
14552                   }
14553               }
14554
14555             if (off >= (bfd_vma) -2)
14556               abort ();
14557
14558             relocation = got->output_section->vma + got->output_offset + off;
14559             addend = -(TOCstart + htab->sec_info[input_section->id].toc_off);
14560           }
14561           break;
14562
14563         case R_PPC64_PLT16_HA:
14564         case R_PPC64_PLT16_HI:
14565         case R_PPC64_PLT16_LO:
14566         case R_PPC64_PLT32:
14567         case R_PPC64_PLT64:
14568           /* Relocation is to the entry for this symbol in the
14569              procedure linkage table.  */
14570           {
14571             struct plt_entry **plt_list = NULL;
14572             if (h != NULL)
14573               plt_list = &h->elf.plt.plist;
14574             else if (local_got_ents != NULL)
14575               {
14576                 struct plt_entry **local_plt = (struct plt_entry **)
14577                   (local_got_ents + symtab_hdr->sh_info);
14578                 unsigned char *local_got_tls_masks = (unsigned char *)
14579                   (local_plt + symtab_hdr->sh_info);
14580                 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
14581                   plt_list = local_plt + r_symndx;
14582               }
14583             if (plt_list)
14584               {
14585                 struct plt_entry *ent;
14586
14587                 for (ent = *plt_list; ent != NULL; ent = ent->next)
14588                   if (ent->plt.offset != (bfd_vma) -1
14589                       && ent->addend == orig_rel.r_addend)
14590                     {
14591                       asection *plt;
14592
14593                       plt = htab->elf.splt;
14594                       if (!htab->elf.dynamic_sections_created
14595                           || h == NULL
14596                           || h->elf.dynindx == -1)
14597                         plt = htab->elf.iplt;
14598                       relocation = (plt->output_section->vma
14599                                     + plt->output_offset
14600                                     + ent->plt.offset);
14601                       addend = 0;
14602                       unresolved_reloc = FALSE;
14603                       break;
14604                     }
14605               }
14606           }
14607           break;
14608
14609         case R_PPC64_TOC:
14610           /* Relocation value is TOC base.  */
14611           relocation = TOCstart;
14612           if (r_symndx == STN_UNDEF)
14613             relocation += htab->sec_info[input_section->id].toc_off;
14614           else if (unresolved_reloc)
14615             ;
14616           else if (sec != NULL && sec->id < htab->sec_info_arr_size)
14617             relocation += htab->sec_info[sec->id].toc_off;
14618           else
14619             unresolved_reloc = TRUE;
14620           goto dodyn;
14621
14622           /* TOC16 relocs.  We want the offset relative to the TOC base,
14623              which is the address of the start of the TOC plus 0x8000.
14624              The TOC consists of sections .got, .toc, .tocbss, and .plt,
14625              in this order.  */
14626         case R_PPC64_TOC16:
14627         case R_PPC64_TOC16_LO:
14628         case R_PPC64_TOC16_HI:
14629         case R_PPC64_TOC16_DS:
14630         case R_PPC64_TOC16_LO_DS:
14631         case R_PPC64_TOC16_HA:
14632           addend -= TOCstart + htab->sec_info[input_section->id].toc_off;
14633           break;
14634
14635           /* Relocate against the beginning of the section.  */
14636         case R_PPC64_SECTOFF:
14637         case R_PPC64_SECTOFF_LO:
14638         case R_PPC64_SECTOFF_HI:
14639         case R_PPC64_SECTOFF_DS:
14640         case R_PPC64_SECTOFF_LO_DS:
14641         case R_PPC64_SECTOFF_HA:
14642           if (sec != NULL)
14643             addend -= sec->output_section->vma;
14644           break;
14645
14646         case R_PPC64_REL16:
14647         case R_PPC64_REL16_LO:
14648         case R_PPC64_REL16_HI:
14649         case R_PPC64_REL16_HA:
14650         case R_PPC64_REL16DX_HA:
14651           break;
14652
14653         case R_PPC64_REL14:
14654         case R_PPC64_REL14_BRNTAKEN:
14655         case R_PPC64_REL14_BRTAKEN:
14656         case R_PPC64_REL24:
14657           break;
14658
14659         case R_PPC64_TPREL16:
14660         case R_PPC64_TPREL16_LO:
14661         case R_PPC64_TPREL16_HI:
14662         case R_PPC64_TPREL16_HA:
14663         case R_PPC64_TPREL16_DS:
14664         case R_PPC64_TPREL16_LO_DS:
14665         case R_PPC64_TPREL16_HIGH:
14666         case R_PPC64_TPREL16_HIGHA:
14667         case R_PPC64_TPREL16_HIGHER:
14668         case R_PPC64_TPREL16_HIGHERA:
14669         case R_PPC64_TPREL16_HIGHEST:
14670         case R_PPC64_TPREL16_HIGHESTA:
14671           if (h != NULL
14672               && h->elf.root.type == bfd_link_hash_undefweak
14673               && h->elf.dynindx == -1)
14674             {
14675               /* Make this relocation against an undefined weak symbol
14676                  resolve to zero.  This is really just a tweak, since
14677                  code using weak externs ought to check that they are
14678                  defined before using them.  */
14679               bfd_byte *p = contents + rel->r_offset - d_offset;
14680
14681               insn = bfd_get_32 (output_bfd, p);
14682               insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14683               if (insn != 0)
14684                 bfd_put_32 (output_bfd, insn, p);
14685               break;
14686             }
14687           if (htab->elf.tls_sec != NULL)
14688             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14689           if (bfd_link_pic (info))
14690             /* The TPREL16 relocs shouldn't really be used in shared
14691                libs as they will result in DT_TEXTREL being set, but
14692                support them anyway.  */
14693             goto dodyn;
14694           break;
14695
14696         case R_PPC64_DTPREL16:
14697         case R_PPC64_DTPREL16_LO:
14698         case R_PPC64_DTPREL16_HI:
14699         case R_PPC64_DTPREL16_HA:
14700         case R_PPC64_DTPREL16_DS:
14701         case R_PPC64_DTPREL16_LO_DS:
14702         case R_PPC64_DTPREL16_HIGH:
14703         case R_PPC64_DTPREL16_HIGHA:
14704         case R_PPC64_DTPREL16_HIGHER:
14705         case R_PPC64_DTPREL16_HIGHERA:
14706         case R_PPC64_DTPREL16_HIGHEST:
14707         case R_PPC64_DTPREL16_HIGHESTA:
14708           if (htab->elf.tls_sec != NULL)
14709             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14710           break;
14711
14712         case R_PPC64_ADDR64_LOCAL:
14713           addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
14714                                               ? h->elf.other
14715                                               : sym->st_other);
14716           break;
14717
14718         case R_PPC64_DTPMOD64:
14719           relocation = 1;
14720           addend = 0;
14721           goto dodyn;
14722
14723         case R_PPC64_TPREL64:
14724           if (htab->elf.tls_sec != NULL)
14725             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14726           goto dodyn;
14727
14728         case R_PPC64_DTPREL64:
14729           if (htab->elf.tls_sec != NULL)
14730             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14731           /* Fall thru */
14732
14733           /* Relocations that may need to be propagated if this is a
14734              dynamic object.  */
14735         case R_PPC64_REL30:
14736         case R_PPC64_REL32:
14737         case R_PPC64_REL64:
14738         case R_PPC64_ADDR14:
14739         case R_PPC64_ADDR14_BRNTAKEN:
14740         case R_PPC64_ADDR14_BRTAKEN:
14741         case R_PPC64_ADDR16:
14742         case R_PPC64_ADDR16_DS:
14743         case R_PPC64_ADDR16_HA:
14744         case R_PPC64_ADDR16_HI:
14745         case R_PPC64_ADDR16_HIGH:
14746         case R_PPC64_ADDR16_HIGHA:
14747         case R_PPC64_ADDR16_HIGHER:
14748         case R_PPC64_ADDR16_HIGHERA:
14749         case R_PPC64_ADDR16_HIGHEST:
14750         case R_PPC64_ADDR16_HIGHESTA:
14751         case R_PPC64_ADDR16_LO:
14752         case R_PPC64_ADDR16_LO_DS:
14753         case R_PPC64_ADDR24:
14754         case R_PPC64_ADDR32:
14755         case R_PPC64_ADDR64:
14756         case R_PPC64_UADDR16:
14757         case R_PPC64_UADDR32:
14758         case R_PPC64_UADDR64:
14759         dodyn:
14760           if ((input_section->flags & SEC_ALLOC) == 0)
14761             break;
14762
14763           if (NO_OPD_RELOCS && is_opd)
14764             break;
14765
14766           if (bfd_link_pic (info)
14767               ? ((h != NULL && pc_dynrelocs (h))
14768                  || must_be_dyn_reloc (info, r_type))
14769               : (h != NULL
14770                  ? h->dyn_relocs != NULL
14771                  : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14772             {
14773               bfd_boolean skip, relocate;
14774               asection *sreloc;
14775               bfd_vma out_off;
14776
14777               /* When generating a dynamic object, these relocations
14778                  are copied into the output file to be resolved at run
14779                  time.  */
14780
14781               skip = FALSE;
14782               relocate = FALSE;
14783
14784               out_off = _bfd_elf_section_offset (output_bfd, info,
14785                                                  input_section, rel->r_offset);
14786               if (out_off == (bfd_vma) -1)
14787                 skip = TRUE;
14788               else if (out_off == (bfd_vma) -2)
14789                 skip = TRUE, relocate = TRUE;
14790               out_off += (input_section->output_section->vma
14791                           + input_section->output_offset);
14792               outrel.r_offset = out_off;
14793               outrel.r_addend = rel->r_addend;
14794
14795               /* Optimize unaligned reloc use.  */
14796               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14797                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14798                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14799               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14800                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
14801                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
14802               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
14803                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
14804                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
14805
14806               if (skip)
14807                 memset (&outrel, 0, sizeof outrel);
14808               else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14809                        && !is_opd
14810                        && r_type != R_PPC64_TOC)
14811                 {
14812                   BFD_ASSERT (h->elf.dynindx != -1);
14813                   outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
14814                 }
14815               else
14816                 {
14817                   /* This symbol is local, or marked to become local,
14818                      or this is an opd section reloc which must point
14819                      at a local function.  */
14820                   outrel.r_addend += relocation;
14821                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
14822                     {
14823                       if (is_opd && h != NULL)
14824                         {
14825                           /* Lie about opd entries.  This case occurs
14826                              when building shared libraries and we
14827                              reference a function in another shared
14828                              lib.  The same thing happens for a weak
14829                              definition in an application that's
14830                              overridden by a strong definition in a
14831                              shared lib.  (I believe this is a generic
14832                              bug in binutils handling of weak syms.)
14833                              In these cases we won't use the opd
14834                              entry in this lib.  */
14835                           unresolved_reloc = FALSE;
14836                         }
14837                       if (!is_opd
14838                           && r_type == R_PPC64_ADDR64
14839                           && (h != NULL
14840                               ? h->elf.type == STT_GNU_IFUNC
14841                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14842                         outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14843                       else
14844                         {
14845                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14846
14847                           /* We need to relocate .opd contents for ld.so.
14848                              Prelink also wants simple and consistent rules
14849                              for relocs.  This make all RELATIVE relocs have
14850                              *r_offset equal to r_addend.  */
14851                           relocate = TRUE;
14852                         }
14853                     }
14854                   else
14855                     {
14856                       long indx = 0;
14857
14858                       if (h != NULL
14859                           ? h->elf.type == STT_GNU_IFUNC
14860                           : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14861                         {
14862                           info->callbacks->einfo
14863                             (_("%P: %H: %s for indirect "
14864                                "function `%T' unsupported\n"),
14865                              input_bfd, input_section, rel->r_offset,
14866                              ppc64_elf_howto_table[r_type]->name,
14867                              sym_name);
14868                           ret = FALSE;
14869                         }
14870                       else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
14871                         ;
14872                       else if (sec == NULL || sec->owner == NULL)
14873                         {
14874                           bfd_set_error (bfd_error_bad_value);
14875                           return FALSE;
14876                         }
14877                       else
14878                         {
14879                           asection *osec;
14880
14881                           osec = sec->output_section;
14882                           indx = elf_section_data (osec)->dynindx;
14883
14884                           if (indx == 0)
14885                             {
14886                               if ((osec->flags & SEC_READONLY) == 0
14887                                   && htab->elf.data_index_section != NULL)
14888                                 osec = htab->elf.data_index_section;
14889                               else
14890                                 osec = htab->elf.text_index_section;
14891                               indx = elf_section_data (osec)->dynindx;
14892                             }
14893                           BFD_ASSERT (indx != 0);
14894
14895                           /* We are turning this relocation into one
14896                              against a section symbol, so subtract out
14897                              the output section's address but not the
14898                              offset of the input section in the output
14899                              section.  */
14900                           outrel.r_addend -= osec->vma;
14901                         }
14902
14903                       outrel.r_info = ELF64_R_INFO (indx, r_type);
14904                     }
14905                 }
14906
14907               sreloc = elf_section_data (input_section)->sreloc;
14908               if (h != NULL
14909                   ? h->elf.type == STT_GNU_IFUNC
14910                   : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14911                 sreloc = htab->elf.irelplt;
14912               if (sreloc == NULL)
14913                 abort ();
14914
14915               if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
14916                   >= sreloc->size)
14917                 abort ();
14918               loc = sreloc->contents;
14919               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
14920               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14921
14922               /* If this reloc is against an external symbol, it will
14923                  be computed at runtime, so there's no need to do
14924                  anything now.  However, for the sake of prelink ensure
14925                  that the section contents are a known value.  */
14926               if (! relocate)
14927                 {
14928                   unresolved_reloc = FALSE;
14929                   /* The value chosen here is quite arbitrary as ld.so
14930                      ignores section contents except for the special
14931                      case of .opd where the contents might be accessed
14932                      before relocation.  Choose zero, as that won't
14933                      cause reloc overflow.  */
14934                   relocation = 0;
14935                   addend = 0;
14936                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
14937                      to improve backward compatibility with older
14938                      versions of ld.  */
14939                   if (r_type == R_PPC64_ADDR64)
14940                     addend = outrel.r_addend;
14941                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
14942                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
14943                     addend = (input_section->output_section->vma
14944                               + input_section->output_offset
14945                               + rel->r_offset);
14946                 }
14947             }
14948           break;
14949
14950         case R_PPC64_COPY:
14951         case R_PPC64_GLOB_DAT:
14952         case R_PPC64_JMP_SLOT:
14953         case R_PPC64_JMP_IREL:
14954         case R_PPC64_RELATIVE:
14955           /* We shouldn't ever see these dynamic relocs in relocatable
14956              files.  */
14957           /* Fall through.  */
14958
14959         case R_PPC64_PLTGOT16:
14960         case R_PPC64_PLTGOT16_DS:
14961         case R_PPC64_PLTGOT16_HA:
14962         case R_PPC64_PLTGOT16_HI:
14963         case R_PPC64_PLTGOT16_LO:
14964         case R_PPC64_PLTGOT16_LO_DS:
14965         case R_PPC64_PLTREL32:
14966         case R_PPC64_PLTREL64:
14967           /* These ones haven't been implemented yet.  */
14968
14969           info->callbacks->einfo
14970             (_("%P: %B: %s is not supported for `%T'\n"),
14971              input_bfd,
14972              ppc64_elf_howto_table[r_type]->name, sym_name);
14973
14974           bfd_set_error (bfd_error_invalid_operation);
14975           ret = FALSE;
14976           goto copy_reloc;
14977         }
14978
14979       /* Multi-instruction sequences that access the TOC can be
14980          optimized, eg. addis ra,r2,0; addi rb,ra,x;
14981          to             nop;           addi rb,r2,x;  */
14982       switch (r_type)
14983         {
14984         default:
14985           break;
14986
14987         case R_PPC64_GOT_TLSLD16_HI:
14988         case R_PPC64_GOT_TLSGD16_HI:
14989         case R_PPC64_GOT_TPREL16_HI:
14990         case R_PPC64_GOT_DTPREL16_HI:
14991         case R_PPC64_GOT16_HI:
14992         case R_PPC64_TOC16_HI:
14993           /* These relocs would only be useful if building up an
14994              offset to later add to r2, perhaps in an indexed
14995              addressing mode instruction.  Don't try to optimize.
14996              Unfortunately, the possibility of someone building up an
14997              offset like this or even with the HA relocs, means that
14998              we need to check the high insn when optimizing the low
14999              insn.  */
15000           break;
15001
15002         case R_PPC64_GOT_TLSLD16_HA:
15003         case R_PPC64_GOT_TLSGD16_HA:
15004         case R_PPC64_GOT_TPREL16_HA:
15005         case R_PPC64_GOT_DTPREL16_HA:
15006         case R_PPC64_GOT16_HA:
15007         case R_PPC64_TOC16_HA:
15008           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
15009               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
15010             {
15011               bfd_byte *p = contents + (rel->r_offset & ~3);
15012               bfd_put_32 (input_bfd, NOP, p);
15013             }
15014           break;
15015
15016         case R_PPC64_GOT_TLSLD16_LO:
15017         case R_PPC64_GOT_TLSGD16_LO:
15018         case R_PPC64_GOT_TPREL16_LO_DS:
15019         case R_PPC64_GOT_DTPREL16_LO_DS:
15020         case R_PPC64_GOT16_LO:
15021         case R_PPC64_GOT16_LO_DS:
15022         case R_PPC64_TOC16_LO:
15023         case R_PPC64_TOC16_LO_DS:
15024           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
15025               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
15026             {
15027               bfd_byte *p = contents + (rel->r_offset & ~3);
15028               insn = bfd_get_32 (input_bfd, p);
15029               if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
15030                 {
15031                   /* Transform addic to addi when we change reg.  */
15032                   insn &= ~((0x3f << 26) | (0x1f << 16));
15033                   insn |= (14u << 26) | (2 << 16);
15034                 }
15035               else
15036                 {
15037                   insn &= ~(0x1f << 16);
15038                   insn |= 2 << 16;
15039                 }
15040               bfd_put_32 (input_bfd, insn, p);
15041             }
15042           break;
15043         }
15044
15045       /* Do any further special processing.  */
15046       howto = ppc64_elf_howto_table[(int) r_type];
15047       switch (r_type)
15048         {
15049         default:
15050           break;
15051
15052         case R_PPC64_REL16_HA:
15053         case R_PPC64_REL16DX_HA:
15054         case R_PPC64_ADDR16_HA:
15055         case R_PPC64_ADDR16_HIGHA:
15056         case R_PPC64_ADDR16_HIGHERA:
15057         case R_PPC64_ADDR16_HIGHESTA:
15058         case R_PPC64_TOC16_HA:
15059         case R_PPC64_SECTOFF_HA:
15060         case R_PPC64_TPREL16_HA:
15061         case R_PPC64_TPREL16_HIGHA:
15062         case R_PPC64_TPREL16_HIGHERA:
15063         case R_PPC64_TPREL16_HIGHESTA:
15064         case R_PPC64_DTPREL16_HA:
15065         case R_PPC64_DTPREL16_HIGHA:
15066         case R_PPC64_DTPREL16_HIGHERA:
15067         case R_PPC64_DTPREL16_HIGHESTA:
15068           /* It's just possible that this symbol is a weak symbol
15069              that's not actually defined anywhere. In that case,
15070              'sec' would be NULL, and we should leave the symbol
15071              alone (it will be set to zero elsewhere in the link).  */
15072           if (sec == NULL)
15073             break;
15074           /* Fall thru */
15075
15076         case R_PPC64_GOT16_HA:
15077         case R_PPC64_PLTGOT16_HA:
15078         case R_PPC64_PLT16_HA:
15079         case R_PPC64_GOT_TLSGD16_HA:
15080         case R_PPC64_GOT_TLSLD16_HA:
15081         case R_PPC64_GOT_TPREL16_HA:
15082         case R_PPC64_GOT_DTPREL16_HA:
15083           /* Add 0x10000 if sign bit in 0:15 is set.
15084              Bits 0:15 are not used.  */
15085           addend += 0x8000;
15086           break;
15087
15088         case R_PPC64_ADDR16_DS:
15089         case R_PPC64_ADDR16_LO_DS:
15090         case R_PPC64_GOT16_DS:
15091         case R_PPC64_GOT16_LO_DS:
15092         case R_PPC64_PLT16_LO_DS:
15093         case R_PPC64_SECTOFF_DS:
15094         case R_PPC64_SECTOFF_LO_DS:
15095         case R_PPC64_TOC16_DS:
15096         case R_PPC64_TOC16_LO_DS:
15097         case R_PPC64_PLTGOT16_DS:
15098         case R_PPC64_PLTGOT16_LO_DS:
15099         case R_PPC64_GOT_TPREL16_DS:
15100         case R_PPC64_GOT_TPREL16_LO_DS:
15101         case R_PPC64_GOT_DTPREL16_DS:
15102         case R_PPC64_GOT_DTPREL16_LO_DS:
15103         case R_PPC64_TPREL16_DS:
15104         case R_PPC64_TPREL16_LO_DS:
15105         case R_PPC64_DTPREL16_DS:
15106         case R_PPC64_DTPREL16_LO_DS:
15107           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15108           mask = 3;
15109           /* If this reloc is against an lq, lxv, or stxv insn, then
15110              the value must be a multiple of 16.  This is somewhat of
15111              a hack, but the "correct" way to do this by defining _DQ
15112              forms of all the _DS relocs bloats all reloc switches in
15113              this file.  It doesn't make much sense to use these
15114              relocs in data, so testing the insn should be safe.  */
15115           if ((insn & (0x3f << 26)) == (56u << 26)
15116               || ((insn & (0x3f << 26)) == (61u << 26) && (insn & 3) == 1))
15117             mask = 15;
15118           relocation += addend;
15119           addend = insn & (mask ^ 3);
15120           if ((relocation & mask) != 0)
15121             {
15122               relocation ^= relocation & mask;
15123               info->callbacks->einfo
15124                 (_("%P: %H: error: %s not a multiple of %u\n"),
15125                  input_bfd, input_section, rel->r_offset,
15126                  howto->name,
15127                  mask + 1);
15128               bfd_set_error (bfd_error_bad_value);
15129               ret = FALSE;
15130               goto copy_reloc;
15131             }
15132           break;
15133         }
15134
15135       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
15136          because such sections are not SEC_ALLOC and thus ld.so will
15137          not process them.  */
15138       if (unresolved_reloc
15139           && !((input_section->flags & SEC_DEBUGGING) != 0
15140                && h->elf.def_dynamic)
15141           && _bfd_elf_section_offset (output_bfd, info, input_section,
15142                                       rel->r_offset) != (bfd_vma) -1)
15143         {
15144           info->callbacks->einfo
15145             (_("%P: %H: unresolvable %s against `%T'\n"),
15146              input_bfd, input_section, rel->r_offset,
15147              howto->name,
15148              h->elf.root.root.string);
15149           ret = FALSE;
15150         }
15151
15152       /* 16-bit fields in insns mostly have signed values, but a
15153          few insns have 16-bit unsigned values.  Really, we should
15154          have different reloc types.  */
15155       if (howto->complain_on_overflow != complain_overflow_dont
15156           && howto->dst_mask == 0xffff
15157           && (input_section->flags & SEC_CODE) != 0)
15158         {
15159           enum complain_overflow complain = complain_overflow_signed;
15160
15161           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15162           if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
15163             complain = complain_overflow_bitfield;
15164           else if (howto->rightshift == 0
15165                    ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
15166                       || (insn & (0x3f << 26)) == 24u << 26 /* ori */
15167                       || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
15168                    : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
15169                       || (insn & (0x3f << 26)) == 25u << 26 /* oris */
15170                       || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
15171             complain = complain_overflow_unsigned;
15172           if (howto->complain_on_overflow != complain)
15173             {
15174               alt_howto = *howto;
15175               alt_howto.complain_on_overflow = complain;
15176               howto = &alt_howto;
15177             }
15178         }
15179
15180       if (r_type == R_PPC64_REL16DX_HA)
15181         {
15182           /* Split field reloc isn't handled by _bfd_final_link_relocate.  */
15183           if (rel->r_offset + 4 > input_section->size)
15184             r = bfd_reloc_outofrange;
15185           else
15186             {
15187               relocation += addend;
15188               relocation -= (rel->r_offset
15189                              + input_section->output_offset
15190                              + input_section->output_section->vma);
15191               relocation = (bfd_signed_vma) relocation >> 16;
15192               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
15193               insn &= ~0x1fffc1;
15194               insn |= (relocation & 0xffc1) | ((relocation & 0x3e) << 15);
15195               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
15196               r = bfd_reloc_ok;
15197               if (relocation + 0x8000 > 0xffff)
15198                 r = bfd_reloc_overflow;
15199             }
15200         }
15201       else
15202         r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
15203                                       rel->r_offset, relocation, addend);
15204
15205       if (r != bfd_reloc_ok)
15206         {
15207           char *more_info = NULL;
15208           const char *reloc_name = howto->name;
15209
15210           if (reloc_dest != DEST_NORMAL)
15211             {
15212               more_info = bfd_malloc (strlen (reloc_name) + 8);
15213               if (more_info != NULL)
15214                 {
15215                   strcpy (more_info, reloc_name);
15216                   strcat (more_info, (reloc_dest == DEST_OPD
15217                                       ? " (OPD)" : " (stub)"));
15218                   reloc_name = more_info;
15219                 }
15220             }
15221
15222           if (r == bfd_reloc_overflow)
15223             {
15224               /* On code like "if (foo) foo();" don't report overflow
15225                  on a branch to zero when foo is undefined.  */
15226               if (!warned
15227                   && (reloc_dest == DEST_STUB
15228                       || !(h != NULL
15229                            && (h->elf.root.type == bfd_link_hash_undefweak
15230                                || h->elf.root.type == bfd_link_hash_undefined)
15231                            && is_branch_reloc (r_type))))
15232                 info->callbacks->reloc_overflow (info, &h->elf.root,
15233                                                  sym_name, reloc_name,
15234                                                  orig_rel.r_addend,
15235                                                  input_bfd, input_section,
15236                                                  rel->r_offset);
15237             }
15238           else
15239             {
15240               info->callbacks->einfo
15241                 (_("%P: %H: %s against `%T': error %d\n"),
15242                  input_bfd, input_section, rel->r_offset,
15243                  reloc_name, sym_name, (int) r);
15244               ret = FALSE;
15245             }
15246           if (more_info != NULL)
15247             free (more_info);
15248         }
15249     copy_reloc:
15250       if (wrel != rel)
15251         *wrel = *rel;
15252     }
15253
15254   if (wrel != rel)
15255     {
15256       Elf_Internal_Shdr *rel_hdr;
15257       size_t deleted = rel - wrel;
15258
15259       rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
15260       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15261       if (rel_hdr->sh_size == 0)
15262         {
15263           /* It is too late to remove an empty reloc section.  Leave
15264              one NONE reloc.
15265              ??? What is wrong with an empty section???  */
15266           rel_hdr->sh_size = rel_hdr->sh_entsize;
15267           deleted -= 1;
15268         }
15269       rel_hdr = _bfd_elf_single_rel_hdr (input_section);
15270       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15271       input_section->reloc_count -= deleted;
15272     }
15273
15274   /* If we're emitting relocations, then shortly after this function
15275      returns, reloc offsets and addends for this section will be
15276      adjusted.  Worse, reloc symbol indices will be for the output
15277      file rather than the input.  Save a copy of the relocs for
15278      opd_entry_value.  */
15279   if (is_opd && (info->emitrelocations || bfd_link_relocatable (info)))
15280     {
15281       bfd_size_type amt;
15282       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
15283       rel = bfd_alloc (input_bfd, amt);
15284       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
15285       ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
15286       if (rel == NULL)
15287         return FALSE;
15288       memcpy (rel, relocs, amt);
15289     }
15290   return ret;
15291 }
15292
15293 /* Adjust the value of any local symbols in opd sections.  */
15294
15295 static int
15296 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
15297                               const char *name ATTRIBUTE_UNUSED,
15298                               Elf_Internal_Sym *elfsym,
15299                               asection *input_sec,
15300                               struct elf_link_hash_entry *h)
15301 {
15302   struct _opd_sec_data *opd;
15303   long adjust;
15304   bfd_vma value;
15305
15306   if (h != NULL)
15307     return 1;
15308
15309   opd = get_opd_info (input_sec);
15310   if (opd == NULL || opd->adjust == NULL)
15311     return 1;
15312
15313   value = elfsym->st_value - input_sec->output_offset;
15314   if (!bfd_link_relocatable (info))
15315     value -= input_sec->output_section->vma;
15316
15317   adjust = opd->adjust[OPD_NDX (value)];
15318   if (adjust == -1)
15319     return 2;
15320
15321   elfsym->st_value += adjust;
15322   return 1;
15323 }
15324
15325 /* Finish up dynamic symbol handling.  We set the contents of various
15326    dynamic sections here.  */
15327
15328 static bfd_boolean
15329 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
15330                                  struct bfd_link_info *info,
15331                                  struct elf_link_hash_entry *h,
15332                                  Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
15333 {
15334   struct ppc_link_hash_table *htab;
15335   struct plt_entry *ent;
15336   Elf_Internal_Rela rela;
15337   bfd_byte *loc;
15338
15339   htab = ppc_hash_table (info);
15340   if (htab == NULL)
15341     return FALSE;
15342
15343   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
15344     if (ent->plt.offset != (bfd_vma) -1)
15345       {
15346         /* This symbol has an entry in the procedure linkage
15347            table.  Set it up.  */
15348         if (!htab->elf.dynamic_sections_created
15349             || h->dynindx == -1)
15350           {
15351             BFD_ASSERT (h->type == STT_GNU_IFUNC
15352                         && h->def_regular
15353                         && (h->root.type == bfd_link_hash_defined
15354                             || h->root.type == bfd_link_hash_defweak));
15355             rela.r_offset = (htab->elf.iplt->output_section->vma
15356                              + htab->elf.iplt->output_offset
15357                              + ent->plt.offset);
15358             if (htab->opd_abi)
15359               rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
15360             else
15361               rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15362             rela.r_addend = (h->root.u.def.value
15363                              + h->root.u.def.section->output_offset
15364                              + h->root.u.def.section->output_section->vma
15365                              + ent->addend);
15366             loc = (htab->elf.irelplt->contents
15367                    + (htab->elf.irelplt->reloc_count++
15368                       * sizeof (Elf64_External_Rela)));
15369           }
15370         else
15371           {
15372             rela.r_offset = (htab->elf.splt->output_section->vma
15373                              + htab->elf.splt->output_offset
15374                              + ent->plt.offset);
15375             rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
15376             rela.r_addend = ent->addend;
15377             loc = (htab->elf.srelplt->contents
15378                    + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
15379                       / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
15380           }
15381         bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15382
15383         if (!htab->opd_abi)
15384           {
15385             if (!h->def_regular)
15386               {
15387                 /* Mark the symbol as undefined, rather than as
15388                    defined in glink.  Leave the value if there were
15389                    any relocations where pointer equality matters
15390                    (this is a clue for the dynamic linker, to make
15391                    function pointer comparisons work between an
15392                    application and shared library), otherwise set it
15393                    to zero.  */
15394                 sym->st_shndx = SHN_UNDEF;
15395                 if (!h->pointer_equality_needed)
15396                   sym->st_value = 0;
15397                 else if (!h->ref_regular_nonweak)
15398                   {
15399                     /* This breaks function pointer comparisons, but
15400                        that is better than breaking tests for a NULL
15401                        function pointer.  */
15402                     sym->st_value = 0;
15403                   }
15404               }
15405           }
15406       }
15407
15408   if (h->needs_copy)
15409     {
15410       /* This symbol needs a copy reloc.  Set it up.  */
15411
15412       if (h->dynindx == -1
15413           || (h->root.type != bfd_link_hash_defined
15414               && h->root.type != bfd_link_hash_defweak)
15415           || htab->relbss == NULL)
15416         abort ();
15417
15418       rela.r_offset = (h->root.u.def.value
15419                        + h->root.u.def.section->output_section->vma
15420                        + h->root.u.def.section->output_offset);
15421       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
15422       rela.r_addend = 0;
15423       loc = htab->relbss->contents;
15424       loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
15425       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15426     }
15427
15428   return TRUE;
15429 }
15430
15431 /* Used to decide how to sort relocs in an optimal manner for the
15432    dynamic linker, before writing them out.  */
15433
15434 static enum elf_reloc_type_class
15435 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
15436                             const asection *rel_sec,
15437                             const Elf_Internal_Rela *rela)
15438 {
15439   enum elf_ppc64_reloc_type r_type;
15440   struct ppc_link_hash_table *htab = ppc_hash_table (info);
15441
15442   if (rel_sec == htab->elf.irelplt)
15443     return reloc_class_ifunc;
15444
15445   r_type = ELF64_R_TYPE (rela->r_info);
15446   switch (r_type)
15447     {
15448     case R_PPC64_RELATIVE:
15449       return reloc_class_relative;
15450     case R_PPC64_JMP_SLOT:
15451       return reloc_class_plt;
15452     case R_PPC64_COPY:
15453       return reloc_class_copy;
15454     default:
15455       return reloc_class_normal;
15456     }
15457 }
15458
15459 /* Finish up the dynamic sections.  */
15460
15461 static bfd_boolean
15462 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
15463                                    struct bfd_link_info *info)
15464 {
15465   struct ppc_link_hash_table *htab;
15466   bfd *dynobj;
15467   asection *sdyn;
15468
15469   htab = ppc_hash_table (info);
15470   if (htab == NULL)
15471     return FALSE;
15472
15473   dynobj = htab->elf.dynobj;
15474   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
15475
15476   if (htab->elf.dynamic_sections_created)
15477     {
15478       Elf64_External_Dyn *dyncon, *dynconend;
15479
15480       if (sdyn == NULL || htab->elf.sgot == NULL)
15481         abort ();
15482
15483       dyncon = (Elf64_External_Dyn *) sdyn->contents;
15484       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
15485       for (; dyncon < dynconend; dyncon++)
15486         {
15487           Elf_Internal_Dyn dyn;
15488           asection *s;
15489
15490           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
15491
15492           switch (dyn.d_tag)
15493             {
15494             default:
15495               continue;
15496
15497             case DT_PPC64_GLINK:
15498               s = htab->glink;
15499               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15500               /* We stupidly defined DT_PPC64_GLINK to be the start
15501                  of glink rather than the first entry point, which is
15502                  what ld.so needs, and now have a bigger stub to
15503                  support automatic multiple TOCs.  */
15504               dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
15505               break;
15506
15507             case DT_PPC64_OPD:
15508               s = bfd_get_section_by_name (output_bfd, ".opd");
15509               if (s == NULL)
15510                 continue;
15511               dyn.d_un.d_ptr = s->vma;
15512               break;
15513
15514             case DT_PPC64_OPT:
15515               if (htab->do_multi_toc && htab->multi_toc_needed)
15516                 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
15517               break;
15518
15519             case DT_PPC64_OPDSZ:
15520               s = bfd_get_section_by_name (output_bfd, ".opd");
15521               if (s == NULL)
15522                 continue;
15523               dyn.d_un.d_val = s->size;
15524               break;
15525
15526             case DT_PLTGOT:
15527               s = htab->elf.splt;
15528               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15529               break;
15530
15531             case DT_JMPREL:
15532               s = htab->elf.srelplt;
15533               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15534               break;
15535
15536             case DT_PLTRELSZ:
15537               dyn.d_un.d_val = htab->elf.srelplt->size;
15538               break;
15539
15540             case DT_RELASZ:
15541               /* Don't count procedure linkage table relocs in the
15542                  overall reloc count.  */
15543               s = htab->elf.srelplt;
15544               if (s == NULL)
15545                 continue;
15546               dyn.d_un.d_val -= s->size;
15547               break;
15548
15549             case DT_RELA:
15550               /* We may not be using the standard ELF linker script.
15551                  If .rela.plt is the first .rela section, we adjust
15552                  DT_RELA to not include it.  */
15553               s = htab->elf.srelplt;
15554               if (s == NULL)
15555                 continue;
15556               if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
15557                 continue;
15558               dyn.d_un.d_ptr += s->size;
15559               break;
15560             }
15561
15562           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
15563         }
15564     }
15565
15566   if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0)
15567     {
15568       /* Fill in the first entry in the global offset table.
15569          We use it to hold the link-time TOCbase.  */
15570       bfd_put_64 (output_bfd,
15571                   elf_gp (output_bfd) + TOC_BASE_OFF,
15572                   htab->elf.sgot->contents);
15573
15574       /* Set .got entry size.  */
15575       elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
15576     }
15577
15578   if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
15579     {
15580       /* Set .plt entry size.  */
15581       elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
15582         = PLT_ENTRY_SIZE (htab);
15583     }
15584
15585   /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
15586      brlt ourselves if emitrelocations.  */
15587   if (htab->brlt != NULL
15588       && htab->brlt->reloc_count != 0
15589       && !_bfd_elf_link_output_relocs (output_bfd,
15590                                        htab->brlt,
15591                                        elf_section_data (htab->brlt)->rela.hdr,
15592                                        elf_section_data (htab->brlt)->relocs,
15593                                        NULL))
15594     return FALSE;
15595
15596   if (htab->glink != NULL
15597       && htab->glink->reloc_count != 0
15598       && !_bfd_elf_link_output_relocs (output_bfd,
15599                                        htab->glink,
15600                                        elf_section_data (htab->glink)->rela.hdr,
15601                                        elf_section_data (htab->glink)->relocs,
15602                                        NULL))
15603     return FALSE;
15604
15605   if (htab->glink_eh_frame != NULL
15606       && htab->glink_eh_frame->size != 0)
15607     {
15608       bfd_vma val;
15609       bfd_byte *p;
15610       asection *stub_sec;
15611
15612       p = htab->glink_eh_frame->contents + sizeof (glink_eh_frame_cie);
15613       for (stub_sec = htab->params->stub_bfd->sections;
15614            stub_sec != NULL;
15615            stub_sec = stub_sec->next)
15616         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
15617           {
15618             /* FDE length.  */
15619             p += 4;
15620             /* CIE pointer.  */
15621             p += 4;
15622             /* Offset to stub section.  */
15623             val = (stub_sec->output_section->vma
15624                    + stub_sec->output_offset);
15625             val -= (htab->glink_eh_frame->output_section->vma
15626                     + htab->glink_eh_frame->output_offset
15627                     + (p - htab->glink_eh_frame->contents));
15628             if (val + 0x80000000 > 0xffffffff)
15629               {
15630                 info->callbacks->einfo
15631                   (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15632                    stub_sec->name);
15633                 return FALSE;
15634               }
15635             bfd_put_32 (dynobj, val, p);
15636             p += 4;
15637             /* stub section size.  */
15638             p += 4;
15639             /* Augmentation.  */
15640             p += 1;
15641             /* Pad.  */
15642             p += 7;
15643           }
15644       if (htab->glink != NULL && htab->glink->size != 0)
15645         {
15646           /* FDE length.  */
15647           p += 4;
15648           /* CIE pointer.  */
15649           p += 4;
15650           /* Offset to .glink.  */
15651           val = (htab->glink->output_section->vma
15652                  + htab->glink->output_offset
15653                  + 8);
15654           val -= (htab->glink_eh_frame->output_section->vma
15655                   + htab->glink_eh_frame->output_offset
15656                   + (p - htab->glink_eh_frame->contents));
15657           if (val + 0x80000000 > 0xffffffff)
15658             {
15659               info->callbacks->einfo
15660                 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15661                  htab->glink->name);
15662               return FALSE;
15663             }
15664           bfd_put_32 (dynobj, val, p);
15665           p += 4;
15666           /* .glink size.  */
15667           p += 4;
15668           /* Augmentation.  */
15669           p += 1;
15670           /* Ops.  */
15671           p += 7;
15672         }
15673
15674       if (htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
15675           && !_bfd_elf_write_section_eh_frame (output_bfd, info,
15676                                                htab->glink_eh_frame,
15677                                                htab->glink_eh_frame->contents))
15678         return FALSE;
15679     }
15680
15681   /* We need to handle writing out multiple GOT sections ourselves,
15682      since we didn't add them to DYNOBJ.  We know dynobj is the first
15683      bfd.  */
15684   while ((dynobj = dynobj->link.next) != NULL)
15685     {
15686       asection *s;
15687
15688       if (!is_ppc64_elf (dynobj))
15689         continue;
15690
15691       s = ppc64_elf_tdata (dynobj)->got;
15692       if (s != NULL
15693           && s->size != 0
15694           && s->output_section != bfd_abs_section_ptr
15695           && !bfd_set_section_contents (output_bfd, s->output_section,
15696                                         s->contents, s->output_offset,
15697                                         s->size))
15698         return FALSE;
15699       s = ppc64_elf_tdata (dynobj)->relgot;
15700       if (s != NULL
15701           && s->size != 0
15702           && s->output_section != bfd_abs_section_ptr
15703           && !bfd_set_section_contents (output_bfd, s->output_section,
15704                                         s->contents, s->output_offset,
15705                                         s->size))
15706         return FALSE;
15707     }
15708
15709   return TRUE;
15710 }
15711
15712 #include "elf64-target.h"
15713
15714 /* FreeBSD support */
15715
15716 #undef  TARGET_LITTLE_SYM
15717 #undef  TARGET_LITTLE_NAME
15718
15719 #undef  TARGET_BIG_SYM
15720 #define TARGET_BIG_SYM  powerpc_elf64_fbsd_vec
15721 #undef  TARGET_BIG_NAME
15722 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15723
15724 #undef  ELF_OSABI
15725 #define ELF_OSABI       ELFOSABI_FREEBSD
15726
15727 #undef  elf64_bed
15728 #define elf64_bed       elf64_powerpc_fbsd_bed
15729
15730 #include "elf64-target.h"
15731