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