bfd/elf64-ppc.c

   1 /* PowerPC64-specific support for 64-bit ELF.
   2    Copyright (C) 1999-2016 Free Software Foundation, Inc.
   3    Written by Linus Nordberg, Swox AB <info@swox.com>,
   4    based on elf32-ppc.c by Ian Lance Taylor.
   5    Largely rewritten by Alan Modra.
   6
   7    This file is part of BFD, the Binary File Descriptor library.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License along
  20    with this program; if not, write to the Free Software Foundation, Inc.,
  21    51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
  22
  23
  24 /* The 64-bit PowerPC ELF ABI may be found at
  25    http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and
  26    http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html  */
  27
  28 #include "sysdep.h"
  29 #include <stdarg.h>
  30 #include "bfd.h"
  31 #include "bfdlink.h"
  32 #include "libbfd.h"
  33 #include "elf-bfd.h"
  34 #include "elf/ppc64.h"
  35 #include "elf64-ppc.h"
  36 #include "dwarf2.h"
  37
  38 static bfd_reloc_status_type ppc64_elf_ha_reloc
  39   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  40 static bfd_reloc_status_type ppc64_elf_branch_reloc
  41   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  42 static bfd_reloc_status_type ppc64_elf_brtaken_reloc
  43   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  44 static bfd_reloc_status_type ppc64_elf_sectoff_reloc
  45   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  46 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
  47   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  48 static bfd_reloc_status_type ppc64_elf_toc_reloc
  49   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  50 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
  51   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  52 static bfd_reloc_status_type ppc64_elf_toc64_reloc
  53   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  54 static bfd_reloc_status_type ppc64_elf_unhandled_reloc
  55   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  56 static bfd_vma opd_entry_value
  57   (asection *, bfd_vma, asection **, bfd_vma *, bfd_boolean);
  58
  59 #define TARGET_LITTLE_SYM       powerpc_elf64_le_vec
  60 #define TARGET_LITTLE_NAME      "elf64-powerpcle"
  61 #define TARGET_BIG_SYM          powerpc_elf64_vec
  62 #define TARGET_BIG_NAME         "elf64-powerpc"
  63 #define ELF_ARCH                bfd_arch_powerpc
  64 #define ELF_TARGET_ID           PPC64_ELF_DATA
  65 #define ELF_MACHINE_CODE        EM_PPC64
  66 #define ELF_MAXPAGESIZE         0x10000
  67 #define ELF_COMMONPAGESIZE      0x10000
  68 #define elf_info_to_howto       ppc64_elf_info_to_howto
  69
  70 #define elf_backend_want_got_sym 0
  71 #define elf_backend_want_plt_sym 0
  72 #define elf_backend_plt_alignment 3
  73 #define elf_backend_plt_not_loaded 1
  74 #define elf_backend_got_header_size 8
  75 #define elf_backend_can_gc_sections 1
  76 #define elf_backend_can_refcount 1
  77 #define elf_backend_rela_normal 1
  78 #define elf_backend_default_execstack 0
  79
  80 #define bfd_elf64_mkobject                    ppc64_elf_mkobject
  81 #define bfd_elf64_bfd_reloc_type_lookup       ppc64_elf_reloc_type_lookup
  82 #define bfd_elf64_bfd_reloc_name_lookup       ppc64_elf_reloc_name_lookup
  83 #define bfd_elf64_bfd_merge_private_bfd_data  ppc64_elf_merge_private_bfd_data
  84 #define bfd_elf64_bfd_print_private_bfd_data  ppc64_elf_print_private_bfd_data
  85 #define bfd_elf64_new_section_hook            ppc64_elf_new_section_hook
  86 #define bfd_elf64_bfd_link_hash_table_create  ppc64_elf_link_hash_table_create
  87 #define bfd_elf64_get_synthetic_symtab        ppc64_elf_get_synthetic_symtab
  88 #define bfd_elf64_bfd_link_just_syms          ppc64_elf_link_just_syms
  89
  90 #define elf_backend_object_p                  ppc64_elf_object_p
  91 #define elf_backend_grok_prstatus             ppc64_elf_grok_prstatus
  92 #define elf_backend_grok_psinfo               ppc64_elf_grok_psinfo
  93 #define elf_backend_write_core_note           ppc64_elf_write_core_note
  94 #define elf_backend_create_dynamic_sections   ppc64_elf_create_dynamic_sections
  95 #define elf_backend_copy_indirect_symbol      ppc64_elf_copy_indirect_symbol
  96 #define elf_backend_add_symbol_hook           ppc64_elf_add_symbol_hook
  97 #define elf_backend_check_directives          ppc64_elf_before_check_relocs
  98 #define elf_backend_notice_as_needed          ppc64_elf_notice_as_needed
  99 #define elf_backend_archive_symbol_lookup     ppc64_elf_archive_symbol_lookup
 100 #define elf_backend_check_relocs              ppc64_elf_check_relocs
 101 #define elf_backend_gc_keep                   ppc64_elf_gc_keep
 102 #define elf_backend_gc_mark_dynamic_ref       ppc64_elf_gc_mark_dynamic_ref
 103 #define elf_backend_gc_mark_hook              ppc64_elf_gc_mark_hook
 104 #define elf_backend_gc_sweep_hook             ppc64_elf_gc_sweep_hook
 105 #define elf_backend_adjust_dynamic_symbol     ppc64_elf_adjust_dynamic_symbol
 106 #define elf_backend_hide_symbol               ppc64_elf_hide_symbol
 107 #define elf_backend_maybe_function_sym        ppc64_elf_maybe_function_sym
 108 #define elf_backend_always_size_sections      ppc64_elf_func_desc_adjust
 109 #define elf_backend_size_dynamic_sections     ppc64_elf_size_dynamic_sections
 110 #define elf_backend_hash_symbol               ppc64_elf_hash_symbol
 111 #define elf_backend_init_index_section        _bfd_elf_init_2_index_sections
 112 #define elf_backend_action_discarded          ppc64_elf_action_discarded
 113 #define elf_backend_relocate_section          ppc64_elf_relocate_section
 114 #define elf_backend_finish_dynamic_symbol     ppc64_elf_finish_dynamic_symbol
 115 #define elf_backend_reloc_type_class          ppc64_elf_reloc_type_class
 116 #define elf_backend_finish_dynamic_sections   ppc64_elf_finish_dynamic_sections
 117 #define elf_backend_link_output_symbol_hook   ppc64_elf_output_symbol_hook
 118 #define elf_backend_special_sections          ppc64_elf_special_sections
 119 #define elf_backend_merge_symbol_attribute    ppc64_elf_merge_symbol_attribute
 120
 121 /* The name of the dynamic interpreter.  This is put in the .interp
 122    section.  */
 123 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
 124
 125 /* The size in bytes of an entry in the procedure linkage table.  */
 126 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
 127
 128 /* The initial size of the plt reserved for the dynamic linker.  */
 129 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
 130
 131 /* Offsets to some stack save slots.  */
 132 #define STK_LR 16
 133 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
 134 /* This one is dodgy.  ELFv2 does not have a linker word, so use the
 135    CR save slot.  Used only by optimised __tls_get_addr call stub,
 136    relying on __tls_get_addr_opt not saving CR..  */
 137 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
 138
 139 /* TOC base pointers offset from start of TOC.  */
 140 #define TOC_BASE_OFF    0x8000
 141 /* TOC base alignment.  */
 142 #define TOC_BASE_ALIGN  256
 143
 144 /* Offset of tp and dtp pointers from start of TLS block.  */
 145 #define TP_OFFSET       0x7000
 146 #define DTP_OFFSET      0x8000
 147
 148 /* .plt call stub instructions.  The normal stub is like this, but
 149    sometimes the .plt entry crosses a 64k boundary and we need to
 150    insert an addi to adjust r11.  */
 151 #define STD_R2_0R1      0xf8410000      /* std   %r2,0+40(%r1)       */
 152 #define ADDIS_R11_R2    0x3d620000      /* addis %r11,%r2,xxx@ha     */
 153 #define LD_R12_0R11     0xe98b0000      /* ld    %r12,xxx+0@l(%r11)  */
 154 #define MTCTR_R12       0x7d8903a6      /* mtctr %r12                */
 155 #define LD_R2_0R11      0xe84b0000      /* ld    %r2,xxx+8@l(%r11)   */
 156 #define LD_R11_0R11     0xe96b0000      /* ld    %r11,xxx+16@l(%r11) */
 157 #define BCTR            0x4e800420      /* bctr                      */
 158
 159 #define ADDI_R11_R11    0x396b0000      /* addi %r11,%r11,off@l  */
 160 #define ADDIS_R2_R2     0x3c420000      /* addis %r2,%r2,off@ha  */
 161 #define ADDI_R2_R2      0x38420000      /* addi  %r2,%r2,off@l   */
 162
 163 #define XOR_R2_R12_R12  0x7d826278      /* xor   %r2,%r12,%r12   */
 164 #define ADD_R11_R11_R2  0x7d6b1214      /* add   %r11,%r11,%r2   */
 165 #define XOR_R11_R12_R12 0x7d8b6278      /* xor   %r11,%r12,%r12  */
 166 #define ADD_R2_R2_R11   0x7c425a14      /* add   %r2,%r2,%r11    */
 167 #define CMPLDI_R2_0     0x28220000      /* cmpldi %r2,0          */
 168 #define BNECTR          0x4ca20420      /* bnectr+               */
 169 #define BNECTR_P4       0x4ce20420      /* bnectr+               */
 170
 171 #define LD_R12_0R2      0xe9820000      /* ld    %r12,xxx+0(%r2) */
 172 #define LD_R11_0R2      0xe9620000      /* ld    %r11,xxx+0(%r2) */
 173 #define LD_R2_0R2       0xe8420000      /* ld    %r2,xxx+0(%r2)  */
 174
 175 #define LD_R2_0R1       0xe8410000      /* ld    %r2,0(%r1)      */
 176 #define LD_R2_0R12      0xe84c0000      /* ld    %r2,0(%r12)     */
 177 #define ADD_R2_R2_R12   0x7c426214      /* add   %r2,%r2,%r12    */
 178
 179 #define LIS_R2          0x3c400000      /* lis %r2,xxx@ha         */
 180 #define ADDIS_R2_R12    0x3c4c0000      /* addis %r2,%r12,xxx@ha  */
 181 #define ADDIS_R12_R2    0x3d820000      /* addis %r12,%r2,xxx@ha  */
 182 #define ADDIS_R12_R12   0x3d8c0000      /* addis %r12,%r12,xxx@ha */
 183 #define LD_R12_0R12     0xe98c0000      /* ld    %r12,xxx@l(%r12) */
 184
 185 /* glink call stub instructions.  We enter with the index in R0.  */
 186 #define GLINK_CALL_STUB_SIZE (16*4)
 187                                         /* 0:                           */
 188                                         /*  .quad plt0-1f               */
 189                                         /* __glink:                     */
 190 #define MFLR_R12        0x7d8802a6      /*  mflr %12                    */
 191 #define BCL_20_31       0x429f0005      /*  bcl 20,31,1f                */
 192                                         /* 1:                           */
 193 #define MFLR_R11        0x7d6802a6      /*  mflr %11                    */
 194                                         /*  ld %2,(0b-1b)(%11)          */
 195 #define MTLR_R12        0x7d8803a6      /*  mtlr %12                    */
 196 #define ADD_R11_R2_R11  0x7d625a14      /*  add %11,%2,%11              */
 197                                         /*  ld %12,0(%11)               */
 198                                         /*  ld %2,8(%11)                */
 199                                         /*  mtctr %12                   */
 200                                         /*  ld %11,16(%11)              */
 201                                         /*  bctr                        */
 202 #define MFLR_R0         0x7c0802a6      /*  mflr %r0                    */
 203 #define MTLR_R0         0x7c0803a6      /*  mtlr %r0                    */
 204 #define SUB_R12_R12_R11 0x7d8b6050      /*  subf %r12,%r11,%r12         */
 205 #define ADDI_R0_R12     0x380c0000      /*  addi %r0,%r12,0             */
 206 #define SRDI_R0_R0_2    0x7800f082      /*  rldicl %r0,%r0,62,2         */
 207
 208 /* Pad with this.  */
 209 #define NOP             0x60000000
 210
 211 /* Some other nops.  */
 212 #define CROR_151515     0x4def7b82
 213 #define CROR_313131     0x4ffffb82
 214
 215 /* .glink entries for the first 32k functions are two instructions.  */
 216 #define LI_R0_0         0x38000000      /* li    %r0,0          */
 217 #define B_DOT           0x48000000      /* b     .              */
 218
 219 /* After that, we need two instructions to load the index, followed by
 220    a branch.  */
 221 #define LIS_R0_0        0x3c000000      /* lis   %r0,0          */
 222 #define ORI_R0_R0_0     0x60000000      /* ori   %r0,%r0,0      */
 223
 224 /* Instructions used by the save and restore reg functions.  */
 225 #define STD_R0_0R1      0xf8010000      /* std   %r0,0(%r1)     */
 226 #define STD_R0_0R12     0xf80c0000      /* std   %r0,0(%r12)    */
 227 #define LD_R0_0R1       0xe8010000      /* ld    %r0,0(%r1)     */
 228 #define LD_R0_0R12      0xe80c0000      /* ld    %r0,0(%r12)    */
 229 #define STFD_FR0_0R1    0xd8010000      /* stfd  %fr0,0(%r1)    */
 230 #define LFD_FR0_0R1     0xc8010000      /* lfd   %fr0,0(%r1)    */
 231 #define LI_R12_0        0x39800000      /* li    %r12,0         */
 232 #define STVX_VR0_R12_R0 0x7c0c01ce      /* stvx  %v0,%r12,%r0   */
 233 #define LVX_VR0_R12_R0  0x7c0c00ce      /* lvx   %v0,%r12,%r0   */
 234 #define MTLR_R0         0x7c0803a6      /* mtlr  %r0            */
 235 #define BLR             0x4e800020      /* blr                  */
 236
 237 /* Since .opd is an array of descriptors and each entry will end up
 238    with identical R_PPC64_RELATIVE relocs, there is really no need to
 239    propagate .opd relocs;  The dynamic linker should be taught to
 240    relocate .opd without reloc entries.  */
 241 #ifndef NO_OPD_RELOCS
 242 #define NO_OPD_RELOCS 0
 243 #endif
 244
 245 #ifndef ARRAY_SIZE
 246 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
 247 #endif
 248
 249 static inline int
 250 abiversion (bfd *abfd)
 251 {
 252   return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
 253 }
 254
 255 static inline void
 256 set_abiversion (bfd *abfd, int ver)
 257 {
 258   elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
 259   elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
 260 }
 261 \f
 262 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
 263
 264 /* Relocation HOWTO's.  */
 265 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
 266
 267 static reloc_howto_type ppc64_elf_howto_raw[] = {
 268   /* This reloc does nothing.  */
 269   HOWTO (R_PPC64_NONE,          /* type */
 270          0,                     /* rightshift */
 271          3,                     /* size (0 = byte, 1 = short, 2 = long) */
 272          0,                     /* bitsize */
 273          FALSE,                 /* pc_relative */
 274          0,                     /* bitpos */
 275          complain_overflow_dont, /* complain_on_overflow */
 276          bfd_elf_generic_reloc, /* special_function */
 277          "R_PPC64_NONE",        /* name */
 278          FALSE,                 /* partial_inplace */
 279          0,                     /* src_mask */
 280          0,                     /* dst_mask */
 281          FALSE),                /* pcrel_offset */
 282
 283   /* A standard 32 bit relocation.  */
 284   HOWTO (R_PPC64_ADDR32,        /* type */
 285          0,                     /* rightshift */
 286          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 287          32,                    /* bitsize */
 288          FALSE,                 /* pc_relative */
 289          0,                     /* bitpos */
 290          complain_overflow_bitfield, /* complain_on_overflow */
 291          bfd_elf_generic_reloc, /* special_function */
 292          "R_PPC64_ADDR32",      /* name */
 293          FALSE,                 /* partial_inplace */
 294          0,                     /* src_mask */
 295          0xffffffff,            /* dst_mask */
 296          FALSE),                /* pcrel_offset */
 297
 298   /* An absolute 26 bit branch; the lower two bits must be zero.
 299      FIXME: we don't check that, we just clear them.  */
 300   HOWTO (R_PPC64_ADDR24,        /* type */
 301          0,                     /* rightshift */
 302          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 303          26,                    /* bitsize */
 304          FALSE,                 /* pc_relative */
 305          0,                     /* bitpos */
 306          complain_overflow_bitfield, /* complain_on_overflow */
 307          bfd_elf_generic_reloc, /* special_function */
 308          "R_PPC64_ADDR24",      /* name */
 309          FALSE,                 /* partial_inplace */
 310          0,                     /* src_mask */
 311          0x03fffffc,            /* dst_mask */
 312          FALSE),                /* pcrel_offset */
 313
 314   /* A standard 16 bit relocation.  */
 315   HOWTO (R_PPC64_ADDR16,        /* type */
 316          0,                     /* rightshift */
 317          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 318          16,                    /* bitsize */
 319          FALSE,                 /* pc_relative */
 320          0,                     /* bitpos */
 321          complain_overflow_bitfield, /* complain_on_overflow */
 322          bfd_elf_generic_reloc, /* special_function */
 323          "R_PPC64_ADDR16",      /* name */
 324          FALSE,                 /* partial_inplace */
 325          0,                     /* src_mask */
 326          0xffff,                /* dst_mask */
 327          FALSE),                /* pcrel_offset */
 328
 329   /* A 16 bit relocation without overflow.  */
 330   HOWTO (R_PPC64_ADDR16_LO,     /* type */
 331          0,                     /* rightshift */
 332          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 333          16,                    /* bitsize */
 334          FALSE,                 /* pc_relative */
 335          0,                     /* bitpos */
 336          complain_overflow_dont,/* complain_on_overflow */
 337          bfd_elf_generic_reloc, /* special_function */
 338          "R_PPC64_ADDR16_LO",   /* name */
 339          FALSE,                 /* partial_inplace */
 340          0,                     /* src_mask */
 341          0xffff,                /* dst_mask */
 342          FALSE),                /* pcrel_offset */
 343
 344   /* Bits 16-31 of an address.  */
 345   HOWTO (R_PPC64_ADDR16_HI,     /* type */
 346          16,                    /* rightshift */
 347          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 348          16,                    /* bitsize */
 349          FALSE,                 /* pc_relative */
 350          0,                     /* bitpos */
 351          complain_overflow_signed, /* complain_on_overflow */
 352          bfd_elf_generic_reloc, /* special_function */
 353          "R_PPC64_ADDR16_HI",   /* name */
 354          FALSE,                 /* partial_inplace */
 355          0,                     /* src_mask */
 356          0xffff,                /* dst_mask */
 357          FALSE),                /* pcrel_offset */
 358
 359   /* Bits 16-31 of an address, plus 1 if the contents of the low 16
 360      bits, treated as a signed number, is negative.  */
 361   HOWTO (R_PPC64_ADDR16_HA,     /* type */
 362          16,                    /* rightshift */
 363          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 364          16,                    /* bitsize */
 365          FALSE,                 /* pc_relative */
 366          0,                     /* bitpos */
 367          complain_overflow_signed, /* complain_on_overflow */
 368          ppc64_elf_ha_reloc,    /* special_function */
 369          "R_PPC64_ADDR16_HA",   /* name */
 370          FALSE,                 /* partial_inplace */
 371          0,                     /* src_mask */
 372          0xffff,                /* dst_mask */
 373          FALSE),                /* pcrel_offset */
 374
 375   /* An absolute 16 bit branch; the lower two bits must be zero.
 376      FIXME: we don't check that, we just clear them.  */
 377   HOWTO (R_PPC64_ADDR14,        /* type */
 378          0,                     /* rightshift */
 379          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 380          16,                    /* bitsize */
 381          FALSE,                 /* pc_relative */
 382          0,                     /* bitpos */
 383          complain_overflow_signed, /* complain_on_overflow */
 384          ppc64_elf_branch_reloc, /* special_function */
 385          "R_PPC64_ADDR14",      /* name */
 386          FALSE,                 /* partial_inplace */
 387          0,                     /* src_mask */
 388          0x0000fffc,            /* dst_mask */
 389          FALSE),                /* pcrel_offset */
 390
 391   /* An absolute 16 bit branch, for which bit 10 should be set to
 392      indicate that the branch is expected to be taken.  The lower two
 393      bits must be zero.  */
 394   HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
 395          0,                     /* rightshift */
 396          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 397          16,                    /* bitsize */
 398          FALSE,                 /* pc_relative */
 399          0,                     /* bitpos */
 400          complain_overflow_signed, /* complain_on_overflow */
 401          ppc64_elf_brtaken_reloc, /* special_function */
 402          "R_PPC64_ADDR14_BRTAKEN",/* name */
 403          FALSE,                 /* partial_inplace */
 404          0,                     /* src_mask */
 405          0x0000fffc,            /* dst_mask */
 406          FALSE),                /* pcrel_offset */
 407
 408   /* An absolute 16 bit branch, for which bit 10 should be set to
 409      indicate that the branch is not expected to be taken.  The lower
 410      two bits must be zero.  */
 411   HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
 412          0,                     /* rightshift */
 413          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 414          16,                    /* bitsize */
 415          FALSE,                 /* pc_relative */
 416          0,                     /* bitpos */
 417          complain_overflow_signed, /* complain_on_overflow */
 418          ppc64_elf_brtaken_reloc, /* special_function */
 419          "R_PPC64_ADDR14_BRNTAKEN",/* name */
 420          FALSE,                 /* partial_inplace */
 421          0,                     /* src_mask */
 422          0x0000fffc,            /* dst_mask */
 423          FALSE),                /* pcrel_offset */
 424
 425   /* A relative 26 bit branch; the lower two bits must be zero.  */
 426   HOWTO (R_PPC64_REL24,         /* type */
 427          0,                     /* rightshift */
 428          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 429          26,                    /* bitsize */
 430          TRUE,                  /* pc_relative */
 431          0,                     /* bitpos */
 432          complain_overflow_signed, /* complain_on_overflow */
 433          ppc64_elf_branch_reloc, /* special_function */
 434          "R_PPC64_REL24",       /* name */
 435          FALSE,                 /* partial_inplace */
 436          0,                     /* src_mask */
 437          0x03fffffc,            /* dst_mask */
 438          TRUE),                 /* pcrel_offset */
 439
 440   /* A relative 16 bit branch; the lower two bits must be zero.  */
 441   HOWTO (R_PPC64_REL14,         /* type */
 442          0,                     /* rightshift */
 443          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 444          16,                    /* bitsize */
 445          TRUE,                  /* pc_relative */
 446          0,                     /* bitpos */
 447          complain_overflow_signed, /* complain_on_overflow */
 448          ppc64_elf_branch_reloc, /* special_function */
 449          "R_PPC64_REL14",       /* name */
 450          FALSE,                 /* partial_inplace */
 451          0,                     /* src_mask */
 452          0x0000fffc,            /* dst_mask */
 453          TRUE),                 /* pcrel_offset */
 454
 455   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 456      the branch is expected to be taken.  The lower two bits must be
 457      zero.  */
 458   HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
 459          0,                     /* rightshift */
 460          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 461          16,                    /* bitsize */
 462          TRUE,                  /* pc_relative */
 463          0,                     /* bitpos */
 464          complain_overflow_signed, /* complain_on_overflow */
 465          ppc64_elf_brtaken_reloc, /* special_function */
 466          "R_PPC64_REL14_BRTAKEN", /* name */
 467          FALSE,                 /* partial_inplace */
 468          0,                     /* src_mask */
 469          0x0000fffc,            /* dst_mask */
 470          TRUE),                 /* pcrel_offset */
 471
 472   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 473      the branch is not expected to be taken.  The lower two bits must
 474      be zero.  */
 475   HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
 476          0,                     /* rightshift */
 477          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 478          16,                    /* bitsize */
 479          TRUE,                  /* pc_relative */
 480          0,                     /* bitpos */
 481          complain_overflow_signed, /* complain_on_overflow */
 482          ppc64_elf_brtaken_reloc, /* special_function */
 483          "R_PPC64_REL14_BRNTAKEN",/* name */
 484          FALSE,                 /* partial_inplace */
 485          0,                     /* src_mask */
 486          0x0000fffc,            /* dst_mask */
 487          TRUE),                 /* pcrel_offset */
 488
 489   /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
 490      symbol.  */
 491   HOWTO (R_PPC64_GOT16,         /* type */
 492          0,                     /* rightshift */
 493          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 494          16,                    /* bitsize */
 495          FALSE,                 /* pc_relative */
 496          0,                     /* bitpos */
 497          complain_overflow_signed, /* complain_on_overflow */
 498          ppc64_elf_unhandled_reloc, /* special_function */
 499          "R_PPC64_GOT16",       /* name */
 500          FALSE,                 /* partial_inplace */
 501          0,                     /* src_mask */
 502          0xffff,                /* dst_mask */
 503          FALSE),                /* pcrel_offset */
 504
 505   /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
 506      the symbol.  */
 507   HOWTO (R_PPC64_GOT16_LO,      /* type */
 508          0,                     /* rightshift */
 509          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 510          16,                    /* bitsize */
 511          FALSE,                 /* pc_relative */
 512          0,                     /* bitpos */
 513          complain_overflow_dont, /* complain_on_overflow */
 514          ppc64_elf_unhandled_reloc, /* special_function */
 515          "R_PPC64_GOT16_LO",    /* name */
 516          FALSE,                 /* partial_inplace */
 517          0,                     /* src_mask */
 518          0xffff,                /* dst_mask */
 519          FALSE),                /* pcrel_offset */
 520
 521   /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
 522      the symbol.  */
 523   HOWTO (R_PPC64_GOT16_HI,      /* type */
 524          16,                    /* rightshift */
 525          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 526          16,                    /* bitsize */
 527          FALSE,                 /* pc_relative */
 528          0,                     /* bitpos */
 529          complain_overflow_signed,/* complain_on_overflow */
 530          ppc64_elf_unhandled_reloc, /* special_function */
 531          "R_PPC64_GOT16_HI",    /* name */
 532          FALSE,                 /* partial_inplace */
 533          0,                     /* src_mask */
 534          0xffff,                /* dst_mask */
 535          FALSE),                /* pcrel_offset */
 536
 537   /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
 538      the symbol.  */
 539   HOWTO (R_PPC64_GOT16_HA,      /* type */
 540          16,                    /* rightshift */
 541          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 542          16,                    /* bitsize */
 543          FALSE,                 /* pc_relative */
 544          0,                     /* bitpos */
 545          complain_overflow_signed,/* complain_on_overflow */
 546          ppc64_elf_unhandled_reloc, /* special_function */
 547          "R_PPC64_GOT16_HA",    /* name */
 548          FALSE,                 /* partial_inplace */
 549          0,                     /* src_mask */
 550          0xffff,                /* dst_mask */
 551          FALSE),                /* pcrel_offset */
 552
 553   /* This is used only by the dynamic linker.  The symbol should exist
 554      both in the object being run and in some shared library.  The
 555      dynamic linker copies the data addressed by the symbol from the
 556      shared library into the object, because the object being
 557      run has to have the data at some particular address.  */
 558   HOWTO (R_PPC64_COPY,          /* type */
 559          0,                     /* rightshift */
 560          0,                     /* this one is variable size */
 561          0,                     /* bitsize */
 562          FALSE,                 /* pc_relative */
 563          0,                     /* bitpos */
 564          complain_overflow_dont, /* complain_on_overflow */
 565          ppc64_elf_unhandled_reloc, /* special_function */
 566          "R_PPC64_COPY",        /* name */
 567          FALSE,                 /* partial_inplace */
 568          0,                     /* src_mask */
 569          0,                     /* dst_mask */
 570          FALSE),                /* pcrel_offset */
 571
 572   /* Like R_PPC64_ADDR64, but used when setting global offset table
 573      entries.  */
 574   HOWTO (R_PPC64_GLOB_DAT,      /* type */
 575          0,                     /* rightshift */
 576          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 577          64,                    /* bitsize */
 578          FALSE,                 /* pc_relative */
 579          0,                     /* bitpos */
 580          complain_overflow_dont, /* complain_on_overflow */
 581          ppc64_elf_unhandled_reloc,  /* special_function */
 582          "R_PPC64_GLOB_DAT",    /* name */
 583          FALSE,                 /* partial_inplace */
 584          0,                     /* src_mask */
 585          ONES (64),             /* dst_mask */
 586          FALSE),                /* pcrel_offset */
 587
 588   /* Created by the link editor.  Marks a procedure linkage table
 589      entry for a symbol.  */
 590   HOWTO (R_PPC64_JMP_SLOT,      /* type */
 591          0,                     /* rightshift */
 592          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 593          0,                     /* bitsize */
 594          FALSE,                 /* pc_relative */
 595          0,                     /* bitpos */
 596          complain_overflow_dont, /* complain_on_overflow */
 597          ppc64_elf_unhandled_reloc, /* special_function */
 598          "R_PPC64_JMP_SLOT",    /* name */
 599          FALSE,                 /* partial_inplace */
 600          0,                     /* src_mask */
 601          0,                     /* dst_mask */
 602          FALSE),                /* pcrel_offset */
 603
 604   /* Used only by the dynamic linker.  When the object is run, this
 605      doubleword64 is set to the load address of the object, plus the
 606      addend.  */
 607   HOWTO (R_PPC64_RELATIVE,      /* type */
 608          0,                     /* rightshift */
 609          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 610          64,                    /* bitsize */
 611          FALSE,                 /* pc_relative */
 612          0,                     /* bitpos */
 613          complain_overflow_dont, /* complain_on_overflow */
 614          bfd_elf_generic_reloc, /* special_function */
 615          "R_PPC64_RELATIVE",    /* name */
 616          FALSE,                 /* partial_inplace */
 617          0,                     /* src_mask */
 618          ONES (64),             /* dst_mask */
 619          FALSE),                /* pcrel_offset */
 620
 621   /* Like R_PPC64_ADDR32, but may be unaligned.  */
 622   HOWTO (R_PPC64_UADDR32,       /* type */
 623          0,                     /* rightshift */
 624          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 625          32,                    /* bitsize */
 626          FALSE,                 /* pc_relative */
 627          0,                     /* bitpos */
 628          complain_overflow_bitfield, /* complain_on_overflow */
 629          bfd_elf_generic_reloc, /* special_function */
 630          "R_PPC64_UADDR32",     /* name */
 631          FALSE,                 /* partial_inplace */
 632          0,                     /* src_mask */
 633          0xffffffff,            /* dst_mask */
 634          FALSE),                /* pcrel_offset */
 635
 636   /* Like R_PPC64_ADDR16, but may be unaligned.  */
 637   HOWTO (R_PPC64_UADDR16,       /* type */
 638          0,                     /* rightshift */
 639          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 640          16,                    /* bitsize */
 641          FALSE,                 /* pc_relative */
 642          0,                     /* bitpos */
 643          complain_overflow_bitfield, /* complain_on_overflow */
 644          bfd_elf_generic_reloc, /* special_function */
 645          "R_PPC64_UADDR16",     /* name */
 646          FALSE,                 /* partial_inplace */
 647          0,                     /* src_mask */
 648          0xffff,                /* dst_mask */
 649          FALSE),                /* pcrel_offset */
 650
 651   /* 32-bit PC relative.  */
 652   HOWTO (R_PPC64_REL32,         /* type */
 653          0,                     /* rightshift */
 654          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 655          32,                    /* bitsize */
 656          TRUE,                  /* pc_relative */
 657          0,                     /* bitpos */
 658          complain_overflow_signed, /* complain_on_overflow */
 659          bfd_elf_generic_reloc, /* special_function */
 660          "R_PPC64_REL32",       /* name */
 661          FALSE,                 /* partial_inplace */
 662          0,                     /* src_mask */
 663          0xffffffff,            /* dst_mask */
 664          TRUE),                 /* pcrel_offset */
 665
 666   /* 32-bit relocation to the symbol's procedure linkage table.  */
 667   HOWTO (R_PPC64_PLT32,         /* type */
 668          0,                     /* rightshift */
 669          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 670          32,                    /* bitsize */
 671          FALSE,                 /* pc_relative */
 672          0,                     /* bitpos */
 673          complain_overflow_bitfield, /* complain_on_overflow */
 674          ppc64_elf_unhandled_reloc, /* special_function */
 675          "R_PPC64_PLT32",       /* name */
 676          FALSE,                 /* partial_inplace */
 677          0,                     /* src_mask */
 678          0xffffffff,            /* dst_mask */
 679          FALSE),                /* pcrel_offset */
 680
 681   /* 32-bit PC relative relocation to the symbol's procedure linkage table.
 682      FIXME: R_PPC64_PLTREL32 not supported.  */
 683   HOWTO (R_PPC64_PLTREL32,      /* type */
 684          0,                     /* rightshift */
 685          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 686          32,                    /* bitsize */
 687          TRUE,                  /* pc_relative */
 688          0,                     /* bitpos */
 689          complain_overflow_signed, /* complain_on_overflow */
 690          ppc64_elf_unhandled_reloc, /* special_function */
 691          "R_PPC64_PLTREL32",    /* name */
 692          FALSE,                 /* partial_inplace */
 693          0,                     /* src_mask */
 694          0xffffffff,            /* dst_mask */
 695          TRUE),                 /* pcrel_offset */
 696
 697   /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
 698      the symbol.  */
 699   HOWTO (R_PPC64_PLT16_LO,      /* type */
 700          0,                     /* rightshift */
 701          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 702          16,                    /* bitsize */
 703          FALSE,                 /* pc_relative */
 704          0,                     /* bitpos */
 705          complain_overflow_dont, /* complain_on_overflow */
 706          ppc64_elf_unhandled_reloc, /* special_function */
 707          "R_PPC64_PLT16_LO",    /* name */
 708          FALSE,                 /* partial_inplace */
 709          0,                     /* src_mask */
 710          0xffff,                /* dst_mask */
 711          FALSE),                /* pcrel_offset */
 712
 713   /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
 714      the symbol.  */
 715   HOWTO (R_PPC64_PLT16_HI,      /* type */
 716          16,                    /* rightshift */
 717          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 718          16,                    /* bitsize */
 719          FALSE,                 /* pc_relative */
 720          0,                     /* bitpos */
 721          complain_overflow_signed, /* complain_on_overflow */
 722          ppc64_elf_unhandled_reloc, /* special_function */
 723          "R_PPC64_PLT16_HI",    /* name */
 724          FALSE,                 /* partial_inplace */
 725          0,                     /* src_mask */
 726          0xffff,                /* dst_mask */
 727          FALSE),                /* pcrel_offset */
 728
 729   /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
 730      the symbol.  */
 731   HOWTO (R_PPC64_PLT16_HA,      /* type */
 732          16,                    /* rightshift */
 733          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 734          16,                    /* bitsize */
 735          FALSE,                 /* pc_relative */
 736          0,                     /* bitpos */
 737          complain_overflow_signed, /* complain_on_overflow */
 738          ppc64_elf_unhandled_reloc, /* special_function */
 739          "R_PPC64_PLT16_HA",    /* name */
 740          FALSE,                 /* partial_inplace */
 741          0,                     /* src_mask */
 742          0xffff,                /* dst_mask */
 743          FALSE),                /* pcrel_offset */
 744
 745   /* 16-bit section relative relocation.  */
 746   HOWTO (R_PPC64_SECTOFF,       /* type */
 747          0,                     /* rightshift */
 748          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 749          16,                    /* bitsize */
 750          FALSE,                 /* pc_relative */
 751          0,                     /* bitpos */
 752          complain_overflow_signed, /* complain_on_overflow */
 753          ppc64_elf_sectoff_reloc, /* special_function */
 754          "R_PPC64_SECTOFF",     /* name */
 755          FALSE,                 /* partial_inplace */
 756          0,                     /* src_mask */
 757          0xffff,                /* dst_mask */
 758          FALSE),                /* pcrel_offset */
 759
 760   /* Like R_PPC64_SECTOFF, but no overflow warning.  */
 761   HOWTO (R_PPC64_SECTOFF_LO,    /* type */
 762          0,                     /* rightshift */
 763          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 764          16,                    /* bitsize */
 765          FALSE,                 /* pc_relative */
 766          0,                     /* bitpos */
 767          complain_overflow_dont, /* complain_on_overflow */
 768          ppc64_elf_sectoff_reloc, /* special_function */
 769          "R_PPC64_SECTOFF_LO",  /* name */
 770          FALSE,                 /* partial_inplace */
 771          0,                     /* src_mask */
 772          0xffff,                /* dst_mask */
 773          FALSE),                /* pcrel_offset */
 774
 775   /* 16-bit upper half section relative relocation.  */
 776   HOWTO (R_PPC64_SECTOFF_HI,    /* type */
 777          16,                    /* rightshift */
 778          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 779          16,                    /* bitsize */
 780          FALSE,                 /* pc_relative */
 781          0,                     /* bitpos */
 782          complain_overflow_signed, /* complain_on_overflow */
 783          ppc64_elf_sectoff_reloc, /* special_function */
 784          "R_PPC64_SECTOFF_HI",  /* name */
 785          FALSE,                 /* partial_inplace */
 786          0,                     /* src_mask */
 787          0xffff,                /* dst_mask */
 788          FALSE),                /* pcrel_offset */
 789
 790   /* 16-bit upper half adjusted section relative relocation.  */
 791   HOWTO (R_PPC64_SECTOFF_HA,    /* type */
 792          16,                    /* rightshift */
 793          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 794          16,                    /* bitsize */
 795          FALSE,                 /* pc_relative */
 796          0,                     /* bitpos */
 797          complain_overflow_signed, /* complain_on_overflow */
 798          ppc64_elf_sectoff_ha_reloc, /* special_function */
 799          "R_PPC64_SECTOFF_HA",  /* name */
 800          FALSE,                 /* partial_inplace */
 801          0,                     /* src_mask */
 802          0xffff,                /* dst_mask */
 803          FALSE),                /* pcrel_offset */
 804
 805   /* Like R_PPC64_REL24 without touching the two least significant bits.  */
 806   HOWTO (R_PPC64_REL30,         /* type */
 807          2,                     /* rightshift */
 808          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 809          30,                    /* bitsize */
 810          TRUE,                  /* pc_relative */
 811          0,                     /* bitpos */
 812          complain_overflow_dont, /* complain_on_overflow */
 813          bfd_elf_generic_reloc, /* special_function */
 814          "R_PPC64_REL30",       /* name */
 815          FALSE,                 /* partial_inplace */
 816          0,                     /* src_mask */
 817          0xfffffffc,            /* dst_mask */
 818          TRUE),                 /* pcrel_offset */
 819
 820   /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI.  */
 821
 822   /* A standard 64-bit relocation.  */
 823   HOWTO (R_PPC64_ADDR64,        /* type */
 824          0,                     /* rightshift */
 825          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 826          64,                    /* bitsize */
 827          FALSE,                 /* pc_relative */
 828          0,                     /* bitpos */
 829          complain_overflow_dont, /* complain_on_overflow */
 830          bfd_elf_generic_reloc, /* special_function */
 831          "R_PPC64_ADDR64",      /* name */
 832          FALSE,                 /* partial_inplace */
 833          0,                     /* src_mask */
 834          ONES (64),             /* dst_mask */
 835          FALSE),                /* pcrel_offset */
 836
 837   /* The bits 32-47 of an address.  */
 838   HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
 839          32,                    /* rightshift */
 840          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 841          16,                    /* bitsize */
 842          FALSE,                 /* pc_relative */
 843          0,                     /* bitpos */
 844          complain_overflow_dont, /* complain_on_overflow */
 845          bfd_elf_generic_reloc, /* special_function */
 846          "R_PPC64_ADDR16_HIGHER", /* name */
 847          FALSE,                 /* partial_inplace */
 848          0,                     /* src_mask */
 849          0xffff,                /* dst_mask */
 850          FALSE),                /* pcrel_offset */
 851
 852   /* The bits 32-47 of an address, plus 1 if the contents of the low
 853      16 bits, treated as a signed number, is negative.  */
 854   HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
 855          32,                    /* rightshift */
 856          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 857          16,                    /* bitsize */
 858          FALSE,                 /* pc_relative */
 859          0,                     /* bitpos */
 860          complain_overflow_dont, /* complain_on_overflow */
 861          ppc64_elf_ha_reloc,    /* special_function */
 862          "R_PPC64_ADDR16_HIGHERA", /* name */
 863          FALSE,                 /* partial_inplace */
 864          0,                     /* src_mask */
 865          0xffff,                /* dst_mask */
 866          FALSE),                /* pcrel_offset */
 867
 868   /* The bits 48-63 of an address.  */
 869   HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
 870          48,                    /* rightshift */
 871          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 872          16,                    /* bitsize */
 873          FALSE,                 /* pc_relative */
 874          0,                     /* bitpos */
 875          complain_overflow_dont, /* complain_on_overflow */
 876          bfd_elf_generic_reloc, /* special_function */
 877          "R_PPC64_ADDR16_HIGHEST", /* name */
 878          FALSE,                 /* partial_inplace */
 879          0,                     /* src_mask */
 880          0xffff,                /* dst_mask */
 881          FALSE),                /* pcrel_offset */
 882
 883   /* The bits 48-63 of an address, plus 1 if the contents of the low
 884      16 bits, treated as a signed number, is negative.  */
 885   HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
 886          48,                    /* rightshift */
 887          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 888          16,                    /* bitsize */
 889          FALSE,                 /* pc_relative */
 890          0,                     /* bitpos */
 891          complain_overflow_dont, /* complain_on_overflow */
 892          ppc64_elf_ha_reloc,    /* special_function */
 893          "R_PPC64_ADDR16_HIGHESTA", /* name */
 894          FALSE,                 /* partial_inplace */
 895          0,                     /* src_mask */
 896          0xffff,                /* dst_mask */
 897          FALSE),                /* pcrel_offset */
 898
 899   /* Like ADDR64, but may be unaligned.  */
 900   HOWTO (R_PPC64_UADDR64,       /* type */
 901          0,                     /* rightshift */
 902          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 903          64,                    /* bitsize */
 904          FALSE,                 /* pc_relative */
 905          0,                     /* bitpos */
 906          complain_overflow_dont, /* complain_on_overflow */
 907          bfd_elf_generic_reloc, /* special_function */
 908          "R_PPC64_UADDR64",     /* name */
 909          FALSE,                 /* partial_inplace */
 910          0,                     /* src_mask */
 911          ONES (64),             /* dst_mask */
 912          FALSE),                /* pcrel_offset */
 913
 914   /* 64-bit relative relocation.  */
 915   HOWTO (R_PPC64_REL64,         /* type */
 916          0,                     /* rightshift */
 917          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 918          64,                    /* bitsize */
 919          TRUE,                  /* pc_relative */
 920          0,                     /* bitpos */
 921          complain_overflow_dont, /* complain_on_overflow */
 922          bfd_elf_generic_reloc, /* special_function */
 923          "R_PPC64_REL64",       /* name */
 924          FALSE,                 /* partial_inplace */
 925          0,                     /* src_mask */
 926          ONES (64),             /* dst_mask */
 927          TRUE),                 /* pcrel_offset */
 928
 929   /* 64-bit relocation to the symbol's procedure linkage table.  */
 930   HOWTO (R_PPC64_PLT64,         /* type */
 931          0,                     /* rightshift */
 932          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 933          64,                    /* bitsize */
 934          FALSE,                 /* pc_relative */
 935          0,                     /* bitpos */
 936          complain_overflow_dont, /* complain_on_overflow */
 937          ppc64_elf_unhandled_reloc, /* special_function */
 938          "R_PPC64_PLT64",       /* name */
 939          FALSE,                 /* partial_inplace */
 940          0,                     /* src_mask */
 941          ONES (64),             /* dst_mask */
 942          FALSE),                /* pcrel_offset */
 943
 944   /* 64-bit PC relative relocation to the symbol's procedure linkage
 945      table.  */
 946   /* FIXME: R_PPC64_PLTREL64 not supported.  */
 947   HOWTO (R_PPC64_PLTREL64,      /* type */
 948          0,                     /* rightshift */
 949          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 950          64,                    /* bitsize */
 951          TRUE,                  /* pc_relative */
 952          0,                     /* bitpos */
 953          complain_overflow_dont, /* complain_on_overflow */
 954          ppc64_elf_unhandled_reloc, /* special_function */
 955          "R_PPC64_PLTREL64",    /* name */
 956          FALSE,                 /* partial_inplace */
 957          0,                     /* src_mask */
 958          ONES (64),             /* dst_mask */
 959          TRUE),                 /* pcrel_offset */
 960
 961   /* 16 bit TOC-relative relocation.  */
 962
 963   /* R_PPC64_TOC16        47       half16*      S + A - .TOC.  */
 964   HOWTO (R_PPC64_TOC16,         /* type */
 965          0,                     /* rightshift */
 966          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 967          16,                    /* bitsize */
 968          FALSE,                 /* pc_relative */
 969          0,                     /* bitpos */
 970          complain_overflow_signed, /* complain_on_overflow */
 971          ppc64_elf_toc_reloc,   /* special_function */
 972          "R_PPC64_TOC16",       /* name */
 973          FALSE,                 /* partial_inplace */
 974          0,                     /* src_mask */
 975          0xffff,                /* dst_mask */
 976          FALSE),                /* pcrel_offset */
 977
 978   /* 16 bit TOC-relative relocation without overflow.  */
 979
 980   /* R_PPC64_TOC16_LO     48       half16        #lo (S + A - .TOC.)  */
 981   HOWTO (R_PPC64_TOC16_LO,      /* type */
 982          0,                     /* rightshift */
 983          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 984          16,                    /* bitsize */
 985          FALSE,                 /* pc_relative */
 986          0,                     /* bitpos */
 987          complain_overflow_dont, /* complain_on_overflow */
 988          ppc64_elf_toc_reloc,   /* special_function */
 989          "R_PPC64_TOC16_LO",    /* name */
 990          FALSE,                 /* partial_inplace */
 991          0,                     /* src_mask */
 992          0xffff,                /* dst_mask */
 993          FALSE),                /* pcrel_offset */
 994
 995   /* 16 bit TOC-relative relocation, high 16 bits.  */
 996
 997   /* R_PPC64_TOC16_HI     49       half16        #hi (S + A - .TOC.)  */
 998   HOWTO (R_PPC64_TOC16_HI,      /* type */
 999          16,                    /* rightshift */
1000          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1001          16,                    /* bitsize */
1002          FALSE,                 /* pc_relative */
1003          0,                     /* bitpos */
1004          complain_overflow_signed, /* complain_on_overflow */
1005          ppc64_elf_toc_reloc,   /* special_function */
1006          "R_PPC64_TOC16_HI",    /* name */
1007          FALSE,                 /* partial_inplace */
1008          0,                     /* src_mask */
1009          0xffff,                /* dst_mask */
1010          FALSE),                /* pcrel_offset */
1011
1012   /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
1013      contents of the low 16 bits, treated as a signed number, is
1014      negative.  */
1015
1016   /* R_PPC64_TOC16_HA     50       half16        #ha (S + A - .TOC.)  */
1017   HOWTO (R_PPC64_TOC16_HA,      /* type */
1018          16,                    /* rightshift */
1019          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1020          16,                    /* bitsize */
1021          FALSE,                 /* pc_relative */
1022          0,                     /* bitpos */
1023          complain_overflow_signed, /* complain_on_overflow */
1024          ppc64_elf_toc_ha_reloc, /* special_function */
1025          "R_PPC64_TOC16_HA",    /* name */
1026          FALSE,                 /* partial_inplace */
1027          0,                     /* src_mask */
1028          0xffff,                /* dst_mask */
1029          FALSE),                /* pcrel_offset */
1030
1031   /* 64-bit relocation; insert value of TOC base (.TOC.).  */
1032
1033   /* R_PPC64_TOC                  51       doubleword64  .TOC.  */
1034   HOWTO (R_PPC64_TOC,           /* type */
1035          0,                     /* rightshift */
1036          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1037          64,                    /* bitsize */
1038          FALSE,                 /* pc_relative */
1039          0,                     /* bitpos */
1040          complain_overflow_dont, /* complain_on_overflow */
1041          ppc64_elf_toc64_reloc, /* special_function */
1042          "R_PPC64_TOC",         /* name */
1043          FALSE,                 /* partial_inplace */
1044          0,                     /* src_mask */
1045          ONES (64),             /* dst_mask */
1046          FALSE),                /* pcrel_offset */
1047
1048   /* Like R_PPC64_GOT16, but also informs the link editor that the
1049      value to relocate may (!) refer to a PLT entry which the link
1050      editor (a) may replace with the symbol value.  If the link editor
1051      is unable to fully resolve the symbol, it may (b) create a PLT
1052      entry and store the address to the new PLT entry in the GOT.
1053      This permits lazy resolution of function symbols at run time.
1054      The link editor may also skip all of this and just (c) emit a
1055      R_PPC64_GLOB_DAT to tie the symbol to the GOT entry.  */
1056   /* FIXME: R_PPC64_PLTGOT16 not implemented.  */
1057     HOWTO (R_PPC64_PLTGOT16,    /* type */
1058          0,                     /* rightshift */
1059          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1060          16,                    /* bitsize */
1061          FALSE,                 /* pc_relative */
1062          0,                     /* bitpos */
1063          complain_overflow_signed, /* complain_on_overflow */
1064          ppc64_elf_unhandled_reloc, /* special_function */
1065          "R_PPC64_PLTGOT16",    /* name */
1066          FALSE,                 /* partial_inplace */
1067          0,                     /* src_mask */
1068          0xffff,                /* dst_mask */
1069          FALSE),                /* pcrel_offset */
1070
1071   /* Like R_PPC64_PLTGOT16, but without overflow.  */
1072   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1073   HOWTO (R_PPC64_PLTGOT16_LO,   /* type */
1074          0,                     /* rightshift */
1075          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1076          16,                    /* bitsize */
1077          FALSE,                 /* pc_relative */
1078          0,                     /* bitpos */
1079          complain_overflow_dont, /* complain_on_overflow */
1080          ppc64_elf_unhandled_reloc, /* special_function */
1081          "R_PPC64_PLTGOT16_LO", /* name */
1082          FALSE,                 /* partial_inplace */
1083          0,                     /* src_mask */
1084          0xffff,                /* dst_mask */
1085          FALSE),                /* pcrel_offset */
1086
1087   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address.  */
1088   /* FIXME: R_PPC64_PLTGOT16_HI not implemented.  */
1089   HOWTO (R_PPC64_PLTGOT16_HI,   /* type */
1090          16,                    /* rightshift */
1091          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1092          16,                    /* bitsize */
1093          FALSE,                 /* pc_relative */
1094          0,                     /* bitpos */
1095          complain_overflow_signed, /* complain_on_overflow */
1096          ppc64_elf_unhandled_reloc, /* special_function */
1097          "R_PPC64_PLTGOT16_HI", /* name */
1098          FALSE,                 /* partial_inplace */
1099          0,                     /* src_mask */
1100          0xffff,                /* dst_mask */
1101          FALSE),                /* pcrel_offset */
1102
1103   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1104      1 if the contents of the low 16 bits, treated as a signed number,
1105      is negative.  */
1106   /* FIXME: R_PPC64_PLTGOT16_HA not implemented.  */
1107   HOWTO (R_PPC64_PLTGOT16_HA,   /* type */
1108          16,                    /* rightshift */
1109          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1110          16,                    /* bitsize */
1111          FALSE,                 /* pc_relative */
1112          0,                     /* bitpos */
1113          complain_overflow_signed, /* complain_on_overflow */
1114          ppc64_elf_unhandled_reloc, /* special_function */
1115          "R_PPC64_PLTGOT16_HA", /* name */
1116          FALSE,                 /* partial_inplace */
1117          0,                     /* src_mask */
1118          0xffff,                /* dst_mask */
1119          FALSE),                /* pcrel_offset */
1120
1121   /* Like R_PPC64_ADDR16, but for instructions with a DS field.  */
1122   HOWTO (R_PPC64_ADDR16_DS,     /* type */
1123          0,                     /* rightshift */
1124          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1125          16,                    /* bitsize */
1126          FALSE,                 /* pc_relative */
1127          0,                     /* bitpos */
1128          complain_overflow_signed, /* complain_on_overflow */
1129          bfd_elf_generic_reloc, /* special_function */
1130          "R_PPC64_ADDR16_DS",   /* name */
1131          FALSE,                 /* partial_inplace */
1132          0,                     /* src_mask */
1133          0xfffc,                /* dst_mask */
1134          FALSE),                /* pcrel_offset */
1135
1136   /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field.  */
1137   HOWTO (R_PPC64_ADDR16_LO_DS,  /* type */
1138          0,                     /* rightshift */
1139          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1140          16,                    /* bitsize */
1141          FALSE,                 /* pc_relative */
1142          0,                     /* bitpos */
1143          complain_overflow_dont,/* complain_on_overflow */
1144          bfd_elf_generic_reloc, /* special_function */
1145          "R_PPC64_ADDR16_LO_DS",/* name */
1146          FALSE,                 /* partial_inplace */
1147          0,                     /* src_mask */
1148          0xfffc,                /* dst_mask */
1149          FALSE),                /* pcrel_offset */
1150
1151   /* Like R_PPC64_GOT16, but for instructions with a DS field.  */
1152   HOWTO (R_PPC64_GOT16_DS,      /* type */
1153          0,                     /* rightshift */
1154          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1155          16,                    /* bitsize */
1156          FALSE,                 /* pc_relative */
1157          0,                     /* bitpos */
1158          complain_overflow_signed, /* complain_on_overflow */
1159          ppc64_elf_unhandled_reloc, /* special_function */
1160          "R_PPC64_GOT16_DS",    /* name */
1161          FALSE,                 /* partial_inplace */
1162          0,                     /* src_mask */
1163          0xfffc,                /* dst_mask */
1164          FALSE),                /* pcrel_offset */
1165
1166   /* Like R_PPC64_GOT16_LO, but for instructions with a DS field.  */
1167   HOWTO (R_PPC64_GOT16_LO_DS,   /* type */
1168          0,                     /* rightshift */
1169          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1170          16,                    /* bitsize */
1171          FALSE,                 /* pc_relative */
1172          0,                     /* bitpos */
1173          complain_overflow_dont, /* complain_on_overflow */
1174          ppc64_elf_unhandled_reloc, /* special_function */
1175          "R_PPC64_GOT16_LO_DS", /* name */
1176          FALSE,                 /* partial_inplace */
1177          0,                     /* src_mask */
1178          0xfffc,                /* dst_mask */
1179          FALSE),                /* pcrel_offset */
1180
1181   /* Like R_PPC64_PLT16_LO, but for instructions with a DS field.  */
1182   HOWTO (R_PPC64_PLT16_LO_DS,   /* type */
1183          0,                     /* rightshift */
1184          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1185          16,                    /* bitsize */
1186          FALSE,                 /* pc_relative */
1187          0,                     /* bitpos */
1188          complain_overflow_dont, /* complain_on_overflow */
1189          ppc64_elf_unhandled_reloc, /* special_function */
1190          "R_PPC64_PLT16_LO_DS", /* name */
1191          FALSE,                 /* partial_inplace */
1192          0,                     /* src_mask */
1193          0xfffc,                /* dst_mask */
1194          FALSE),                /* pcrel_offset */
1195
1196   /* Like R_PPC64_SECTOFF, but for instructions with a DS field.  */
1197   HOWTO (R_PPC64_SECTOFF_DS,    /* type */
1198          0,                     /* rightshift */
1199          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1200          16,                    /* bitsize */
1201          FALSE,                 /* pc_relative */
1202          0,                     /* bitpos */
1203          complain_overflow_signed, /* complain_on_overflow */
1204          ppc64_elf_sectoff_reloc, /* special_function */
1205          "R_PPC64_SECTOFF_DS",  /* name */
1206          FALSE,                 /* partial_inplace */
1207          0,                     /* src_mask */
1208          0xfffc,                /* dst_mask */
1209          FALSE),                /* pcrel_offset */
1210
1211   /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field.  */
1212   HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1213          0,                     /* rightshift */
1214          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1215          16,                    /* bitsize */
1216          FALSE,                 /* pc_relative */
1217          0,                     /* bitpos */
1218          complain_overflow_dont, /* complain_on_overflow */
1219          ppc64_elf_sectoff_reloc, /* special_function */
1220          "R_PPC64_SECTOFF_LO_DS",/* name */
1221          FALSE,                 /* partial_inplace */
1222          0,                     /* src_mask */
1223          0xfffc,                /* dst_mask */
1224          FALSE),                /* pcrel_offset */
1225
1226   /* Like R_PPC64_TOC16, but for instructions with a DS field.  */
1227   HOWTO (R_PPC64_TOC16_DS,      /* type */
1228          0,                     /* rightshift */
1229          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1230          16,                    /* bitsize */
1231          FALSE,                 /* pc_relative */
1232          0,                     /* bitpos */
1233          complain_overflow_signed, /* complain_on_overflow */
1234          ppc64_elf_toc_reloc,   /* special_function */
1235          "R_PPC64_TOC16_DS",    /* name */
1236          FALSE,                 /* partial_inplace */
1237          0,                     /* src_mask */
1238          0xfffc,                /* dst_mask */
1239          FALSE),                /* pcrel_offset */
1240
1241   /* Like R_PPC64_TOC16_LO, but for instructions with a DS field.  */
1242   HOWTO (R_PPC64_TOC16_LO_DS,   /* type */
1243          0,                     /* rightshift */
1244          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1245          16,                    /* bitsize */
1246          FALSE,                 /* pc_relative */
1247          0,                     /* bitpos */
1248          complain_overflow_dont, /* complain_on_overflow */
1249          ppc64_elf_toc_reloc,   /* special_function */
1250          "R_PPC64_TOC16_LO_DS", /* name */
1251          FALSE,                 /* partial_inplace */
1252          0,                     /* src_mask */
1253          0xfffc,                /* dst_mask */
1254          FALSE),                /* pcrel_offset */
1255
1256   /* Like R_PPC64_PLTGOT16, but for instructions with a DS field.  */
1257   /* FIXME: R_PPC64_PLTGOT16_DS not implemented.  */
1258   HOWTO (R_PPC64_PLTGOT16_DS,   /* type */
1259          0,                     /* rightshift */
1260          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1261          16,                    /* bitsize */
1262          FALSE,                 /* pc_relative */
1263          0,                     /* bitpos */
1264          complain_overflow_signed, /* complain_on_overflow */
1265          ppc64_elf_unhandled_reloc, /* special_function */
1266          "R_PPC64_PLTGOT16_DS", /* name */
1267          FALSE,                 /* partial_inplace */
1268          0,                     /* src_mask */
1269          0xfffc,                /* dst_mask */
1270          FALSE),                /* pcrel_offset */
1271
1272   /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field.  */
1273   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1274   HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1275          0,                     /* rightshift */
1276          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1277          16,                    /* bitsize */
1278          FALSE,                 /* pc_relative */
1279          0,                     /* bitpos */
1280          complain_overflow_dont, /* complain_on_overflow */
1281          ppc64_elf_unhandled_reloc, /* special_function */
1282          "R_PPC64_PLTGOT16_LO_DS",/* name */
1283          FALSE,                 /* partial_inplace */
1284          0,                     /* src_mask */
1285          0xfffc,                /* dst_mask */
1286          FALSE),                /* pcrel_offset */
1287
1288   /* Marker relocs for TLS.  */
1289   HOWTO (R_PPC64_TLS,
1290          0,                     /* rightshift */
1291          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1292          32,                    /* bitsize */
1293          FALSE,                 /* pc_relative */
1294          0,                     /* bitpos */
1295          complain_overflow_dont, /* complain_on_overflow */
1296          bfd_elf_generic_reloc, /* special_function */
1297          "R_PPC64_TLS",         /* name */
1298          FALSE,                 /* partial_inplace */
1299          0,                     /* src_mask */
1300          0,                     /* dst_mask */
1301          FALSE),                /* pcrel_offset */
1302
1303   HOWTO (R_PPC64_TLSGD,
1304          0,                     /* rightshift */
1305          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1306          32,                    /* bitsize */
1307          FALSE,                 /* pc_relative */
1308          0,                     /* bitpos */
1309          complain_overflow_dont, /* complain_on_overflow */
1310          bfd_elf_generic_reloc, /* special_function */
1311          "R_PPC64_TLSGD",       /* name */
1312          FALSE,                 /* partial_inplace */
1313          0,                     /* src_mask */
1314          0,                     /* dst_mask */
1315          FALSE),                /* pcrel_offset */
1316
1317   HOWTO (R_PPC64_TLSLD,
1318          0,                     /* rightshift */
1319          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1320          32,                    /* bitsize */
1321          FALSE,                 /* pc_relative */
1322          0,                     /* bitpos */
1323          complain_overflow_dont, /* complain_on_overflow */
1324          bfd_elf_generic_reloc, /* special_function */
1325          "R_PPC64_TLSLD",       /* name */
1326          FALSE,                 /* partial_inplace */
1327          0,                     /* src_mask */
1328          0,                     /* dst_mask */
1329          FALSE),                /* pcrel_offset */
1330
1331   HOWTO (R_PPC64_TOCSAVE,
1332          0,                     /* rightshift */
1333          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1334          32,                    /* bitsize */
1335          FALSE,                 /* pc_relative */
1336          0,                     /* bitpos */
1337          complain_overflow_dont, /* complain_on_overflow */
1338          bfd_elf_generic_reloc, /* special_function */
1339          "R_PPC64_TOCSAVE",     /* name */
1340          FALSE,                 /* partial_inplace */
1341          0,                     /* src_mask */
1342          0,                     /* dst_mask */
1343          FALSE),                /* pcrel_offset */
1344
1345   /* Computes the load module index of the load module that contains the
1346      definition of its TLS sym.  */
1347   HOWTO (R_PPC64_DTPMOD64,
1348          0,                     /* rightshift */
1349          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1350          64,                    /* bitsize */
1351          FALSE,                 /* pc_relative */
1352          0,                     /* bitpos */
1353          complain_overflow_dont, /* complain_on_overflow */
1354          ppc64_elf_unhandled_reloc, /* special_function */
1355          "R_PPC64_DTPMOD64",    /* name */
1356          FALSE,                 /* partial_inplace */
1357          0,                     /* src_mask */
1358          ONES (64),             /* dst_mask */
1359          FALSE),                /* pcrel_offset */
1360
1361   /* Computes a dtv-relative displacement, the difference between the value
1362      of sym+add and the base address of the thread-local storage block that
1363      contains the definition of sym, minus 0x8000.  */
1364   HOWTO (R_PPC64_DTPREL64,
1365          0,                     /* rightshift */
1366          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1367          64,                    /* bitsize */
1368          FALSE,                 /* pc_relative */
1369          0,                     /* bitpos */
1370          complain_overflow_dont, /* complain_on_overflow */
1371          ppc64_elf_unhandled_reloc, /* special_function */
1372          "R_PPC64_DTPREL64",    /* name */
1373          FALSE,                 /* partial_inplace */
1374          0,                     /* src_mask */
1375          ONES (64),             /* dst_mask */
1376          FALSE),                /* pcrel_offset */
1377
1378   /* A 16 bit dtprel reloc.  */
1379   HOWTO (R_PPC64_DTPREL16,
1380          0,                     /* rightshift */
1381          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1382          16,                    /* bitsize */
1383          FALSE,                 /* pc_relative */
1384          0,                     /* bitpos */
1385          complain_overflow_signed, /* complain_on_overflow */
1386          ppc64_elf_unhandled_reloc, /* special_function */
1387          "R_PPC64_DTPREL16",    /* name */
1388          FALSE,                 /* partial_inplace */
1389          0,                     /* src_mask */
1390          0xffff,                /* dst_mask */
1391          FALSE),                /* pcrel_offset */
1392
1393   /* Like DTPREL16, but no overflow.  */
1394   HOWTO (R_PPC64_DTPREL16_LO,
1395          0,                     /* rightshift */
1396          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1397          16,                    /* bitsize */
1398          FALSE,                 /* pc_relative */
1399          0,                     /* bitpos */
1400          complain_overflow_dont, /* complain_on_overflow */
1401          ppc64_elf_unhandled_reloc, /* special_function */
1402          "R_PPC64_DTPREL16_LO", /* name */
1403          FALSE,                 /* partial_inplace */
1404          0,                     /* src_mask */
1405          0xffff,                /* dst_mask */
1406          FALSE),                /* pcrel_offset */
1407
1408   /* Like DTPREL16_LO, but next higher group of 16 bits.  */
1409   HOWTO (R_PPC64_DTPREL16_HI,
1410          16,                    /* rightshift */
1411          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1412          16,                    /* bitsize */
1413          FALSE,                 /* pc_relative */
1414          0,                     /* bitpos */
1415          complain_overflow_signed, /* complain_on_overflow */
1416          ppc64_elf_unhandled_reloc, /* special_function */
1417          "R_PPC64_DTPREL16_HI", /* name */
1418          FALSE,                 /* partial_inplace */
1419          0,                     /* src_mask */
1420          0xffff,                /* dst_mask */
1421          FALSE),                /* pcrel_offset */
1422
1423   /* Like DTPREL16_HI, but adjust for low 16 bits.  */
1424   HOWTO (R_PPC64_DTPREL16_HA,
1425          16,                    /* rightshift */
1426          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1427          16,                    /* bitsize */
1428          FALSE,                 /* pc_relative */
1429          0,                     /* bitpos */
1430          complain_overflow_signed, /* complain_on_overflow */
1431          ppc64_elf_unhandled_reloc, /* special_function */
1432          "R_PPC64_DTPREL16_HA", /* name */
1433          FALSE,                 /* partial_inplace */
1434          0,                     /* src_mask */
1435          0xffff,                /* dst_mask */
1436          FALSE),                /* pcrel_offset */
1437
1438   /* Like DTPREL16_HI, but next higher group of 16 bits.  */
1439   HOWTO (R_PPC64_DTPREL16_HIGHER,
1440          32,                    /* rightshift */
1441          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1442          16,                    /* bitsize */
1443          FALSE,                 /* pc_relative */
1444          0,                     /* bitpos */
1445          complain_overflow_dont, /* complain_on_overflow */
1446          ppc64_elf_unhandled_reloc, /* special_function */
1447          "R_PPC64_DTPREL16_HIGHER", /* name */
1448          FALSE,                 /* partial_inplace */
1449          0,                     /* src_mask */
1450          0xffff,                /* dst_mask */
1451          FALSE),                /* pcrel_offset */
1452
1453   /* Like DTPREL16_HIGHER, but adjust for low 16 bits.  */
1454   HOWTO (R_PPC64_DTPREL16_HIGHERA,
1455          32,                    /* rightshift */
1456          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1457          16,                    /* bitsize */
1458          FALSE,                 /* pc_relative */
1459          0,                     /* bitpos */
1460          complain_overflow_dont, /* complain_on_overflow */
1461          ppc64_elf_unhandled_reloc, /* special_function */
1462          "R_PPC64_DTPREL16_HIGHERA", /* name */
1463          FALSE,                 /* partial_inplace */
1464          0,                     /* src_mask */
1465          0xffff,                /* dst_mask */
1466          FALSE),                /* pcrel_offset */
1467
1468   /* Like DTPREL16_HIGHER, but next higher group of 16 bits.  */
1469   HOWTO (R_PPC64_DTPREL16_HIGHEST,
1470          48,                    /* rightshift */
1471          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1472          16,                    /* bitsize */
1473          FALSE,                 /* pc_relative */
1474          0,                     /* bitpos */
1475          complain_overflow_dont, /* complain_on_overflow */
1476          ppc64_elf_unhandled_reloc, /* special_function */
1477          "R_PPC64_DTPREL16_HIGHEST", /* name */
1478          FALSE,                 /* partial_inplace */
1479          0,                     /* src_mask */
1480          0xffff,                /* dst_mask */
1481          FALSE),                /* pcrel_offset */
1482
1483   /* Like DTPREL16_HIGHEST, but adjust for low 16 bits.  */
1484   HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1485          48,                    /* rightshift */
1486          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1487          16,                    /* bitsize */
1488          FALSE,                 /* pc_relative */
1489          0,                     /* bitpos */
1490          complain_overflow_dont, /* complain_on_overflow */
1491          ppc64_elf_unhandled_reloc, /* special_function */
1492          "R_PPC64_DTPREL16_HIGHESTA", /* name */
1493          FALSE,                 /* partial_inplace */
1494          0,                     /* src_mask */
1495          0xffff,                /* dst_mask */
1496          FALSE),                /* pcrel_offset */
1497
1498   /* Like DTPREL16, but for insns with a DS field.  */
1499   HOWTO (R_PPC64_DTPREL16_DS,
1500          0,                     /* rightshift */
1501          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1502          16,                    /* bitsize */
1503          FALSE,                 /* pc_relative */
1504          0,                     /* bitpos */
1505          complain_overflow_signed, /* complain_on_overflow */
1506          ppc64_elf_unhandled_reloc, /* special_function */
1507          "R_PPC64_DTPREL16_DS", /* name */
1508          FALSE,                 /* partial_inplace */
1509          0,                     /* src_mask */
1510          0xfffc,                /* dst_mask */
1511          FALSE),                /* pcrel_offset */
1512
1513   /* Like DTPREL16_DS, but no overflow.  */
1514   HOWTO (R_PPC64_DTPREL16_LO_DS,
1515          0,                     /* rightshift */
1516          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1517          16,                    /* bitsize */
1518          FALSE,                 /* pc_relative */
1519          0,                     /* bitpos */
1520          complain_overflow_dont, /* complain_on_overflow */
1521          ppc64_elf_unhandled_reloc, /* special_function */
1522          "R_PPC64_DTPREL16_LO_DS", /* name */
1523          FALSE,                 /* partial_inplace */
1524          0,                     /* src_mask */
1525          0xfffc,                /* dst_mask */
1526          FALSE),                /* pcrel_offset */
1527
1528   /* Computes a tp-relative displacement, the difference between the value of
1529      sym+add and the value of the thread pointer (r13).  */
1530   HOWTO (R_PPC64_TPREL64,
1531          0,                     /* rightshift */
1532          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1533          64,                    /* bitsize */
1534          FALSE,                 /* pc_relative */
1535          0,                     /* bitpos */
1536          complain_overflow_dont, /* complain_on_overflow */
1537          ppc64_elf_unhandled_reloc, /* special_function */
1538          "R_PPC64_TPREL64",     /* name */
1539          FALSE,                 /* partial_inplace */
1540          0,                     /* src_mask */
1541          ONES (64),             /* dst_mask */
1542          FALSE),                /* pcrel_offset */
1543
1544   /* A 16 bit tprel reloc.  */
1545   HOWTO (R_PPC64_TPREL16,
1546          0,                     /* rightshift */
1547          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1548          16,                    /* bitsize */
1549          FALSE,                 /* pc_relative */
1550          0,                     /* bitpos */
1551          complain_overflow_signed, /* complain_on_overflow */
1552          ppc64_elf_unhandled_reloc, /* special_function */
1553          "R_PPC64_TPREL16",     /* name */
1554          FALSE,                 /* partial_inplace */
1555          0,                     /* src_mask */
1556          0xffff,                /* dst_mask */
1557          FALSE),                /* pcrel_offset */
1558
1559   /* Like TPREL16, but no overflow.  */
1560   HOWTO (R_PPC64_TPREL16_LO,
1561          0,                     /* rightshift */
1562          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1563          16,                    /* bitsize */
1564          FALSE,                 /* pc_relative */
1565          0,                     /* bitpos */
1566          complain_overflow_dont, /* complain_on_overflow */
1567          ppc64_elf_unhandled_reloc, /* special_function */
1568          "R_PPC64_TPREL16_LO",  /* name */
1569          FALSE,                 /* partial_inplace */
1570          0,                     /* src_mask */
1571          0xffff,                /* dst_mask */
1572          FALSE),                /* pcrel_offset */
1573
1574   /* Like TPREL16_LO, but next higher group of 16 bits.  */
1575   HOWTO (R_PPC64_TPREL16_HI,
1576          16,                    /* rightshift */
1577          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1578          16,                    /* bitsize */
1579          FALSE,                 /* pc_relative */
1580          0,                     /* bitpos */
1581          complain_overflow_signed, /* complain_on_overflow */
1582          ppc64_elf_unhandled_reloc, /* special_function */
1583          "R_PPC64_TPREL16_HI",  /* name */
1584          FALSE,                 /* partial_inplace */
1585          0,                     /* src_mask */
1586          0xffff,                /* dst_mask */
1587          FALSE),                /* pcrel_offset */
1588
1589   /* Like TPREL16_HI, but adjust for low 16 bits.  */
1590   HOWTO (R_PPC64_TPREL16_HA,
1591          16,                    /* rightshift */
1592          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1593          16,                    /* bitsize */
1594          FALSE,                 /* pc_relative */
1595          0,                     /* bitpos */
1596          complain_overflow_signed, /* complain_on_overflow */
1597          ppc64_elf_unhandled_reloc, /* special_function */
1598          "R_PPC64_TPREL16_HA",  /* name */
1599          FALSE,                 /* partial_inplace */
1600          0,                     /* src_mask */
1601          0xffff,                /* dst_mask */
1602          FALSE),                /* pcrel_offset */
1603
1604   /* Like TPREL16_HI, but next higher group of 16 bits.  */
1605   HOWTO (R_PPC64_TPREL16_HIGHER,
1606          32,                    /* rightshift */
1607          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1608          16,                    /* bitsize */
1609          FALSE,                 /* pc_relative */
1610          0,                     /* bitpos */
1611          complain_overflow_dont, /* complain_on_overflow */
1612          ppc64_elf_unhandled_reloc, /* special_function */
1613          "R_PPC64_TPREL16_HIGHER",      /* name */
1614          FALSE,                 /* partial_inplace */
1615          0,                     /* src_mask */
1616          0xffff,                /* dst_mask */
1617          FALSE),                /* pcrel_offset */
1618
1619   /* Like TPREL16_HIGHER, but adjust for low 16 bits.  */
1620   HOWTO (R_PPC64_TPREL16_HIGHERA,
1621          32,                    /* rightshift */
1622          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1623          16,                    /* bitsize */
1624          FALSE,                 /* pc_relative */
1625          0,                     /* bitpos */
1626          complain_overflow_dont, /* complain_on_overflow */
1627          ppc64_elf_unhandled_reloc, /* special_function */
1628          "R_PPC64_TPREL16_HIGHERA", /* name */
1629          FALSE,                 /* partial_inplace */
1630          0,                     /* src_mask */
1631          0xffff,                /* dst_mask */
1632          FALSE),                /* pcrel_offset */
1633
1634   /* Like TPREL16_HIGHER, but next higher group of 16 bits.  */
1635   HOWTO (R_PPC64_TPREL16_HIGHEST,
1636          48,                    /* rightshift */
1637          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1638          16,                    /* bitsize */
1639          FALSE,                 /* pc_relative */
1640          0,                     /* bitpos */
1641          complain_overflow_dont, /* complain_on_overflow */
1642          ppc64_elf_unhandled_reloc, /* special_function */
1643          "R_PPC64_TPREL16_HIGHEST", /* name */
1644          FALSE,                 /* partial_inplace */
1645          0,                     /* src_mask */
1646          0xffff,                /* dst_mask */
1647          FALSE),                /* pcrel_offset */
1648
1649   /* Like TPREL16_HIGHEST, but adjust for low 16 bits.  */
1650   HOWTO (R_PPC64_TPREL16_HIGHESTA,
1651          48,                    /* rightshift */
1652          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1653          16,                    /* bitsize */
1654          FALSE,                 /* pc_relative */
1655          0,                     /* bitpos */
1656          complain_overflow_dont, /* complain_on_overflow */
1657          ppc64_elf_unhandled_reloc, /* special_function */
1658          "R_PPC64_TPREL16_HIGHESTA", /* name */
1659          FALSE,                 /* partial_inplace */
1660          0,                     /* src_mask */
1661          0xffff,                /* dst_mask */
1662          FALSE),                /* pcrel_offset */
1663
1664   /* Like TPREL16, but for insns with a DS field.  */
1665   HOWTO (R_PPC64_TPREL16_DS,
1666          0,                     /* rightshift */
1667          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1668          16,                    /* bitsize */
1669          FALSE,                 /* pc_relative */
1670          0,                     /* bitpos */
1671          complain_overflow_signed, /* complain_on_overflow */
1672          ppc64_elf_unhandled_reloc, /* special_function */
1673          "R_PPC64_TPREL16_DS",  /* name */
1674          FALSE,                 /* partial_inplace */
1675          0,                     /* src_mask */
1676          0xfffc,                /* dst_mask */
1677          FALSE),                /* pcrel_offset */
1678
1679   /* Like TPREL16_DS, but no overflow.  */
1680   HOWTO (R_PPC64_TPREL16_LO_DS,
1681          0,                     /* rightshift */
1682          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1683          16,                    /* bitsize */
1684          FALSE,                 /* pc_relative */
1685          0,                     /* bitpos */
1686          complain_overflow_dont, /* complain_on_overflow */
1687          ppc64_elf_unhandled_reloc, /* special_function */
1688          "R_PPC64_TPREL16_LO_DS", /* name */
1689          FALSE,                 /* partial_inplace */
1690          0,                     /* src_mask */
1691          0xfffc,                /* dst_mask */
1692          FALSE),                /* pcrel_offset */
1693
1694   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1695      with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1696      to the first entry relative to the TOC base (r2).  */
1697   HOWTO (R_PPC64_GOT_TLSGD16,
1698          0,                     /* rightshift */
1699          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1700          16,                    /* bitsize */
1701          FALSE,                 /* pc_relative */
1702          0,                     /* bitpos */
1703          complain_overflow_signed, /* complain_on_overflow */
1704          ppc64_elf_unhandled_reloc, /* special_function */
1705          "R_PPC64_GOT_TLSGD16", /* name */
1706          FALSE,                 /* partial_inplace */
1707          0,                     /* src_mask */
1708          0xffff,                /* dst_mask */
1709          FALSE),                /* pcrel_offset */
1710
1711   /* Like GOT_TLSGD16, but no overflow.  */
1712   HOWTO (R_PPC64_GOT_TLSGD16_LO,
1713          0,                     /* rightshift */
1714          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1715          16,                    /* bitsize */
1716          FALSE,                 /* pc_relative */
1717          0,                     /* bitpos */
1718          complain_overflow_dont, /* complain_on_overflow */
1719          ppc64_elf_unhandled_reloc, /* special_function */
1720          "R_PPC64_GOT_TLSGD16_LO", /* name */
1721          FALSE,                 /* partial_inplace */
1722          0,                     /* src_mask */
1723          0xffff,                /* dst_mask */
1724          FALSE),                /* pcrel_offset */
1725
1726   /* Like GOT_TLSGD16_LO, but next higher group of 16 bits.  */
1727   HOWTO (R_PPC64_GOT_TLSGD16_HI,
1728          16,                    /* rightshift */
1729          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1730          16,                    /* bitsize */
1731          FALSE,                 /* pc_relative */
1732          0,                     /* bitpos */
1733          complain_overflow_signed, /* complain_on_overflow */
1734          ppc64_elf_unhandled_reloc, /* special_function */
1735          "R_PPC64_GOT_TLSGD16_HI", /* name */
1736          FALSE,                 /* partial_inplace */
1737          0,                     /* src_mask */
1738          0xffff,                /* dst_mask */
1739          FALSE),                /* pcrel_offset */
1740
1741   /* Like GOT_TLSGD16_HI, but adjust for low 16 bits.  */
1742   HOWTO (R_PPC64_GOT_TLSGD16_HA,
1743          16,                    /* rightshift */
1744          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1745          16,                    /* bitsize */
1746          FALSE,                 /* pc_relative */
1747          0,                     /* bitpos */
1748          complain_overflow_signed, /* complain_on_overflow */
1749          ppc64_elf_unhandled_reloc, /* special_function */
1750          "R_PPC64_GOT_TLSGD16_HA", /* name */
1751          FALSE,                 /* partial_inplace */
1752          0,                     /* src_mask */
1753          0xffff,                /* dst_mask */
1754          FALSE),                /* pcrel_offset */
1755
1756   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1757      with values (sym+add)@dtpmod and zero, and computes the offset to the
1758      first entry relative to the TOC base (r2).  */
1759   HOWTO (R_PPC64_GOT_TLSLD16,
1760          0,                     /* rightshift */
1761          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1762          16,                    /* bitsize */
1763          FALSE,                 /* pc_relative */
1764          0,                     /* bitpos */
1765          complain_overflow_signed, /* complain_on_overflow */
1766          ppc64_elf_unhandled_reloc, /* special_function */
1767          "R_PPC64_GOT_TLSLD16", /* name */
1768          FALSE,                 /* partial_inplace */
1769          0,                     /* src_mask */
1770          0xffff,                /* dst_mask */
1771          FALSE),                /* pcrel_offset */
1772
1773   /* Like GOT_TLSLD16, but no overflow.  */
1774   HOWTO (R_PPC64_GOT_TLSLD16_LO,
1775          0,                     /* rightshift */
1776          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1777          16,                    /* bitsize */
1778          FALSE,                 /* pc_relative */
1779          0,                     /* bitpos */
1780          complain_overflow_dont, /* complain_on_overflow */
1781          ppc64_elf_unhandled_reloc, /* special_function */
1782          "R_PPC64_GOT_TLSLD16_LO", /* name */
1783          FALSE,                 /* partial_inplace */
1784          0,                     /* src_mask */
1785          0xffff,                /* dst_mask */
1786          FALSE),                /* pcrel_offset */
1787
1788   /* Like GOT_TLSLD16_LO, but next higher group of 16 bits.  */
1789   HOWTO (R_PPC64_GOT_TLSLD16_HI,
1790          16,                    /* rightshift */
1791          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1792          16,                    /* bitsize */
1793          FALSE,                 /* pc_relative */
1794          0,                     /* bitpos */
1795          complain_overflow_signed, /* complain_on_overflow */
1796          ppc64_elf_unhandled_reloc, /* special_function */
1797          "R_PPC64_GOT_TLSLD16_HI", /* name */
1798          FALSE,                 /* partial_inplace */
1799          0,                     /* src_mask */
1800          0xffff,                /* dst_mask */
1801          FALSE),                /* pcrel_offset */
1802
1803   /* Like GOT_TLSLD16_HI, but adjust for low 16 bits.  */
1804   HOWTO (R_PPC64_GOT_TLSLD16_HA,
1805          16,                    /* rightshift */
1806          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1807          16,                    /* bitsize */
1808          FALSE,                 /* pc_relative */
1809          0,                     /* bitpos */
1810          complain_overflow_signed, /* complain_on_overflow */
1811          ppc64_elf_unhandled_reloc, /* special_function */
1812          "R_PPC64_GOT_TLSLD16_HA", /* name */
1813          FALSE,                 /* partial_inplace */
1814          0,                     /* src_mask */
1815          0xffff,                /* dst_mask */
1816          FALSE),                /* pcrel_offset */
1817
1818   /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1819      the offset to the entry relative to the TOC base (r2).  */
1820   HOWTO (R_PPC64_GOT_DTPREL16_DS,
1821          0,                     /* rightshift */
1822          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1823          16,                    /* bitsize */
1824          FALSE,                 /* pc_relative */
1825          0,                     /* bitpos */
1826          complain_overflow_signed, /* complain_on_overflow */
1827          ppc64_elf_unhandled_reloc, /* special_function */
1828          "R_PPC64_GOT_DTPREL16_DS", /* name */
1829          FALSE,                 /* partial_inplace */
1830          0,                     /* src_mask */
1831          0xfffc,                /* dst_mask */
1832          FALSE),                /* pcrel_offset */
1833
1834   /* Like GOT_DTPREL16_DS, but no overflow.  */
1835   HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1836          0,                     /* rightshift */
1837          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1838          16,                    /* bitsize */
1839          FALSE,                 /* pc_relative */
1840          0,                     /* bitpos */
1841          complain_overflow_dont, /* complain_on_overflow */
1842          ppc64_elf_unhandled_reloc, /* special_function */
1843          "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1844          FALSE,                 /* partial_inplace */
1845          0,                     /* src_mask */
1846          0xfffc,                /* dst_mask */
1847          FALSE),                /* pcrel_offset */
1848
1849   /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits.  */
1850   HOWTO (R_PPC64_GOT_DTPREL16_HI,
1851          16,                    /* rightshift */
1852          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1853          16,                    /* bitsize */
1854          FALSE,                 /* pc_relative */
1855          0,                     /* bitpos */
1856          complain_overflow_signed, /* complain_on_overflow */
1857          ppc64_elf_unhandled_reloc, /* special_function */
1858          "R_PPC64_GOT_DTPREL16_HI", /* name */
1859          FALSE,                 /* partial_inplace */
1860          0,                     /* src_mask */
1861          0xffff,                /* dst_mask */
1862          FALSE),                /* pcrel_offset */
1863
1864   /* Like GOT_DTPREL16_HI, but adjust for low 16 bits.  */
1865   HOWTO (R_PPC64_GOT_DTPREL16_HA,
1866          16,                    /* rightshift */
1867          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1868          16,                    /* bitsize */
1869          FALSE,                 /* pc_relative */
1870          0,                     /* bitpos */
1871          complain_overflow_signed, /* complain_on_overflow */
1872          ppc64_elf_unhandled_reloc, /* special_function */
1873          "R_PPC64_GOT_DTPREL16_HA", /* name */
1874          FALSE,                 /* partial_inplace */
1875          0,                     /* src_mask */
1876          0xffff,                /* dst_mask */
1877          FALSE),                /* pcrel_offset */
1878
1879   /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1880      offset to the entry relative to the TOC base (r2).  */
1881   HOWTO (R_PPC64_GOT_TPREL16_DS,
1882          0,                     /* rightshift */
1883          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1884          16,                    /* bitsize */
1885          FALSE,                 /* pc_relative */
1886          0,                     /* bitpos */
1887          complain_overflow_signed, /* complain_on_overflow */
1888          ppc64_elf_unhandled_reloc, /* special_function */
1889          "R_PPC64_GOT_TPREL16_DS", /* name */
1890          FALSE,                 /* partial_inplace */
1891          0,                     /* src_mask */
1892          0xfffc,                /* dst_mask */
1893          FALSE),                /* pcrel_offset */
1894
1895   /* Like GOT_TPREL16_DS, but no overflow.  */
1896   HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1897          0,                     /* rightshift */
1898          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1899          16,                    /* bitsize */
1900          FALSE,                 /* pc_relative */
1901          0,                     /* bitpos */
1902          complain_overflow_dont, /* complain_on_overflow */
1903          ppc64_elf_unhandled_reloc, /* special_function */
1904          "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1905          FALSE,                 /* partial_inplace */
1906          0,                     /* src_mask */
1907          0xfffc,                /* dst_mask */
1908          FALSE),                /* pcrel_offset */
1909
1910   /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits.  */
1911   HOWTO (R_PPC64_GOT_TPREL16_HI,
1912          16,                    /* rightshift */
1913          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1914          16,                    /* bitsize */
1915          FALSE,                 /* pc_relative */
1916          0,                     /* bitpos */
1917          complain_overflow_signed, /* complain_on_overflow */
1918          ppc64_elf_unhandled_reloc, /* special_function */
1919          "R_PPC64_GOT_TPREL16_HI", /* name */
1920          FALSE,                 /* partial_inplace */
1921          0,                     /* src_mask */
1922          0xffff,                /* dst_mask */
1923          FALSE),                /* pcrel_offset */
1924
1925   /* Like GOT_TPREL16_HI, but adjust for low 16 bits.  */
1926   HOWTO (R_PPC64_GOT_TPREL16_HA,
1927          16,                    /* rightshift */
1928          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1929          16,                    /* bitsize */
1930          FALSE,                 /* pc_relative */
1931          0,                     /* bitpos */
1932          complain_overflow_signed, /* complain_on_overflow */
1933          ppc64_elf_unhandled_reloc, /* special_function */
1934          "R_PPC64_GOT_TPREL16_HA", /* name */
1935          FALSE,                 /* partial_inplace */
1936          0,                     /* src_mask */
1937          0xffff,                /* dst_mask */
1938          FALSE),                /* pcrel_offset */
1939
1940   HOWTO (R_PPC64_JMP_IREL,      /* type */
1941          0,                     /* rightshift */
1942          0,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1943          0,                     /* bitsize */
1944          FALSE,                 /* pc_relative */
1945          0,                     /* bitpos */
1946          complain_overflow_dont, /* complain_on_overflow */
1947          ppc64_elf_unhandled_reloc, /* special_function */
1948          "R_PPC64_JMP_IREL",    /* name */
1949          FALSE,                 /* partial_inplace */
1950          0,                     /* src_mask */
1951          0,                     /* dst_mask */
1952          FALSE),                /* pcrel_offset */
1953
1954   HOWTO (R_PPC64_IRELATIVE,     /* type */
1955          0,                     /* rightshift */
1956          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1957          64,                    /* bitsize */
1958          FALSE,                 /* pc_relative */
1959          0,                     /* bitpos */
1960          complain_overflow_dont, /* complain_on_overflow */
1961          bfd_elf_generic_reloc, /* special_function */
1962          "R_PPC64_IRELATIVE",   /* name */
1963          FALSE,                 /* partial_inplace */
1964          0,                     /* src_mask */
1965          ONES (64),             /* dst_mask */
1966          FALSE),                /* pcrel_offset */
1967
1968   /* A 16 bit relative relocation.  */
1969   HOWTO (R_PPC64_REL16,         /* type */
1970          0,                     /* rightshift */
1971          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1972          16,                    /* bitsize */
1973          TRUE,                  /* pc_relative */
1974          0,                     /* bitpos */
1975          complain_overflow_signed, /* complain_on_overflow */
1976          bfd_elf_generic_reloc, /* special_function */
1977          "R_PPC64_REL16",       /* name */
1978          FALSE,                 /* partial_inplace */
1979          0,                     /* src_mask */
1980          0xffff,                /* dst_mask */
1981          TRUE),                 /* pcrel_offset */
1982
1983   /* A 16 bit relative relocation without overflow.  */
1984   HOWTO (R_PPC64_REL16_LO,      /* type */
1985          0,                     /* rightshift */
1986          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1987          16,                    /* bitsize */
1988          TRUE,                  /* pc_relative */
1989          0,                     /* bitpos */
1990          complain_overflow_dont,/* complain_on_overflow */
1991          bfd_elf_generic_reloc, /* special_function */
1992          "R_PPC64_REL16_LO",    /* name */
1993          FALSE,                 /* partial_inplace */
1994          0,                     /* src_mask */
1995          0xffff,                /* dst_mask */
1996          TRUE),                 /* pcrel_offset */
1997
1998   /* The high order 16 bits of a relative address.  */
1999   HOWTO (R_PPC64_REL16_HI,      /* type */
2000          16,                    /* rightshift */
2001          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2002          16,                    /* bitsize */
2003          TRUE,                  /* pc_relative */
2004          0,                     /* bitpos */
2005          complain_overflow_signed, /* complain_on_overflow */
2006          bfd_elf_generic_reloc, /* special_function */
2007          "R_PPC64_REL16_HI",    /* name */
2008          FALSE,                 /* partial_inplace */
2009          0,                     /* src_mask */
2010          0xffff,                /* dst_mask */
2011          TRUE),                 /* pcrel_offset */
2012
2013   /* The high order 16 bits of a relative address, plus 1 if the contents of
2014      the low 16 bits, treated as a signed number, is negative.  */
2015   HOWTO (R_PPC64_REL16_HA,      /* type */
2016          16,                    /* rightshift */
2017          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2018          16,                    /* bitsize */
2019          TRUE,                  /* pc_relative */
2020          0,                     /* bitpos */
2021          complain_overflow_signed, /* complain_on_overflow */
2022          ppc64_elf_ha_reloc,    /* special_function */
2023          "R_PPC64_REL16_HA",    /* name */
2024          FALSE,                 /* partial_inplace */
2025          0,                     /* src_mask */
2026          0xffff,                /* dst_mask */
2027          TRUE),                 /* pcrel_offset */
2028
2029   /* Like R_PPC64_REL16_HA but for split field in addpcis.  */
2030   HOWTO (R_PPC64_REL16DX_HA,    /* type */
2031          16,                    /* rightshift */
2032          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2033          16,                    /* bitsize */
2034          TRUE,                  /* pc_relative */
2035          0,                     /* bitpos */
2036          complain_overflow_signed, /* complain_on_overflow */
2037          ppc64_elf_ha_reloc,    /* special_function */
2038          "R_PPC64_REL16DX_HA",  /* name */
2039          FALSE,                 /* partial_inplace */
2040          0,                     /* src_mask */
2041          0x1fffc1,              /* dst_mask */
2042          TRUE),                 /* pcrel_offset */
2043
2044   /* Like R_PPC64_ADDR16_HI, but no overflow.  */
2045   HOWTO (R_PPC64_ADDR16_HIGH,   /* type */
2046          16,                    /* rightshift */
2047          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2048          16,                    /* bitsize */
2049          FALSE,                 /* pc_relative */
2050          0,                     /* bitpos */
2051          complain_overflow_dont, /* complain_on_overflow */
2052          bfd_elf_generic_reloc, /* special_function */
2053          "R_PPC64_ADDR16_HIGH", /* name */
2054          FALSE,                 /* partial_inplace */
2055          0,                     /* src_mask */
2056          0xffff,                /* dst_mask */
2057          FALSE),                /* pcrel_offset */
2058
2059   /* Like R_PPC64_ADDR16_HA, but no overflow.  */
2060   HOWTO (R_PPC64_ADDR16_HIGHA,  /* type */
2061          16,                    /* rightshift */
2062          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2063          16,                    /* bitsize */
2064          FALSE,                 /* pc_relative */
2065          0,                     /* bitpos */
2066          complain_overflow_dont, /* complain_on_overflow */
2067          ppc64_elf_ha_reloc,    /* special_function */
2068          "R_PPC64_ADDR16_HIGHA",        /* name */
2069          FALSE,                 /* partial_inplace */
2070          0,                     /* src_mask */
2071          0xffff,                /* dst_mask */
2072          FALSE),                /* pcrel_offset */
2073
2074   /* Like R_PPC64_DTPREL16_HI, but no overflow.  */
2075   HOWTO (R_PPC64_DTPREL16_HIGH,
2076          16,                    /* rightshift */
2077          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2078          16,                    /* bitsize */
2079          FALSE,                 /* pc_relative */
2080          0,                     /* bitpos */
2081          complain_overflow_dont, /* complain_on_overflow */
2082          ppc64_elf_unhandled_reloc, /* special_function */
2083          "R_PPC64_DTPREL16_HIGH", /* name */
2084          FALSE,                 /* partial_inplace */
2085          0,                     /* src_mask */
2086          0xffff,                /* dst_mask */
2087          FALSE),                /* pcrel_offset */
2088
2089   /* Like R_PPC64_DTPREL16_HA, but no overflow.  */
2090   HOWTO (R_PPC64_DTPREL16_HIGHA,
2091          16,                    /* rightshift */
2092          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2093          16,                    /* bitsize */
2094          FALSE,                 /* pc_relative */
2095          0,                     /* bitpos */
2096          complain_overflow_dont, /* complain_on_overflow */
2097          ppc64_elf_unhandled_reloc, /* special_function */
2098          "R_PPC64_DTPREL16_HIGHA", /* name */
2099          FALSE,                 /* partial_inplace */
2100          0,                     /* src_mask */
2101          0xffff,                /* dst_mask */
2102          FALSE),                /* pcrel_offset */
2103
2104   /* Like R_PPC64_TPREL16_HI, but no overflow.  */
2105   HOWTO (R_PPC64_TPREL16_HIGH,
2106          16,                    /* rightshift */
2107          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2108          16,                    /* bitsize */
2109          FALSE,                 /* pc_relative */
2110          0,                     /* bitpos */
2111          complain_overflow_dont, /* complain_on_overflow */
2112          ppc64_elf_unhandled_reloc, /* special_function */
2113          "R_PPC64_TPREL16_HIGH",        /* name */
2114          FALSE,                 /* partial_inplace */
2115          0,                     /* src_mask */
2116          0xffff,                /* dst_mask */
2117          FALSE),                /* pcrel_offset */
2118
2119   /* Like R_PPC64_TPREL16_HA, but no overflow.  */
2120   HOWTO (R_PPC64_TPREL16_HIGHA,
2121          16,                    /* rightshift */
2122          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2123          16,                    /* bitsize */
2124          FALSE,                 /* pc_relative */
2125          0,                     /* bitpos */
2126          complain_overflow_dont, /* complain_on_overflow */
2127          ppc64_elf_unhandled_reloc, /* special_function */
2128          "R_PPC64_TPREL16_HIGHA",       /* name */
2129          FALSE,                 /* partial_inplace */
2130          0,                     /* src_mask */
2131          0xffff,                /* dst_mask */
2132          FALSE),                /* pcrel_offset */
2133
2134   /* Marker reloc on ELFv2 large-model function entry.  */
2135   HOWTO (R_PPC64_ENTRY,
2136          0,                     /* rightshift */
2137          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2138          32,                    /* bitsize */
2139          FALSE,                 /* pc_relative */
2140          0,                     /* bitpos */
2141          complain_overflow_dont, /* complain_on_overflow */
2142          bfd_elf_generic_reloc, /* special_function */
2143          "R_PPC64_ENTRY",       /* name */
2144          FALSE,                 /* partial_inplace */
2145          0,                     /* src_mask */
2146          0,                     /* dst_mask */
2147          FALSE),                /* pcrel_offset */
2148
2149   /* Like ADDR64, but use local entry point of function.  */
2150   HOWTO (R_PPC64_ADDR64_LOCAL,  /* type */
2151          0,                     /* rightshift */
2152          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2153          64,                    /* bitsize */
2154          FALSE,                 /* pc_relative */
2155          0,                     /* bitpos */
2156          complain_overflow_dont, /* complain_on_overflow */
2157          bfd_elf_generic_reloc, /* special_function */
2158          "R_PPC64_ADDR64_LOCAL", /* name */
2159          FALSE,                 /* partial_inplace */
2160          0,                     /* src_mask */
2161          ONES (64),             /* dst_mask */
2162          FALSE),                /* pcrel_offset */
2163
2164   /* GNU extension to record C++ vtable hierarchy.  */
2165   HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2166          0,                     /* rightshift */
2167          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2168          0,                     /* bitsize */
2169          FALSE,                 /* pc_relative */
2170          0,                     /* bitpos */
2171          complain_overflow_dont, /* complain_on_overflow */
2172          NULL,                  /* special_function */
2173          "R_PPC64_GNU_VTINHERIT", /* name */
2174          FALSE,                 /* partial_inplace */
2175          0,                     /* src_mask */
2176          0,                     /* dst_mask */
2177          FALSE),                /* pcrel_offset */
2178
2179   /* GNU extension to record C++ vtable member usage.  */
2180   HOWTO (R_PPC64_GNU_VTENTRY,   /* type */
2181          0,                     /* rightshift */
2182          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2183          0,                     /* bitsize */
2184          FALSE,                 /* pc_relative */
2185          0,                     /* bitpos */
2186          complain_overflow_dont, /* complain_on_overflow */
2187          NULL,                  /* special_function */
2188          "R_PPC64_GNU_VTENTRY", /* name */
2189          FALSE,                 /* partial_inplace */
2190          0,                     /* src_mask */
2191          0,                     /* dst_mask */
2192          FALSE),                /* pcrel_offset */
2193 };
2194
2195 \f
2196 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2197    be done.  */
2198
2199 static void
2200 ppc_howto_init (void)
2201 {
2202   unsigned int i, type;
2203
2204   for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2205     {
2206       type = ppc64_elf_howto_raw[i].type;
2207       BFD_ASSERT (type < ARRAY_SIZE (ppc64_elf_howto_table));
2208       ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2209     }
2210 }
2211
2212 static reloc_howto_type *
2213 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2214                              bfd_reloc_code_real_type code)
2215 {
2216   enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2217
2218   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2219     /* Initialize howto table if needed.  */
2220     ppc_howto_init ();
2221
2222   switch (code)
2223     {
2224     default:
2225       return NULL;
2226
2227     case BFD_RELOC_NONE:                        r = R_PPC64_NONE;
2228       break;
2229     case BFD_RELOC_32:                          r = R_PPC64_ADDR32;
2230       break;
2231     case BFD_RELOC_PPC_BA26:                    r = R_PPC64_ADDR24;
2232       break;
2233     case BFD_RELOC_16:                          r = R_PPC64_ADDR16;
2234       break;
2235     case BFD_RELOC_LO16:                        r = R_PPC64_ADDR16_LO;
2236       break;
2237     case BFD_RELOC_HI16:                        r = R_PPC64_ADDR16_HI;
2238       break;
2239     case BFD_RELOC_PPC64_ADDR16_HIGH:           r = R_PPC64_ADDR16_HIGH;
2240       break;
2241     case BFD_RELOC_HI16_S:                      r = R_PPC64_ADDR16_HA;
2242       break;
2243     case BFD_RELOC_PPC64_ADDR16_HIGHA:          r = R_PPC64_ADDR16_HIGHA;
2244       break;
2245     case BFD_RELOC_PPC_BA16:                    r = R_PPC64_ADDR14;
2246       break;
2247     case BFD_RELOC_PPC_BA16_BRTAKEN:            r = R_PPC64_ADDR14_BRTAKEN;
2248       break;
2249     case BFD_RELOC_PPC_BA16_BRNTAKEN:           r = R_PPC64_ADDR14_BRNTAKEN;
2250       break;
2251     case BFD_RELOC_PPC_B26:                     r = R_PPC64_REL24;
2252       break;
2253     case BFD_RELOC_PPC_B16:                     r = R_PPC64_REL14;
2254       break;
2255     case BFD_RELOC_PPC_B16_BRTAKEN:             r = R_PPC64_REL14_BRTAKEN;
2256       break;
2257     case BFD_RELOC_PPC_B16_BRNTAKEN:            r = R_PPC64_REL14_BRNTAKEN;
2258       break;
2259     case BFD_RELOC_16_GOTOFF:                   r = R_PPC64_GOT16;
2260       break;
2261     case BFD_RELOC_LO16_GOTOFF:                 r = R_PPC64_GOT16_LO;
2262       break;
2263     case BFD_RELOC_HI16_GOTOFF:                 r = R_PPC64_GOT16_HI;
2264       break;
2265     case BFD_RELOC_HI16_S_GOTOFF:               r = R_PPC64_GOT16_HA;
2266       break;
2267     case BFD_RELOC_PPC_COPY:                    r = R_PPC64_COPY;
2268       break;
2269     case BFD_RELOC_PPC_GLOB_DAT:                r = R_PPC64_GLOB_DAT;
2270       break;
2271     case BFD_RELOC_32_PCREL:                    r = R_PPC64_REL32;
2272       break;
2273     case BFD_RELOC_32_PLTOFF:                   r = R_PPC64_PLT32;
2274       break;
2275     case BFD_RELOC_32_PLT_PCREL:                r = R_PPC64_PLTREL32;
2276       break;
2277     case BFD_RELOC_LO16_PLTOFF:                 r = R_PPC64_PLT16_LO;
2278       break;
2279     case BFD_RELOC_HI16_PLTOFF:                 r = R_PPC64_PLT16_HI;
2280       break;
2281     case BFD_RELOC_HI16_S_PLTOFF:               r = R_PPC64_PLT16_HA;
2282       break;
2283     case BFD_RELOC_16_BASEREL:                  r = R_PPC64_SECTOFF;
2284       break;
2285     case BFD_RELOC_LO16_BASEREL:                r = R_PPC64_SECTOFF_LO;
2286       break;
2287     case BFD_RELOC_HI16_BASEREL:                r = R_PPC64_SECTOFF_HI;
2288       break;
2289     case BFD_RELOC_HI16_S_BASEREL:              r = R_PPC64_SECTOFF_HA;
2290       break;
2291     case BFD_RELOC_CTOR:                        r = R_PPC64_ADDR64;
2292       break;
2293     case BFD_RELOC_64:                          r = R_PPC64_ADDR64;
2294       break;
2295     case BFD_RELOC_PPC64_HIGHER:                r = R_PPC64_ADDR16_HIGHER;
2296       break;
2297     case BFD_RELOC_PPC64_HIGHER_S:              r = R_PPC64_ADDR16_HIGHERA;
2298       break;
2299     case BFD_RELOC_PPC64_HIGHEST:               r = R_PPC64_ADDR16_HIGHEST;
2300       break;
2301     case BFD_RELOC_PPC64_HIGHEST_S:             r = R_PPC64_ADDR16_HIGHESTA;
2302       break;
2303     case BFD_RELOC_64_PCREL:                    r = R_PPC64_REL64;
2304       break;
2305     case BFD_RELOC_64_PLTOFF:                   r = R_PPC64_PLT64;
2306       break;
2307     case BFD_RELOC_64_PLT_PCREL:                r = R_PPC64_PLTREL64;
2308       break;
2309     case BFD_RELOC_PPC_TOC16:                   r = R_PPC64_TOC16;
2310       break;
2311     case BFD_RELOC_PPC64_TOC16_LO:              r = R_PPC64_TOC16_LO;
2312       break;
2313     case BFD_RELOC_PPC64_TOC16_HI:              r = R_PPC64_TOC16_HI;
2314       break;
2315     case BFD_RELOC_PPC64_TOC16_HA:              r = R_PPC64_TOC16_HA;
2316       break;
2317     case BFD_RELOC_PPC64_TOC:                   r = R_PPC64_TOC;
2318       break;
2319     case BFD_RELOC_PPC64_PLTGOT16:              r = R_PPC64_PLTGOT16;
2320       break;
2321     case BFD_RELOC_PPC64_PLTGOT16_LO:           r = R_PPC64_PLTGOT16_LO;
2322       break;
2323     case BFD_RELOC_PPC64_PLTGOT16_HI:           r = R_PPC64_PLTGOT16_HI;
2324       break;
2325     case BFD_RELOC_PPC64_PLTGOT16_HA:           r = R_PPC64_PLTGOT16_HA;
2326       break;
2327     case BFD_RELOC_PPC64_ADDR16_DS:             r = R_PPC64_ADDR16_DS;
2328       break;
2329     case BFD_RELOC_PPC64_ADDR16_LO_DS:          r = R_PPC64_ADDR16_LO_DS;
2330       break;
2331     case BFD_RELOC_PPC64_GOT16_DS:              r = R_PPC64_GOT16_DS;
2332       break;
2333     case BFD_RELOC_PPC64_GOT16_LO_DS:           r = R_PPC64_GOT16_LO_DS;
2334       break;
2335     case BFD_RELOC_PPC64_PLT16_LO_DS:           r = R_PPC64_PLT16_LO_DS;
2336       break;
2337     case BFD_RELOC_PPC64_SECTOFF_DS:            r = R_PPC64_SECTOFF_DS;
2338       break;
2339     case BFD_RELOC_PPC64_SECTOFF_LO_DS:         r = R_PPC64_SECTOFF_LO_DS;
2340       break;
2341     case BFD_RELOC_PPC64_TOC16_DS:              r = R_PPC64_TOC16_DS;
2342       break;
2343     case BFD_RELOC_PPC64_TOC16_LO_DS:           r = R_PPC64_TOC16_LO_DS;
2344       break;
2345     case BFD_RELOC_PPC64_PLTGOT16_DS:           r = R_PPC64_PLTGOT16_DS;
2346       break;
2347     case BFD_RELOC_PPC64_PLTGOT16_LO_DS:        r = R_PPC64_PLTGOT16_LO_DS;
2348       break;
2349     case BFD_RELOC_PPC_TLS:                     r = R_PPC64_TLS;
2350       break;
2351     case BFD_RELOC_PPC_TLSGD:                   r = R_PPC64_TLSGD;
2352       break;
2353     case BFD_RELOC_PPC_TLSLD:                   r = R_PPC64_TLSLD;
2354       break;
2355     case BFD_RELOC_PPC_DTPMOD:                  r = R_PPC64_DTPMOD64;
2356       break;
2357     case BFD_RELOC_PPC_TPREL16:                 r = R_PPC64_TPREL16;
2358       break;
2359     case BFD_RELOC_PPC_TPREL16_LO:              r = R_PPC64_TPREL16_LO;
2360       break;
2361     case BFD_RELOC_PPC_TPREL16_HI:              r = R_PPC64_TPREL16_HI;
2362       break;
2363     case BFD_RELOC_PPC64_TPREL16_HIGH:          r = R_PPC64_TPREL16_HIGH;
2364       break;
2365     case BFD_RELOC_PPC_TPREL16_HA:              r = R_PPC64_TPREL16_HA;
2366       break;
2367     case BFD_RELOC_PPC64_TPREL16_HIGHA:         r = R_PPC64_TPREL16_HIGHA;
2368       break;
2369     case BFD_RELOC_PPC_TPREL:                   r = R_PPC64_TPREL64;
2370       break;
2371     case BFD_RELOC_PPC_DTPREL16:                r = R_PPC64_DTPREL16;
2372       break;
2373     case BFD_RELOC_PPC_DTPREL16_LO:             r = R_PPC64_DTPREL16_LO;
2374       break;
2375     case BFD_RELOC_PPC_DTPREL16_HI:             r = R_PPC64_DTPREL16_HI;
2376       break;
2377     case BFD_RELOC_PPC64_DTPREL16_HIGH:         r = R_PPC64_DTPREL16_HIGH;
2378       break;
2379     case BFD_RELOC_PPC_DTPREL16_HA:             r = R_PPC64_DTPREL16_HA;
2380       break;
2381     case BFD_RELOC_PPC64_DTPREL16_HIGHA:        r = R_PPC64_DTPREL16_HIGHA;
2382       break;
2383     case BFD_RELOC_PPC_DTPREL:                  r = R_PPC64_DTPREL64;
2384       break;
2385     case BFD_RELOC_PPC_GOT_TLSGD16:             r = R_PPC64_GOT_TLSGD16;
2386       break;
2387     case BFD_RELOC_PPC_GOT_TLSGD16_LO:          r = R_PPC64_GOT_TLSGD16_LO;
2388       break;
2389     case BFD_RELOC_PPC_GOT_TLSGD16_HI:          r = R_PPC64_GOT_TLSGD16_HI;
2390       break;
2391     case BFD_RELOC_PPC_GOT_TLSGD16_HA:          r = R_PPC64_GOT_TLSGD16_HA;
2392       break;
2393     case BFD_RELOC_PPC_GOT_TLSLD16:             r = R_PPC64_GOT_TLSLD16;
2394       break;
2395     case BFD_RELOC_PPC_GOT_TLSLD16_LO:          r = R_PPC64_GOT_TLSLD16_LO;
2396       break;
2397     case BFD_RELOC_PPC_GOT_TLSLD16_HI:          r = R_PPC64_GOT_TLSLD16_HI;
2398       break;
2399     case BFD_RELOC_PPC_GOT_TLSLD16_HA:          r = R_PPC64_GOT_TLSLD16_HA;
2400       break;
2401     case BFD_RELOC_PPC_GOT_TPREL16:             r = R_PPC64_GOT_TPREL16_DS;
2402       break;
2403     case BFD_RELOC_PPC_GOT_TPREL16_LO:          r = R_PPC64_GOT_TPREL16_LO_DS;
2404       break;
2405     case BFD_RELOC_PPC_GOT_TPREL16_HI:          r = R_PPC64_GOT_TPREL16_HI;
2406       break;
2407     case BFD_RELOC_PPC_GOT_TPREL16_HA:          r = R_PPC64_GOT_TPREL16_HA;
2408       break;
2409     case BFD_RELOC_PPC_GOT_DTPREL16:            r = R_PPC64_GOT_DTPREL16_DS;
2410       break;
2411     case BFD_RELOC_PPC_GOT_DTPREL16_LO:         r = R_PPC64_GOT_DTPREL16_LO_DS;
2412       break;
2413     case BFD_RELOC_PPC_GOT_DTPREL16_HI:         r = R_PPC64_GOT_DTPREL16_HI;
2414       break;
2415     case BFD_RELOC_PPC_GOT_DTPREL16_HA:         r = R_PPC64_GOT_DTPREL16_HA;
2416       break;
2417     case BFD_RELOC_PPC64_TPREL16_DS:            r = R_PPC64_TPREL16_DS;
2418       break;
2419     case BFD_RELOC_PPC64_TPREL16_LO_DS:         r = R_PPC64_TPREL16_LO_DS;
2420       break;
2421     case BFD_RELOC_PPC64_TPREL16_HIGHER:        r = R_PPC64_TPREL16_HIGHER;
2422       break;
2423     case BFD_RELOC_PPC64_TPREL16_HIGHERA:       r = R_PPC64_TPREL16_HIGHERA;
2424       break;
2425     case BFD_RELOC_PPC64_TPREL16_HIGHEST:       r = R_PPC64_TPREL16_HIGHEST;
2426       break;
2427     case BFD_RELOC_PPC64_TPREL16_HIGHESTA:      r = R_PPC64_TPREL16_HIGHESTA;
2428       break;
2429     case BFD_RELOC_PPC64_DTPREL16_DS:           r = R_PPC64_DTPREL16_DS;
2430       break;
2431     case BFD_RELOC_PPC64_DTPREL16_LO_DS:        r = R_PPC64_DTPREL16_LO_DS;
2432       break;
2433     case BFD_RELOC_PPC64_DTPREL16_HIGHER:       r = R_PPC64_DTPREL16_HIGHER;
2434       break;
2435     case BFD_RELOC_PPC64_DTPREL16_HIGHERA:      r = R_PPC64_DTPREL16_HIGHERA;
2436       break;
2437     case BFD_RELOC_PPC64_DTPREL16_HIGHEST:      r = R_PPC64_DTPREL16_HIGHEST;
2438       break;
2439     case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:     r = R_PPC64_DTPREL16_HIGHESTA;
2440       break;
2441     case BFD_RELOC_16_PCREL:                    r = R_PPC64_REL16;
2442       break;
2443     case BFD_RELOC_LO16_PCREL:                  r = R_PPC64_REL16_LO;
2444       break;
2445     case BFD_RELOC_HI16_PCREL:                  r = R_PPC64_REL16_HI;
2446       break;
2447     case BFD_RELOC_HI16_S_PCREL:                r = R_PPC64_REL16_HA;
2448       break;
2449     case BFD_RELOC_PPC_REL16DX_HA:              r = R_PPC64_REL16DX_HA;
2450       break;
2451     case BFD_RELOC_PPC64_ENTRY:                 r = R_PPC64_ENTRY;
2452       break;
2453     case BFD_RELOC_PPC64_ADDR64_LOCAL:          r = R_PPC64_ADDR64_LOCAL;
2454       break;
2455     case BFD_RELOC_VTABLE_INHERIT:              r = R_PPC64_GNU_VTINHERIT;
2456       break;
2457     case BFD_RELOC_VTABLE_ENTRY:                r = R_PPC64_GNU_VTENTRY;
2458       break;
2459     }
2460
2461   return ppc64_elf_howto_table[r];
2462 };
2463
2464 static reloc_howto_type *
2465 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2466                              const char *r_name)
2467 {
2468   unsigned int i;
2469
2470   for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2471     if (ppc64_elf_howto_raw[i].name != NULL
2472         && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2473       return &ppc64_elf_howto_raw[i];
2474
2475   return NULL;
2476 }
2477
2478 /* Set the howto pointer for a PowerPC ELF reloc.  */
2479
2480 static void
2481 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2482                          Elf_Internal_Rela *dst)
2483 {
2484   unsigned int type;
2485
2486   /* Initialize howto table if needed.  */
2487   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2488     ppc_howto_init ();
2489
2490   type = ELF64_R_TYPE (dst->r_info);
2491   if (type >= ARRAY_SIZE (ppc64_elf_howto_table))
2492     {
2493       _bfd_error_handler (_("%B: invalid relocation type %d"),
2494                           abfd, (int) type);
2495       type = R_PPC64_NONE;
2496     }
2497   cache_ptr->howto = ppc64_elf_howto_table[type];
2498 }
2499
2500 /* Handle the R_PPC64_ADDR16_HA and similar relocs.  */
2501
2502 static bfd_reloc_status_type
2503 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2504                     void *data, asection *input_section,
2505                     bfd *output_bfd, char **error_message)
2506 {
2507   enum elf_ppc64_reloc_type r_type;
2508   long insn;
2509   bfd_size_type octets;
2510   bfd_vma value;
2511
2512   /* If this is a relocatable link (output_bfd test tells us), just
2513      call the generic function.  Any adjustment will be done at final
2514      link time.  */
2515   if (output_bfd != NULL)
2516     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2517                                   input_section, output_bfd, error_message);
2518
2519   /* Adjust the addend for sign extension of the low 16 bits.
2520      We won't actually be using the low 16 bits, so trashing them
2521      doesn't matter.  */
2522   reloc_entry->addend += 0x8000;
2523   r_type = reloc_entry->howto->type;
2524   if (r_type != R_PPC64_REL16DX_HA)
2525     return bfd_reloc_continue;
2526
2527   value = 0;
2528   if (!bfd_is_com_section (symbol->section))
2529     value = symbol->value;
2530   value += (reloc_entry->addend
2531             + symbol->section->output_offset
2532             + symbol->section->output_section->vma);
2533   value -= (reloc_entry->address
2534             + input_section->output_offset
2535             + input_section->output_section->vma);
2536   value = (bfd_signed_vma) value >> 16;
2537
2538   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2539   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2540   insn &= ~0x1fffc1;
2541   insn |= (value & 0xffc1) | ((value & 0x3e) << 15);
2542   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2543   if (value + 0x8000 > 0xffff)
2544     return bfd_reloc_overflow;
2545   return bfd_reloc_ok;
2546 }
2547
2548 static bfd_reloc_status_type
2549 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2550                         void *data, asection *input_section,
2551                         bfd *output_bfd, char **error_message)
2552 {
2553   if (output_bfd != NULL)
2554     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2555                                   input_section, output_bfd, error_message);
2556
2557   if (strcmp (symbol->section->name, ".opd") == 0
2558       && (symbol->section->owner->flags & DYNAMIC) == 0)
2559     {
2560       bfd_vma dest = opd_entry_value (symbol->section,
2561                                       symbol->value + reloc_entry->addend,
2562                                       NULL, NULL, FALSE);
2563       if (dest != (bfd_vma) -1)
2564         reloc_entry->addend = dest - (symbol->value
2565                                       + symbol->section->output_section->vma
2566                                       + symbol->section->output_offset);
2567     }
2568   else
2569     {
2570       elf_symbol_type *elfsym = (elf_symbol_type *) symbol;
2571
2572       if (symbol->section->owner != abfd
2573           && symbol->section->owner != NULL
2574           && abiversion (symbol->section->owner) >= 2)
2575         {
2576           unsigned int i;
2577
2578           for (i = 0; i < symbol->section->owner->symcount; ++i)
2579             {
2580               asymbol *symdef = symbol->section->owner->outsymbols[i];
2581
2582               if (strcmp (symdef->name, symbol->name) == 0)
2583                 {
2584                   elfsym = (elf_symbol_type *) symdef;
2585                   break;
2586                 }
2587             }
2588         }
2589       reloc_entry->addend
2590         += PPC64_LOCAL_ENTRY_OFFSET (elfsym->internal_elf_sym.st_other);
2591     }
2592   return bfd_reloc_continue;
2593 }
2594
2595 static bfd_reloc_status_type
2596 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2597                          void *data, asection *input_section,
2598                          bfd *output_bfd, char **error_message)
2599 {
2600   long insn;
2601   enum elf_ppc64_reloc_type r_type;
2602   bfd_size_type octets;
2603   /* Assume 'at' branch hints.  */
2604   bfd_boolean is_isa_v2 = TRUE;
2605
2606   /* If this is a relocatable link (output_bfd test tells us), just
2607      call the generic function.  Any adjustment will be done at final
2608      link time.  */
2609   if (output_bfd != NULL)
2610     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2611                                   input_section, output_bfd, error_message);
2612
2613   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2614   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2615   insn &= ~(0x01 << 21);
2616   r_type = reloc_entry->howto->type;
2617   if (r_type == R_PPC64_ADDR14_BRTAKEN
2618       || r_type == R_PPC64_REL14_BRTAKEN)
2619     insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
2620
2621   if (is_isa_v2)
2622     {
2623       /* Set 'a' bit.  This is 0b00010 in BO field for branch
2624          on CR(BI) insns (BO == 001at or 011at), and 0b01000
2625          for branch on CTR insns (BO == 1a00t or 1a01t).  */
2626       if ((insn & (0x14 << 21)) == (0x04 << 21))
2627         insn |= 0x02 << 21;
2628       else if ((insn & (0x14 << 21)) == (0x10 << 21))
2629         insn |= 0x08 << 21;
2630       else
2631         goto out;
2632     }
2633   else
2634     {
2635       bfd_vma target = 0;
2636       bfd_vma from;
2637
2638       if (!bfd_is_com_section (symbol->section))
2639         target = symbol->value;
2640       target += symbol->section->output_section->vma;
2641       target += symbol->section->output_offset;
2642       target += reloc_entry->addend;
2643
2644       from = (reloc_entry->address
2645               + input_section->output_offset
2646               + input_section->output_section->vma);
2647
2648       /* Invert 'y' bit if not the default.  */
2649       if ((bfd_signed_vma) (target - from) < 0)
2650         insn ^= 0x01 << 21;
2651     }
2652   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2653  out:
2654   return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2655                                  input_section, output_bfd, error_message);
2656 }
2657
2658 static bfd_reloc_status_type
2659 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2660                          void *data, asection *input_section,
2661                          bfd *output_bfd, char **error_message)
2662 {
2663   /* If this is a relocatable link (output_bfd test tells us), just
2664      call the generic function.  Any adjustment will be done at final
2665      link time.  */
2666   if (output_bfd != NULL)
2667     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2668                                   input_section, output_bfd, error_message);
2669
2670   /* Subtract the symbol section base address.  */
2671   reloc_entry->addend -= symbol->section->output_section->vma;
2672   return bfd_reloc_continue;
2673 }
2674
2675 static bfd_reloc_status_type
2676 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2677                             void *data, asection *input_section,
2678                             bfd *output_bfd, char **error_message)
2679 {
2680   /* If this is a relocatable link (output_bfd test tells us), just
2681      call the generic function.  Any adjustment will be done at final
2682      link time.  */
2683   if (output_bfd != NULL)
2684     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2685                                   input_section, output_bfd, error_message);
2686
2687   /* Subtract the symbol section base address.  */
2688   reloc_entry->addend -= symbol->section->output_section->vma;
2689
2690   /* Adjust the addend for sign extension of the low 16 bits.  */
2691   reloc_entry->addend += 0x8000;
2692   return bfd_reloc_continue;
2693 }
2694
2695 static bfd_reloc_status_type
2696 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2697                      void *data, asection *input_section,
2698                      bfd *output_bfd, char **error_message)
2699 {
2700   bfd_vma TOCstart;
2701
2702   /* If this is a relocatable link (output_bfd test tells us), just
2703      call the generic function.  Any adjustment will be done at final
2704      link time.  */
2705   if (output_bfd != NULL)
2706     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2707                                   input_section, output_bfd, error_message);
2708
2709   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2710   if (TOCstart == 0)
2711     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2712
2713   /* Subtract the TOC base address.  */
2714   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2715   return bfd_reloc_continue;
2716 }
2717
2718 static bfd_reloc_status_type
2719 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2720                         void *data, asection *input_section,
2721                         bfd *output_bfd, char **error_message)
2722 {
2723   bfd_vma TOCstart;
2724
2725   /* If this is a relocatable link (output_bfd test tells us), just
2726      call the generic function.  Any adjustment will be done at final
2727      link time.  */
2728   if (output_bfd != NULL)
2729     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2730                                   input_section, output_bfd, error_message);
2731
2732   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2733   if (TOCstart == 0)
2734     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2735
2736   /* Subtract the TOC base address.  */
2737   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2738
2739   /* Adjust the addend for sign extension of the low 16 bits.  */
2740   reloc_entry->addend += 0x8000;
2741   return bfd_reloc_continue;
2742 }
2743
2744 static bfd_reloc_status_type
2745 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2746                        void *data, asection *input_section,
2747                        bfd *output_bfd, char **error_message)
2748 {
2749   bfd_vma TOCstart;
2750   bfd_size_type octets;
2751
2752   /* If this is a relocatable link (output_bfd test tells us), just
2753      call the generic function.  Any adjustment will be done at final
2754      link time.  */
2755   if (output_bfd != NULL)
2756     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2757                                   input_section, output_bfd, error_message);
2758
2759   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2760   if (TOCstart == 0)
2761     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2762
2763   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2764   bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2765   return bfd_reloc_ok;
2766 }
2767
2768 static bfd_reloc_status_type
2769 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2770                            void *data, asection *input_section,
2771                            bfd *output_bfd, char **error_message)
2772 {
2773   /* If this is a relocatable link (output_bfd test tells us), just
2774      call the generic function.  Any adjustment will be done at final
2775      link time.  */
2776   if (output_bfd != NULL)
2777     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2778                                   input_section, output_bfd, error_message);
2779
2780   if (error_message != NULL)
2781     {
2782       static char buf[60];
2783       sprintf (buf, "generic linker can't handle %s",
2784                reloc_entry->howto->name);
2785       *error_message = buf;
2786     }
2787   return bfd_reloc_dangerous;
2788 }
2789
2790 /* Track GOT entries needed for a given symbol.  We might need more
2791    than one got entry per symbol.  */
2792 struct got_entry
2793 {
2794   struct got_entry *next;
2795
2796   /* The symbol addend that we'll be placing in the GOT.  */
2797   bfd_vma addend;
2798
2799   /* Unlike other ELF targets, we use separate GOT entries for the same
2800      symbol referenced from different input files.  This is to support
2801      automatic multiple TOC/GOT sections, where the TOC base can vary
2802      from one input file to another.  After partitioning into TOC groups
2803      we merge entries within the group.
2804
2805      Point to the BFD owning this GOT entry.  */
2806   bfd *owner;
2807
2808   /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2809      TLS_TPREL or TLS_DTPREL for tls entries.  */
2810   unsigned char tls_type;
2811
2812   /* Non-zero if got.ent points to real entry.  */
2813   unsigned char is_indirect;
2814
2815   /* Reference count until size_dynamic_sections, GOT offset thereafter.  */
2816   union
2817     {
2818       bfd_signed_vma refcount;
2819       bfd_vma offset;
2820       struct got_entry *ent;
2821     } got;
2822 };
2823
2824 /* The same for PLT.  */
2825 struct plt_entry
2826 {
2827   struct plt_entry *next;
2828
2829   bfd_vma addend;
2830
2831   union
2832     {
2833       bfd_signed_vma refcount;
2834       bfd_vma offset;
2835     } plt;
2836 };
2837
2838 struct ppc64_elf_obj_tdata
2839 {
2840   struct elf_obj_tdata elf;
2841
2842   /* Shortcuts to dynamic linker sections.  */
2843   asection *got;
2844   asection *relgot;
2845
2846   /* Used during garbage collection.  We attach global symbols defined
2847      on removed .opd entries to this section so that the sym is removed.  */
2848   asection *deleted_section;
2849
2850   /* TLS local dynamic got entry handling.  Support for multiple GOT
2851      sections means we potentially need one of these for each input bfd.  */
2852   struct got_entry tlsld_got;
2853
2854   union {
2855     /* A copy of relocs before they are modified for --emit-relocs.  */
2856     Elf_Internal_Rela *relocs;
2857
2858     /* Section contents.  */
2859     bfd_byte *contents;
2860   } opd;
2861
2862   /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2863      the reloc to be in the range -32768 to 32767.  */
2864   unsigned int has_small_toc_reloc : 1;
2865
2866   /* Set if toc/got ha relocs detected not using r2, or lo reloc
2867      instruction not one we handle.  */
2868   unsigned int unexpected_toc_insn : 1;
2869 };
2870
2871 #define ppc64_elf_tdata(bfd) \
2872   ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2873
2874 #define ppc64_tlsld_got(bfd) \
2875   (&ppc64_elf_tdata (bfd)->tlsld_got)
2876
2877 #define is_ppc64_elf(bfd) \
2878   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2879    && elf_object_id (bfd) == PPC64_ELF_DATA)
2880
2881 /* Override the generic function because we store some extras.  */
2882
2883 static bfd_boolean
2884 ppc64_elf_mkobject (bfd *abfd)
2885 {
2886   return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2887                                   PPC64_ELF_DATA);
2888 }
2889
2890 /* Fix bad default arch selected for a 64 bit input bfd when the
2891    default is 32 bit.  Also select arch based on apuinfo.  */
2892
2893 static bfd_boolean
2894 ppc64_elf_object_p (bfd *abfd)
2895 {
2896   if (!abfd->arch_info->the_default)
2897     return TRUE;
2898
2899   if (abfd->arch_info->bits_per_word == 32)
2900     {
2901       Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2902
2903       if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2904         {
2905           /* Relies on arch after 32 bit default being 64 bit default.  */
2906           abfd->arch_info = abfd->arch_info->next;
2907           BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2908         }
2909     }
2910   return _bfd_elf_ppc_set_arch (abfd);
2911 }
2912
2913 /* Support for core dump NOTE sections.  */
2914
2915 static bfd_boolean
2916 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2917 {
2918   size_t offset, size;
2919
2920   if (note->descsz != 504)
2921     return FALSE;
2922
2923   /* pr_cursig */
2924   elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2925
2926   /* pr_pid */
2927   elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2928
2929   /* pr_reg */
2930   offset = 112;
2931   size = 384;
2932
2933   /* Make a ".reg/999" section.  */
2934   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2935                                           size, note->descpos + offset);
2936 }
2937
2938 static bfd_boolean
2939 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2940 {
2941   if (note->descsz != 136)
2942     return FALSE;
2943
2944   elf_tdata (abfd)->core->pid
2945     = bfd_get_32 (abfd, note->descdata + 24);
2946   elf_tdata (abfd)->core->program
2947     = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2948   elf_tdata (abfd)->core->command
2949     = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2950
2951   return TRUE;
2952 }
2953
2954 static char *
2955 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2956                            ...)
2957 {
2958   switch (note_type)
2959     {
2960     default:
2961       return NULL;
2962
2963     case NT_PRPSINFO:
2964       {
2965         char data[136];
2966         va_list ap;
2967
2968         va_start (ap, note_type);
2969         memset (data, 0, sizeof (data));
2970         strncpy (data + 40, va_arg (ap, const char *), 16);
2971         strncpy (data + 56, va_arg (ap, const char *), 80);
2972         va_end (ap);
2973         return elfcore_write_note (abfd, buf, bufsiz,
2974                                    "CORE", note_type, data, sizeof (data));
2975       }
2976
2977     case NT_PRSTATUS:
2978       {
2979         char data[504];
2980         va_list ap;
2981         long pid;
2982         int cursig;
2983         const void *greg;
2984
2985         va_start (ap, note_type);
2986         memset (data, 0, 112);
2987         pid = va_arg (ap, long);
2988         bfd_put_32 (abfd, pid, data + 32);
2989         cursig = va_arg (ap, int);
2990         bfd_put_16 (abfd, cursig, data + 12);
2991         greg = va_arg (ap, const void *);
2992         memcpy (data + 112, greg, 384);
2993         memset (data + 496, 0, 8);
2994         va_end (ap);
2995         return elfcore_write_note (abfd, buf, bufsiz,
2996                                    "CORE", note_type, data, sizeof (data));
2997       }
2998     }
2999 }
3000
3001 /* Add extra PPC sections.  */
3002
3003 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
3004 {
3005   { STRING_COMMA_LEN (".plt"),    0, SHT_NOBITS,   0 },
3006   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
3007   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3008   { STRING_COMMA_LEN (".toc"),    0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3009   { STRING_COMMA_LEN (".toc1"),   0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3010   { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
3011   { NULL,                     0,  0, 0,            0 }
3012 };
3013
3014 enum _ppc64_sec_type {
3015   sec_normal = 0,
3016   sec_opd = 1,
3017   sec_toc = 2
3018 };
3019
3020 struct _ppc64_elf_section_data
3021 {
3022   struct bfd_elf_section_data elf;
3023
3024   union
3025   {
3026     /* An array with one entry for each opd function descriptor,
3027        and some spares since opd entries may be either 16 or 24 bytes.  */
3028 #define OPD_NDX(OFF) ((OFF) >> 4)
3029     struct _opd_sec_data
3030     {
3031       /* Points to the function code section for local opd entries.  */
3032       asection **func_sec;
3033
3034       /* After editing .opd, adjust references to opd local syms.  */
3035       long *adjust;
3036     } opd;
3037
3038     /* An array for toc sections, indexed by offset/8.  */
3039     struct _toc_sec_data
3040     {
3041       /* Specifies the relocation symbol index used at a given toc offset.  */
3042       unsigned *symndx;
3043
3044       /* And the relocation addend.  */
3045       bfd_vma *add;
3046     } toc;
3047   } u;
3048
3049   enum _ppc64_sec_type sec_type:2;
3050
3051   /* Flag set when small branches are detected.  Used to
3052      select suitable defaults for the stub group size.  */
3053   unsigned int has_14bit_branch:1;
3054 };
3055
3056 #define ppc64_elf_section_data(sec) \
3057   ((struct _ppc64_elf_section_data *) elf_section_data (sec))
3058
3059 static bfd_boolean
3060 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
3061 {
3062   if (!sec->used_by_bfd)
3063     {
3064       struct _ppc64_elf_section_data *sdata;
3065       bfd_size_type amt = sizeof (*sdata);
3066
3067       sdata = bfd_zalloc (abfd, amt);
3068       if (sdata == NULL)
3069         return FALSE;
3070       sec->used_by_bfd = sdata;
3071     }
3072
3073   return _bfd_elf_new_section_hook (abfd, sec);
3074 }
3075
3076 static struct _opd_sec_data *
3077 get_opd_info (asection * sec)
3078 {
3079   if (sec != NULL
3080       && ppc64_elf_section_data (sec) != NULL
3081       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
3082     return &ppc64_elf_section_data (sec)->u.opd;
3083   return NULL;
3084 }
3085 \f
3086 /* Parameters for the qsort hook.  */
3087 static bfd_boolean synthetic_relocatable;
3088 static asection *synthetic_opd;
3089
3090 /* qsort comparison function for ppc64_elf_get_synthetic_symtab.  */
3091
3092 static int
3093 compare_symbols (const void *ap, const void *bp)
3094 {
3095   const asymbol *a = * (const asymbol **) ap;
3096   const asymbol *b = * (const asymbol **) bp;
3097
3098   /* Section symbols first.  */
3099   if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
3100     return -1;
3101   if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
3102     return 1;
3103
3104   /* then .opd symbols.  */
3105   if (synthetic_opd != NULL)
3106     {
3107       if (strcmp (a->section->name, ".opd") == 0
3108           && strcmp (b->section->name, ".opd") != 0)
3109         return -1;
3110       if (strcmp (a->section->name, ".opd") != 0
3111           && strcmp (b->section->name, ".opd") == 0)
3112         return 1;
3113     }
3114
3115   /* then other code symbols.  */
3116   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3117       == (SEC_CODE | SEC_ALLOC)
3118       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3119          != (SEC_CODE | SEC_ALLOC))
3120     return -1;
3121
3122   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3123       != (SEC_CODE | SEC_ALLOC)
3124       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3125          == (SEC_CODE | SEC_ALLOC))
3126     return 1;
3127
3128   if (synthetic_relocatable)
3129     {
3130       if (a->section->id < b->section->id)
3131         return -1;
3132
3133       if (a->section->id > b->section->id)
3134         return 1;
3135     }
3136
3137   if (a->value + a->section->vma < b->value + b->section->vma)
3138     return -1;
3139
3140   if (a->value + a->section->vma > b->value + b->section->vma)
3141     return 1;
3142
3143   /* For syms with the same value, prefer strong dynamic global function
3144      syms over other syms.  */
3145   if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3146     return -1;
3147
3148   if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3149     return 1;
3150
3151   if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3152     return -1;
3153
3154   if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3155     return 1;
3156
3157   if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3158     return -1;
3159
3160   if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3161     return 1;
3162
3163   if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3164     return -1;
3165
3166   if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3167     return 1;
3168
3169   return 0;
3170 }
3171
3172 /* Search SYMS for a symbol of the given VALUE.  */
3173
3174 static asymbol *
3175 sym_exists_at (asymbol **syms, long lo, long hi, unsigned int id, bfd_vma value)
3176 {
3177   long mid;
3178
3179   if (id == (unsigned) -1)
3180     {
3181       while (lo < hi)
3182         {
3183           mid = (lo + hi) >> 1;
3184           if (syms[mid]->value + syms[mid]->section->vma < value)
3185             lo = mid + 1;
3186           else if (syms[mid]->value + syms[mid]->section->vma > value)
3187             hi = mid;
3188           else
3189             return syms[mid];
3190         }
3191     }
3192   else
3193     {
3194       while (lo < hi)
3195         {
3196           mid = (lo + hi) >> 1;
3197           if (syms[mid]->section->id < id)
3198             lo = mid + 1;
3199           else if (syms[mid]->section->id > id)
3200             hi = mid;
3201           else if (syms[mid]->value < value)
3202             lo = mid + 1;
3203           else if (syms[mid]->value > value)
3204             hi = mid;
3205           else
3206             return syms[mid];
3207         }
3208     }
3209   return NULL;
3210 }
3211
3212 static bfd_boolean
3213 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3214 {
3215   bfd_vma vma = *(bfd_vma *) ptr;
3216   return ((section->flags & SEC_ALLOC) != 0
3217           && section->vma <= vma
3218           && vma < section->vma + section->size);
3219 }
3220
3221 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3222    entry syms.  Also generate @plt symbols for the glink branch table.
3223    Returns count of synthetic symbols in RET or -1 on error.  */
3224
3225 static long
3226 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3227                                 long static_count, asymbol **static_syms,
3228                                 long dyn_count, asymbol **dyn_syms,
3229                                 asymbol **ret)
3230 {
3231   asymbol *s;
3232   long i;
3233   long count;
3234   char *names;
3235   long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3236   asection *opd = NULL;
3237   bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3238   asymbol **syms;
3239   int abi = abiversion (abfd);
3240
3241   *ret = NULL;
3242
3243   if (abi < 2)
3244     {
3245       opd = bfd_get_section_by_name (abfd, ".opd");
3246       if (opd == NULL && abi == 1)
3247         return 0;
3248     }
3249
3250   symcount = static_count;
3251   if (!relocatable)
3252     symcount += dyn_count;
3253   if (symcount == 0)
3254     return 0;
3255
3256   syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3257   if (syms == NULL)
3258     return -1;
3259
3260   if (!relocatable && static_count != 0 && dyn_count != 0)
3261     {
3262       /* Use both symbol tables.  */
3263       memcpy (syms, static_syms, static_count * sizeof (*syms));
3264       memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3265     }
3266   else if (!relocatable && static_count == 0)
3267     memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3268   else
3269     memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3270
3271   synthetic_relocatable = relocatable;
3272   synthetic_opd = opd;
3273   qsort (syms, symcount, sizeof (*syms), compare_symbols);
3274
3275   if (!relocatable && symcount > 1)
3276     {
3277       long j;
3278       /* Trim duplicate syms, since we may have merged the normal and
3279          dynamic symbols.  Actually, we only care about syms that have
3280          different values, so trim any with the same value.  */
3281       for (i = 1, j = 1; i < symcount; ++i)
3282         if (syms[i - 1]->value + syms[i - 1]->section->vma
3283             != syms[i]->value + syms[i]->section->vma)
3284           syms[j++] = syms[i];
3285       symcount = j;
3286     }
3287
3288   i = 0;
3289   /* Note that here and in compare_symbols we can't compare opd and
3290      sym->section directly.  With separate debug info files, the
3291      symbols will be extracted from the debug file while abfd passed
3292      to this function is the real binary.  */
3293   if (opd != NULL && strcmp (syms[i]->section->name, ".opd") == 0)
3294     ++i;
3295   codesecsym = i;
3296
3297   for (; i < symcount; ++i)
3298     if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3299          != (SEC_CODE | SEC_ALLOC))
3300         || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3301       break;
3302   codesecsymend = i;
3303
3304   for (; i < symcount; ++i)
3305     if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3306       break;
3307   secsymend = i;
3308
3309   if (opd != NULL)
3310     for (; i < symcount; ++i)
3311       if (strcmp (syms[i]->section->name, ".opd") != 0)
3312         break;
3313   opdsymend = i;
3314
3315   for (; i < symcount; ++i)
3316     if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3317         != (SEC_CODE | SEC_ALLOC))
3318       break;
3319   symcount = i;
3320
3321   count = 0;
3322
3323   if (relocatable)
3324     {
3325       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3326       arelent *r;
3327       size_t size;
3328       long relcount;
3329
3330       if (opdsymend == secsymend)
3331         goto done;
3332
3333       slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3334       relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3335       if (relcount == 0)
3336         goto done;
3337
3338       if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3339         {
3340           count = -1;
3341           goto done;
3342         }
3343
3344       size = 0;
3345       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3346         {
3347           asymbol *sym;
3348
3349           while (r < opd->relocation + relcount
3350                  && r->address < syms[i]->value + opd->vma)
3351             ++r;
3352
3353           if (r == opd->relocation + relcount)
3354             break;
3355
3356           if (r->address != syms[i]->value + opd->vma)
3357             continue;
3358
3359           if (r->howto->type != R_PPC64_ADDR64)
3360             continue;
3361
3362           sym = *r->sym_ptr_ptr;
3363           if (!sym_exists_at (syms, opdsymend, symcount,
3364                               sym->section->id, sym->value + r->addend))
3365             {
3366               ++count;
3367               size += sizeof (asymbol);
3368               size += strlen (syms[i]->name) + 2;
3369             }
3370         }
3371
3372       if (size == 0)
3373         goto done;
3374       s = *ret = bfd_malloc (size);
3375       if (s == NULL)
3376         {
3377           count = -1;
3378           goto done;
3379         }
3380
3381       names = (char *) (s + count);
3382
3383       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3384         {
3385           asymbol *sym;
3386
3387           while (r < opd->relocation + relcount
3388                  && r->address < syms[i]->value + opd->vma)
3389             ++r;
3390
3391           if (r == opd->relocation + relcount)
3392             break;
3393
3394           if (r->address != syms[i]->value + opd->vma)
3395             continue;
3396
3397           if (r->howto->type != R_PPC64_ADDR64)
3398             continue;
3399
3400           sym = *r->sym_ptr_ptr;
3401           if (!sym_exists_at (syms, opdsymend, symcount,
3402                               sym->section->id, sym->value + r->addend))
3403             {
3404               size_t len;
3405
3406               *s = *syms[i];
3407               s->flags |= BSF_SYNTHETIC;
3408               s->section = sym->section;
3409               s->value = sym->value + r->addend;
3410               s->name = names;
3411               *names++ = '.';
3412               len = strlen (syms[i]->name);
3413               memcpy (names, syms[i]->name, len + 1);
3414               names += len + 1;
3415               /* Have udata.p point back to the original symbol this
3416                  synthetic symbol was derived from.  */
3417               s->udata.p = syms[i];
3418               s++;
3419             }
3420         }
3421     }
3422   else
3423     {
3424       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3425       bfd_byte *contents = NULL;
3426       size_t size;
3427       long plt_count = 0;
3428       bfd_vma glink_vma = 0, resolv_vma = 0;
3429       asection *dynamic, *glink = NULL, *relplt = NULL;
3430       arelent *p;
3431
3432       if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3433         {
3434         free_contents_and_exit_err:
3435           count = -1;
3436         free_contents_and_exit:
3437           if (contents)
3438             free (contents);
3439           goto done;
3440         }
3441
3442       size = 0;
3443       for (i = secsymend; i < opdsymend; ++i)
3444         {
3445           bfd_vma ent;
3446
3447           /* Ignore bogus symbols.  */
3448           if (syms[i]->value > opd->size - 8)
3449             continue;
3450
3451           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3452           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3453             {
3454               ++count;
3455               size += sizeof (asymbol);
3456               size += strlen (syms[i]->name) + 2;
3457             }
3458         }
3459
3460       /* Get start of .glink stubs from DT_PPC64_GLINK.  */
3461       if (dyn_count != 0
3462           && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3463         {
3464           bfd_byte *dynbuf, *extdyn, *extdynend;
3465           size_t extdynsize;
3466           void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3467
3468           if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3469             goto free_contents_and_exit_err;
3470
3471           extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3472           swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3473
3474           extdyn = dynbuf;
3475           extdynend = extdyn + dynamic->size;
3476           for (; extdyn < extdynend; extdyn += extdynsize)
3477             {
3478               Elf_Internal_Dyn dyn;
3479               (*swap_dyn_in) (abfd, extdyn, &dyn);
3480
3481               if (dyn.d_tag == DT_NULL)
3482                 break;
3483
3484               if (dyn.d_tag == DT_PPC64_GLINK)
3485                 {
3486                   /* The first glink stub starts at offset 32; see
3487                      comment in ppc64_elf_finish_dynamic_sections. */
3488                   glink_vma = dyn.d_un.d_val + GLINK_CALL_STUB_SIZE - 8 * 4;
3489                   /* The .glink section usually does not survive the final
3490                      link; search for the section (usually .text) where the
3491                      glink stubs now reside.  */
3492                   glink = bfd_sections_find_if (abfd, section_covers_vma,
3493                                                 &glink_vma);
3494                   break;
3495                 }
3496             }
3497
3498           free (dynbuf);
3499         }
3500
3501       if (glink != NULL)
3502         {
3503           /* Determine __glink trampoline by reading the relative branch
3504              from the first glink stub.  */
3505           bfd_byte buf[4];
3506           unsigned int off = 0;
3507
3508           while (bfd_get_section_contents (abfd, glink, buf,
3509                                            glink_vma + off - glink->vma, 4))
3510             {
3511               unsigned int insn = bfd_get_32 (abfd, buf);
3512               insn ^= B_DOT;
3513               if ((insn & ~0x3fffffc) == 0)
3514                 {
3515                   resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3516                   break;
3517                 }
3518               off += 4;
3519               if (off > 4)
3520                 break;
3521             }
3522
3523           if (resolv_vma)
3524             size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3525
3526           relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3527           if (relplt != NULL)
3528             {
3529               slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3530               if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3531                 goto free_contents_and_exit_err;
3532
3533               plt_count = relplt->size / sizeof (Elf64_External_Rela);
3534               size += plt_count * sizeof (asymbol);
3535
3536               p = relplt->relocation;
3537               for (i = 0; i < plt_count; i++, p++)
3538                 {
3539                   size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3540                   if (p->addend != 0)
3541                     size += sizeof ("+0x") - 1 + 16;
3542                 }
3543             }
3544         }
3545
3546       if (size == 0)
3547         goto free_contents_and_exit;
3548       s = *ret = bfd_malloc (size);
3549       if (s == NULL)
3550         goto free_contents_and_exit_err;
3551
3552       names = (char *) (s + count + plt_count + (resolv_vma != 0));
3553
3554       for (i = secsymend; i < opdsymend; ++i)
3555         {
3556           bfd_vma ent;
3557
3558           if (syms[i]->value > opd->size - 8)
3559             continue;
3560
3561           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3562           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3563             {
3564               long lo, hi;
3565               size_t len;
3566               asection *sec = abfd->sections;
3567
3568               *s = *syms[i];
3569               lo = codesecsym;
3570               hi = codesecsymend;
3571               while (lo < hi)
3572                 {
3573                   long mid = (lo + hi) >> 1;
3574                   if (syms[mid]->section->vma < ent)
3575                     lo = mid + 1;
3576                   else if (syms[mid]->section->vma > ent)
3577                     hi = mid;
3578                   else
3579                     {
3580                       sec = syms[mid]->section;
3581                       break;
3582                     }
3583                 }
3584
3585               if (lo >= hi && lo > codesecsym)
3586                 sec = syms[lo - 1]->section;
3587
3588               for (; sec != NULL; sec = sec->next)
3589                 {
3590                   if (sec->vma > ent)
3591                     break;
3592                   /* SEC_LOAD may not be set if SEC is from a separate debug
3593                      info file.  */
3594                   if ((sec->flags & SEC_ALLOC) == 0)
3595                     break;
3596                   if ((sec->flags & SEC_CODE) != 0)
3597                     s->section = sec;
3598                 }
3599               s->flags |= BSF_SYNTHETIC;
3600               s->value = ent - s->section->vma;
3601               s->name = names;
3602               *names++ = '.';
3603               len = strlen (syms[i]->name);
3604               memcpy (names, syms[i]->name, len + 1);
3605               names += len + 1;
3606               /* Have udata.p point back to the original symbol this
3607                  synthetic symbol was derived from.  */
3608               s->udata.p = syms[i];
3609               s++;
3610             }
3611         }
3612       free (contents);
3613
3614       if (glink != NULL && relplt != NULL)
3615         {
3616           if (resolv_vma)
3617             {
3618               /* Add a symbol for the main glink trampoline.  */
3619               memset (s, 0, sizeof *s);
3620               s->the_bfd = abfd;
3621               s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3622               s->section = glink;
3623               s->value = resolv_vma - glink->vma;
3624               s->name = names;
3625               memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3626               names += sizeof ("__glink_PLTresolve");
3627               s++;
3628               count++;
3629             }
3630
3631           /* FIXME: It would be very much nicer to put sym@plt on the
3632              stub rather than on the glink branch table entry.  The
3633              objdump disassembler would then use a sensible symbol
3634              name on plt calls.  The difficulty in doing so is
3635              a) finding the stubs, and,
3636              b) matching stubs against plt entries, and,
3637              c) there can be multiple stubs for a given plt entry.
3638
3639              Solving (a) could be done by code scanning, but older
3640              ppc64 binaries used different stubs to current code.
3641              (b) is the tricky one since you need to known the toc
3642              pointer for at least one function that uses a pic stub to
3643              be able to calculate the plt address referenced.
3644              (c) means gdb would need to set multiple breakpoints (or
3645              find the glink branch itself) when setting breakpoints
3646              for pending shared library loads.  */
3647           p = relplt->relocation;
3648           for (i = 0; i < plt_count; i++, p++)
3649             {
3650               size_t len;
3651
3652               *s = **p->sym_ptr_ptr;
3653               /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
3654                  we are defining a symbol, ensure one of them is set.  */
3655               if ((s->flags & BSF_LOCAL) == 0)
3656                 s->flags |= BSF_GLOBAL;
3657               s->flags |= BSF_SYNTHETIC;
3658               s->section = glink;
3659               s->value = glink_vma - glink->vma;
3660               s->name = names;
3661               s->udata.p = NULL;
3662               len = strlen ((*p->sym_ptr_ptr)->name);
3663               memcpy (names, (*p->sym_ptr_ptr)->name, len);
3664               names += len;
3665               if (p->addend != 0)
3666                 {
3667                   memcpy (names, "+0x", sizeof ("+0x") - 1);
3668                   names += sizeof ("+0x") - 1;
3669                   bfd_sprintf_vma (abfd, names, p->addend);
3670                   names += strlen (names);
3671                 }
3672               memcpy (names, "@plt", sizeof ("@plt"));
3673               names += sizeof ("@plt");
3674               s++;
3675               if (abi < 2)
3676                 {
3677                   glink_vma += 8;
3678                   if (i >= 0x8000)
3679                     glink_vma += 4;
3680                 }
3681               else
3682                 glink_vma += 4;
3683             }
3684           count += plt_count;
3685         }
3686     }
3687
3688  done:
3689   free (syms);
3690   return count;
3691 }
3692 \f
3693 /* The following functions are specific to the ELF linker, while
3694    functions above are used generally.  Those named ppc64_elf_* are
3695    called by the main ELF linker code.  They appear in this file more
3696    or less in the order in which they are called.  eg.
3697    ppc64_elf_check_relocs is called early in the link process,
3698    ppc64_elf_finish_dynamic_sections is one of the last functions
3699    called.
3700
3701    PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3702    functions have both a function code symbol and a function descriptor
3703    symbol.  A call to foo in a relocatable object file looks like:
3704
3705    .            .text
3706    .    x:
3707    .            bl      .foo
3708    .            nop
3709
3710    The function definition in another object file might be:
3711
3712    .            .section .opd
3713    .    foo:    .quad   .foo
3714    .            .quad   .TOC.@tocbase
3715    .            .quad   0
3716    .
3717    .            .text
3718    .    .foo:   blr
3719
3720    When the linker resolves the call during a static link, the branch
3721    unsurprisingly just goes to .foo and the .opd information is unused.
3722    If the function definition is in a shared library, things are a little
3723    different:  The call goes via a plt call stub, the opd information gets
3724    copied to the plt, and the linker patches the nop.
3725
3726    .    x:
3727    .            bl      .foo_stub
3728    .            ld      2,40(1)
3729    .
3730    .
3731    .    .foo_stub:
3732    .            std     2,40(1)                 # in practice, the call stub
3733    .            addis   11,2,Lfoo@toc@ha        # is slightly optimized, but
3734    .            addi    11,11,Lfoo@toc@l        # this is the general idea
3735    .            ld      12,0(11)
3736    .            ld      2,8(11)
3737    .            mtctr   12
3738    .            ld      11,16(11)
3739    .            bctr
3740    .
3741    .            .section .plt
3742    .    Lfoo:   reloc (R_PPC64_JMP_SLOT, foo)
3743
3744    The "reloc ()" notation is supposed to indicate that the linker emits
3745    an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
3746    copying.
3747
3748    What are the difficulties here?  Well, firstly, the relocations
3749    examined by the linker in check_relocs are against the function code
3750    sym .foo, while the dynamic relocation in the plt is emitted against
3751    the function descriptor symbol, foo.  Somewhere along the line, we need
3752    to carefully copy dynamic link information from one symbol to the other.
3753    Secondly, the generic part of the elf linker will make .foo a dynamic
3754    symbol as is normal for most other backends.  We need foo dynamic
3755    instead, at least for an application final link.  However, when
3756    creating a shared library containing foo, we need to have both symbols
3757    dynamic so that references to .foo are satisfied during the early
3758    stages of linking.  Otherwise the linker might decide to pull in a
3759    definition from some other object, eg. a static library.
3760
3761    Update: As of August 2004, we support a new convention.  Function
3762    calls may use the function descriptor symbol, ie. "bl foo".  This
3763    behaves exactly as "bl .foo".  */
3764
3765 /* Of those relocs that might be copied as dynamic relocs, this function
3766    selects those that must be copied when linking a shared library,
3767    even when the symbol is local.  */
3768
3769 static int
3770 must_be_dyn_reloc (struct bfd_link_info *info,
3771                    enum elf_ppc64_reloc_type r_type)
3772 {
3773   switch (r_type)
3774     {
3775     default:
3776       return 1;
3777
3778     case R_PPC64_REL32:
3779     case R_PPC64_REL64:
3780     case R_PPC64_REL30:
3781       return 0;
3782
3783     case R_PPC64_TPREL16:
3784     case R_PPC64_TPREL16_LO:
3785     case R_PPC64_TPREL16_HI:
3786     case R_PPC64_TPREL16_HA:
3787     case R_PPC64_TPREL16_DS:
3788     case R_PPC64_TPREL16_LO_DS:
3789     case R_PPC64_TPREL16_HIGH:
3790     case R_PPC64_TPREL16_HIGHA:
3791     case R_PPC64_TPREL16_HIGHER:
3792     case R_PPC64_TPREL16_HIGHERA:
3793     case R_PPC64_TPREL16_HIGHEST:
3794     case R_PPC64_TPREL16_HIGHESTA:
3795     case R_PPC64_TPREL64:
3796       return !bfd_link_executable (info);
3797     }
3798 }
3799
3800 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3801    copying dynamic variables from a shared lib into an app's dynbss
3802    section, and instead use a dynamic relocation to point into the
3803    shared lib.  With code that gcc generates, it's vital that this be
3804    enabled;  In the PowerPC64 ABI, the address of a function is actually
3805    the address of a function descriptor, which resides in the .opd
3806    section.  gcc uses the descriptor directly rather than going via the
3807    GOT as some other ABI's do, which means that initialized function
3808    pointers must reference the descriptor.  Thus, a function pointer
3809    initialized to the address of a function in a shared library will
3810    either require a copy reloc, or a dynamic reloc.  Using a copy reloc
3811    redefines the function descriptor symbol to point to the copy.  This
3812    presents a problem as a plt entry for that function is also
3813    initialized from the function descriptor symbol and the copy reloc
3814    may not be initialized first.  */
3815 #define ELIMINATE_COPY_RELOCS 1
3816
3817 /* Section name for stubs is the associated section name plus this
3818    string.  */
3819 #define STUB_SUFFIX ".stub"
3820
3821 /* Linker stubs.
3822    ppc_stub_long_branch:
3823    Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3824    destination, but a 24 bit branch in a stub section will reach.
3825    .    b       dest
3826
3827    ppc_stub_plt_branch:
3828    Similar to the above, but a 24 bit branch in the stub section won't
3829    reach its destination.
3830    .    addis   %r11,%r2,xxx@toc@ha
3831    .    ld      %r12,xxx@toc@l(%r11)
3832    .    mtctr   %r12
3833    .    bctr
3834
3835    ppc_stub_plt_call:
3836    Used to call a function in a shared library.  If it so happens that
3837    the plt entry referenced crosses a 64k boundary, then an extra
3838    "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3839    .    std     %r2,40(%r1)
3840    .    addis   %r11,%r2,xxx@toc@ha
3841    .    ld      %r12,xxx+0@toc@l(%r11)
3842    .    mtctr   %r12
3843    .    ld      %r2,xxx+8@toc@l(%r11)
3844    .    ld      %r11,xxx+16@toc@l(%r11)
3845    .    bctr
3846
3847    ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3848    code to adjust the value and save r2 to support multiple toc sections.
3849    A ppc_stub_long_branch with an r2 offset looks like:
3850    .    std     %r2,40(%r1)
3851    .    addis   %r2,%r2,off@ha
3852    .    addi    %r2,%r2,off@l
3853    .    b       dest
3854
3855    A ppc_stub_plt_branch with an r2 offset looks like:
3856    .    std     %r2,40(%r1)
3857    .    addis   %r11,%r2,xxx@toc@ha
3858    .    ld      %r12,xxx@toc@l(%r11)
3859    .    addis   %r2,%r2,off@ha
3860    .    addi    %r2,%r2,off@l
3861    .    mtctr   %r12
3862    .    bctr
3863
3864    In cases where the "addis" instruction would add zero, the "addis" is
3865    omitted and following instructions modified slightly in some cases.
3866 */
3867
3868 enum ppc_stub_type {
3869   ppc_stub_none,
3870   ppc_stub_long_branch,
3871   ppc_stub_long_branch_r2off,
3872   ppc_stub_plt_branch,
3873   ppc_stub_plt_branch_r2off,
3874   ppc_stub_plt_call,
3875   ppc_stub_plt_call_r2save,
3876   ppc_stub_global_entry,
3877   ppc_stub_save_res
3878 };
3879
3880 /* Information on stub grouping.  */
3881 struct map_stub
3882 {
3883   /* The stub section.  */
3884   asection *stub_sec;
3885   /* This is the section to which stubs in the group will be attached.  */
3886   asection *link_sec;
3887   /* Next group.  */
3888   struct map_stub *next;
3889   /* Whether to emit a copy of register save/restore functions in this
3890      group.  */
3891   int needs_save_res;
3892 };
3893
3894 struct ppc_stub_hash_entry {
3895
3896   /* Base hash table entry structure.  */
3897   struct bfd_hash_entry root;
3898
3899   enum ppc_stub_type stub_type;
3900
3901   /* Group information.  */
3902   struct map_stub *group;
3903
3904   /* Offset within stub_sec of the beginning of this stub.  */
3905   bfd_vma stub_offset;
3906
3907   /* Given the symbol's value and its section we can determine its final
3908      value when building the stubs (so the stub knows where to jump.  */
3909   bfd_vma target_value;
3910   asection *target_section;
3911
3912   /* The symbol table entry, if any, that this was derived from.  */
3913   struct ppc_link_hash_entry *h;
3914   struct plt_entry *plt_ent;
3915
3916   /* Symbol st_other.  */
3917   unsigned char other;
3918 };
3919
3920 struct ppc_branch_hash_entry {
3921
3922   /* Base hash table entry structure.  */
3923   struct bfd_hash_entry root;
3924
3925   /* Offset within branch lookup table.  */
3926   unsigned int offset;
3927
3928   /* Generation marker.  */
3929   unsigned int iter;
3930 };
3931
3932 /* Used to track dynamic relocations for local symbols.  */
3933 struct ppc_dyn_relocs
3934 {
3935   struct ppc_dyn_relocs *next;
3936
3937   /* The input section of the reloc.  */
3938   asection *sec;
3939
3940   /* Total number of relocs copied for the input section.  */
3941   unsigned int count : 31;
3942
3943   /* Whether this entry is for STT_GNU_IFUNC symbols.  */
3944   unsigned int ifunc : 1;
3945 };
3946
3947 struct ppc_link_hash_entry
3948 {
3949   struct elf_link_hash_entry elf;
3950
3951   union {
3952     /* A pointer to the most recently used stub hash entry against this
3953        symbol.  */
3954     struct ppc_stub_hash_entry *stub_cache;
3955
3956     /* A pointer to the next symbol starting with a '.'  */
3957     struct ppc_link_hash_entry *next_dot_sym;
3958   } u;
3959
3960   /* Track dynamic relocs copied for this symbol.  */
3961   struct elf_dyn_relocs *dyn_relocs;
3962
3963   /* Chain of aliases referring to a weakdef.  */
3964   struct ppc_link_hash_entry *weakref;
3965
3966   /* Link between function code and descriptor symbols.  */
3967   struct ppc_link_hash_entry *oh;
3968
3969   /* Flag function code and descriptor symbols.  */
3970   unsigned int is_func:1;
3971   unsigned int is_func_descriptor:1;
3972   unsigned int fake:1;
3973
3974   /* Whether global opd/toc sym has been adjusted or not.
3975      After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3976      should be set for all globals defined in any opd/toc section.  */
3977   unsigned int adjust_done:1;
3978
3979   /* Set if we twiddled this symbol to weak at some stage.  */
3980   unsigned int was_undefined:1;
3981
3982   /* Set if this is an out-of-line register save/restore function,
3983      with non-standard calling convention.  */
3984   unsigned int save_res:1;
3985
3986   /* Contexts in which symbol is used in the GOT (or TOC).
3987      TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3988      corresponding relocs are encountered during check_relocs.
3989      tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3990      indicate the corresponding GOT entry type is not needed.
3991      tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3992      a TPREL one.  We use a separate flag rather than setting TPREL
3993      just for convenience in distinguishing the two cases.  */
3994 #define TLS_GD           1      /* GD reloc. */
3995 #define TLS_LD           2      /* LD reloc. */
3996 #define TLS_TPREL        4      /* TPREL reloc, => IE. */
3997 #define TLS_DTPREL       8      /* DTPREL reloc, => LD. */
3998 #define TLS_TLS         16      /* Any TLS reloc.  */
3999 #define TLS_EXPLICIT    32      /* Marks TOC section TLS relocs. */
4000 #define TLS_TPRELGD     64      /* TPREL reloc resulting from GD->IE. */
4001 #define PLT_IFUNC      128      /* STT_GNU_IFUNC.  */
4002   unsigned char tls_mask;
4003 };
4004
4005 /* ppc64 ELF linker hash table.  */
4006
4007 struct ppc_link_hash_table
4008 {
4009   struct elf_link_hash_table elf;
4010
4011   /* The stub hash table.  */
4012   struct bfd_hash_table stub_hash_table;
4013
4014   /* Another hash table for plt_branch stubs.  */
4015   struct bfd_hash_table branch_hash_table;
4016
4017   /* Hash table for function prologue tocsave.  */
4018   htab_t tocsave_htab;
4019
4020   /* Various options and other info passed from the linker.  */
4021   struct ppc64_elf_params *params;
4022
4023   /* The size of sec_info below.  */
4024   unsigned int sec_info_arr_size;
4025
4026   /* Per-section array of extra section info.  Done this way rather
4027      than as part of ppc64_elf_section_data so we have the info for
4028      non-ppc64 sections.  */
4029   struct
4030   {
4031     /* Along with elf_gp, specifies the TOC pointer used by this section.  */
4032     bfd_vma toc_off;
4033
4034     union
4035     {
4036       /* The section group that this section belongs to.  */
4037       struct map_stub *group;
4038       /* A temp section list pointer.  */
4039       asection *list;
4040     } u;
4041   } *sec_info;
4042
4043   /* Linked list of groups.  */
4044   struct map_stub *group;
4045
4046   /* Temp used when calculating TOC pointers.  */
4047   bfd_vma toc_curr;
4048   bfd *toc_bfd;
4049   asection *toc_first_sec;
4050
4051   /* Used when adding symbols.  */
4052   struct ppc_link_hash_entry *dot_syms;
4053
4054   /* Shortcuts to get to dynamic linker sections.  */
4055   asection *dynbss;
4056   asection *relbss;
4057   asection *glink;
4058   asection *sfpr;
4059   asection *brlt;
4060   asection *relbrlt;
4061   asection *glink_eh_frame;
4062
4063   /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
4064   struct ppc_link_hash_entry *tls_get_addr;
4065   struct ppc_link_hash_entry *tls_get_addr_fd;
4066
4067   /* The size of reliplt used by got entry relocs.  */
4068   bfd_size_type got_reli_size;
4069
4070   /* Statistics.  */
4071   unsigned long stub_count[ppc_stub_global_entry];
4072
4073   /* Number of stubs against global syms.  */
4074   unsigned long stub_globals;
4075
4076   /* Set if we're linking code with function descriptors.  */
4077   unsigned int opd_abi:1;
4078
4079   /* Support for multiple toc sections.  */
4080   unsigned int do_multi_toc:1;
4081   unsigned int multi_toc_needed:1;
4082   unsigned int second_toc_pass:1;
4083   unsigned int do_toc_opt:1;
4084
4085   /* Set on error.  */
4086   unsigned int stub_error:1;
4087
4088   /* Temp used by ppc64_elf_before_check_relocs.  */
4089   unsigned int twiddled_syms:1;
4090
4091   /* Incremented every time we size stubs.  */
4092   unsigned int stub_iteration;
4093
4094   /* Small local sym cache.  */
4095   struct sym_cache sym_cache;
4096 };
4097
4098 /* Rename some of the generic section flags to better document how they
4099    are used here.  */
4100
4101 /* Nonzero if this section has TLS related relocations.  */
4102 #define has_tls_reloc sec_flg0
4103
4104 /* Nonzero if this section has a call to __tls_get_addr.  */
4105 #define has_tls_get_addr_call sec_flg1
4106
4107 /* Nonzero if this section has any toc or got relocs.  */
4108 #define has_toc_reloc sec_flg2
4109
4110 /* Nonzero if this section has a call to another section that uses
4111    the toc or got.  */
4112 #define makes_toc_func_call sec_flg3
4113
4114 /* Recursion protection when determining above flag.  */
4115 #define call_check_in_progress sec_flg4
4116 #define call_check_done sec_flg5
4117
4118 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
4119
4120 #define ppc_hash_table(p) \
4121   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
4122   == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
4123
4124 #define ppc_stub_hash_lookup(table, string, create, copy) \
4125   ((struct ppc_stub_hash_entry *) \
4126    bfd_hash_lookup ((table), (string), (create), (copy)))
4127
4128 #define ppc_branch_hash_lookup(table, string, create, copy) \
4129   ((struct ppc_branch_hash_entry *) \
4130    bfd_hash_lookup ((table), (string), (create), (copy)))
4131
4132 /* Create an entry in the stub hash table.  */
4133
4134 static struct bfd_hash_entry *
4135 stub_hash_newfunc (struct bfd_hash_entry *entry,
4136                    struct bfd_hash_table *table,
4137                    const char *string)
4138 {
4139   /* Allocate the structure if it has not already been allocated by a
4140      subclass.  */
4141   if (entry == NULL)
4142     {
4143       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4144       if (entry == NULL)
4145         return entry;
4146     }
4147
4148   /* Call the allocation method of the superclass.  */
4149   entry = bfd_hash_newfunc (entry, table, string);
4150   if (entry != NULL)
4151     {
4152       struct ppc_stub_hash_entry *eh;
4153
4154       /* Initialize the local fields.  */
4155       eh = (struct ppc_stub_hash_entry *) entry;
4156       eh->stub_type = ppc_stub_none;
4157       eh->group = NULL;
4158       eh->stub_offset = 0;
4159       eh->target_value = 0;
4160       eh->target_section = NULL;
4161       eh->h = NULL;
4162       eh->plt_ent = NULL;
4163       eh->other = 0;
4164     }
4165
4166   return entry;
4167 }
4168
4169 /* Create an entry in the branch hash table.  */
4170
4171 static struct bfd_hash_entry *
4172 branch_hash_newfunc (struct bfd_hash_entry *entry,
4173                      struct bfd_hash_table *table,
4174                      const char *string)
4175 {
4176   /* Allocate the structure if it has not already been allocated by a
4177      subclass.  */
4178   if (entry == NULL)
4179     {
4180       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4181       if (entry == NULL)
4182         return entry;
4183     }
4184
4185   /* Call the allocation method of the superclass.  */
4186   entry = bfd_hash_newfunc (entry, table, string);
4187   if (entry != NULL)
4188     {
4189       struct ppc_branch_hash_entry *eh;
4190
4191       /* Initialize the local fields.  */
4192       eh = (struct ppc_branch_hash_entry *) entry;
4193       eh->offset = 0;
4194       eh->iter = 0;
4195     }
4196
4197   return entry;
4198 }
4199
4200 /* Create an entry in a ppc64 ELF linker hash table.  */
4201
4202 static struct bfd_hash_entry *
4203 link_hash_newfunc (struct bfd_hash_entry *entry,
4204                    struct bfd_hash_table *table,
4205                    const char *string)
4206 {
4207   /* Allocate the structure if it has not already been allocated by a
4208      subclass.  */
4209   if (entry == NULL)
4210     {
4211       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4212       if (entry == NULL)
4213         return entry;
4214     }
4215
4216   /* Call the allocation method of the superclass.  */
4217   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4218   if (entry != NULL)
4219     {
4220       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4221
4222       memset (&eh->u.stub_cache, 0,
4223               (sizeof (struct ppc_link_hash_entry)
4224                - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4225
4226       /* When making function calls, old ABI code references function entry
4227          points (dot symbols), while new ABI code references the function
4228          descriptor symbol.  We need to make any combination of reference and
4229          definition work together, without breaking archive linking.
4230
4231          For a defined function "foo" and an undefined call to "bar":
4232          An old object defines "foo" and ".foo", references ".bar" (possibly
4233          "bar" too).
4234          A new object defines "foo" and references "bar".
4235
4236          A new object thus has no problem with its undefined symbols being
4237          satisfied by definitions in an old object.  On the other hand, the
4238          old object won't have ".bar" satisfied by a new object.
4239
4240          Keep a list of newly added dot-symbols.  */
4241
4242       if (string[0] == '.')
4243         {
4244           struct ppc_link_hash_table *htab;
4245
4246           htab = (struct ppc_link_hash_table *) table;
4247           eh->u.next_dot_sym = htab->dot_syms;
4248           htab->dot_syms = eh;
4249         }
4250     }
4251
4252   return entry;
4253 }
4254
4255 struct tocsave_entry {
4256   asection *sec;
4257   bfd_vma offset;
4258 };
4259
4260 static hashval_t
4261 tocsave_htab_hash (const void *p)
4262 {
4263   const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4264   return ((bfd_vma)(intptr_t) e->sec ^ e->offset) >> 3;
4265 }
4266
4267 static int
4268 tocsave_htab_eq (const void *p1, const void *p2)
4269 {
4270   const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4271   const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4272   return e1->sec == e2->sec && e1->offset == e2->offset;
4273 }
4274
4275 /* Destroy a ppc64 ELF linker hash table.  */
4276
4277 static void
4278 ppc64_elf_link_hash_table_free (bfd *obfd)
4279 {
4280   struct ppc_link_hash_table *htab;
4281
4282   htab = (struct ppc_link_hash_table *) obfd->link.hash;
4283   if (htab->tocsave_htab)
4284     htab_delete (htab->tocsave_htab);
4285   bfd_hash_table_free (&htab->branch_hash_table);
4286   bfd_hash_table_free (&htab->stub_hash_table);
4287   _bfd_elf_link_hash_table_free (obfd);
4288 }
4289
4290 /* Create a ppc64 ELF linker hash table.  */
4291
4292 static struct bfd_link_hash_table *
4293 ppc64_elf_link_hash_table_create (bfd *abfd)
4294 {
4295   struct ppc_link_hash_table *htab;
4296   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4297
4298   htab = bfd_zmalloc (amt);
4299   if (htab == NULL)
4300     return NULL;
4301
4302   if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4303                                       sizeof (struct ppc_link_hash_entry),
4304                                       PPC64_ELF_DATA))
4305     {
4306       free (htab);
4307       return NULL;
4308     }
4309
4310   /* Init the stub hash table too.  */
4311   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4312                             sizeof (struct ppc_stub_hash_entry)))
4313     {
4314       _bfd_elf_link_hash_table_free (abfd);
4315       return NULL;
4316     }
4317
4318   /* And the branch hash table.  */
4319   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4320                             sizeof (struct ppc_branch_hash_entry)))
4321     {
4322       bfd_hash_table_free (&htab->stub_hash_table);
4323       _bfd_elf_link_hash_table_free (abfd);
4324       return NULL;
4325     }
4326
4327   htab->tocsave_htab = htab_try_create (1024,
4328                                         tocsave_htab_hash,
4329                                         tocsave_htab_eq,
4330                                         NULL);
4331   if (htab->tocsave_htab == NULL)
4332     {
4333       ppc64_elf_link_hash_table_free (abfd);
4334       return NULL;
4335     }
4336   htab->elf.root.hash_table_free = ppc64_elf_link_hash_table_free;
4337
4338   /* Initializing two fields of the union is just cosmetic.  We really
4339      only care about glist, but when compiled on a 32-bit host the
4340      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
4341      debugger inspection of these fields look nicer.  */
4342   htab->elf.init_got_refcount.refcount = 0;
4343   htab->elf.init_got_refcount.glist = NULL;
4344   htab->elf.init_plt_refcount.refcount = 0;
4345   htab->elf.init_plt_refcount.glist = NULL;
4346   htab->elf.init_got_offset.offset = 0;
4347   htab->elf.init_got_offset.glist = NULL;
4348   htab->elf.init_plt_offset.offset = 0;
4349   htab->elf.init_plt_offset.glist = NULL;
4350
4351   return &htab->elf.root;
4352 }
4353
4354 /* Create sections for linker generated code.  */
4355
4356 static bfd_boolean
4357 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4358 {
4359   struct ppc_link_hash_table *htab;
4360   flagword flags;
4361
4362   htab = ppc_hash_table (info);
4363
4364   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4365            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4366   if (htab->params->save_restore_funcs)
4367     {
4368       /* Create .sfpr for code to save and restore fp regs.  */
4369       htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4370                                                        flags);
4371       if (htab->sfpr == NULL
4372           || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4373         return FALSE;
4374     }
4375
4376   if (bfd_link_relocatable (info))
4377     return TRUE;
4378
4379   /* Create .glink for lazy dynamic linking support.  */
4380   htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4381                                                     flags);
4382   if (htab->glink == NULL
4383       || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4384     return FALSE;
4385
4386   if (!info->no_ld_generated_unwind_info)
4387     {
4388       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4389                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4390       htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4391                                                                  ".eh_frame",
4392                                                                  flags);
4393       if (htab->glink_eh_frame == NULL
4394           || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4395         return FALSE;
4396     }
4397
4398   flags = SEC_ALLOC | SEC_LINKER_CREATED;
4399   htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4400   if (htab->elf.iplt == NULL
4401       || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4402     return FALSE;
4403
4404   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4405            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4406   htab->elf.irelplt
4407     = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4408   if (htab->elf.irelplt == NULL
4409       || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4410     return FALSE;
4411
4412   /* Create branch lookup table for plt_branch stubs.  */
4413   flags = (SEC_ALLOC | SEC_LOAD
4414            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4415   htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4416                                                    flags);
4417   if (htab->brlt == NULL
4418       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4419     return FALSE;
4420
4421   if (!bfd_link_pic (info))
4422     return TRUE;
4423
4424   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4425            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4426   htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4427                                                       ".rela.branch_lt",
4428                                                       flags);
4429   if (htab->relbrlt == NULL
4430       || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4431     return FALSE;
4432
4433   return TRUE;
4434 }
4435
4436 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
4437
4438 bfd_boolean
4439 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4440                          struct ppc64_elf_params *params)
4441 {
4442   struct ppc_link_hash_table *htab;
4443
4444   elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4445
4446 /* Always hook our dynamic sections into the first bfd, which is the
4447    linker created stub bfd.  This ensures that the GOT header is at
4448    the start of the output TOC section.  */
4449   htab = ppc_hash_table (info);
4450   htab->elf.dynobj = params->stub_bfd;
4451   htab->params = params;
4452
4453   return create_linkage_sections (htab->elf.dynobj, info);
4454 }
4455
4456 /* Build a name for an entry in the stub hash table.  */
4457
4458 static char *
4459 ppc_stub_name (const asection *input_section,
4460                const asection *sym_sec,
4461                const struct ppc_link_hash_entry *h,
4462                const Elf_Internal_Rela *rel)
4463 {
4464   char *stub_name;
4465   ssize_t len;
4466
4467   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4468      offsets from a sym as a branch target?  In fact, we could
4469      probably assume the addend is always zero.  */
4470   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4471
4472   if (h)
4473     {
4474       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4475       stub_name = bfd_malloc (len);
4476       if (stub_name == NULL)
4477         return stub_name;
4478
4479       len = sprintf (stub_name, "%08x.%s+%x",
4480                      input_section->id & 0xffffffff,
4481                      h->elf.root.root.string,
4482                      (int) rel->r_addend & 0xffffffff);
4483     }
4484   else
4485     {
4486       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4487       stub_name = bfd_malloc (len);
4488       if (stub_name == NULL)
4489         return stub_name;
4490
4491       len = sprintf (stub_name, "%08x.%x:%x+%x",
4492                      input_section->id & 0xffffffff,
4493                      sym_sec->id & 0xffffffff,
4494                      (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4495                      (int) rel->r_addend & 0xffffffff);
4496     }
4497   if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4498     stub_name[len - 2] = 0;
4499   return stub_name;
4500 }
4501
4502 /* Look up an entry in the stub hash.  Stub entries are cached because
4503    creating the stub name takes a bit of time.  */
4504
4505 static struct ppc_stub_hash_entry *
4506 ppc_get_stub_entry (const asection *input_section,
4507                     const asection *sym_sec,
4508                     struct ppc_link_hash_entry *h,
4509                     const Elf_Internal_Rela *rel,
4510                     struct ppc_link_hash_table *htab)
4511 {
4512   struct ppc_stub_hash_entry *stub_entry;
4513   struct map_stub *group;
4514
4515   /* If this input section is part of a group of sections sharing one
4516      stub section, then use the id of the first section in the group.
4517      Stub names need to include a section id, as there may well be
4518      more than one stub used to reach say, printf, and we need to
4519      distinguish between them.  */
4520   group = htab->sec_info[input_section->id].u.group;
4521   if (group == NULL)
4522     return NULL;
4523
4524   if (h != NULL && h->u.stub_cache != NULL
4525       && h->u.stub_cache->h == h
4526       && h->u.stub_cache->group == group)
4527     {
4528       stub_entry = h->u.stub_cache;
4529     }
4530   else
4531     {
4532       char *stub_name;
4533
4534       stub_name = ppc_stub_name (group->link_sec, sym_sec, h, rel);
4535       if (stub_name == NULL)
4536         return NULL;
4537
4538       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4539                                          stub_name, FALSE, FALSE);
4540       if (h != NULL)
4541         h->u.stub_cache = stub_entry;
4542
4543       free (stub_name);
4544     }
4545
4546   return stub_entry;
4547 }
4548
4549 /* Add a new stub entry to the stub hash.  Not all fields of the new
4550    stub entry are initialised.  */
4551
4552 static struct ppc_stub_hash_entry *
4553 ppc_add_stub (const char *stub_name,
4554               asection *section,
4555               struct bfd_link_info *info)
4556 {
4557   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4558   struct map_stub *group;
4559   asection *link_sec;
4560   asection *stub_sec;
4561   struct ppc_stub_hash_entry *stub_entry;
4562
4563   group = htab->sec_info[section->id].u.group;
4564   link_sec = group->link_sec;
4565   stub_sec = group->stub_sec;
4566   if (stub_sec == NULL)
4567     {
4568       size_t namelen;
4569       bfd_size_type len;
4570       char *s_name;
4571
4572       namelen = strlen (link_sec->name);
4573       len = namelen + sizeof (STUB_SUFFIX);
4574       s_name = bfd_alloc (htab->params->stub_bfd, len);
4575       if (s_name == NULL)
4576         return NULL;
4577
4578       memcpy (s_name, link_sec->name, namelen);
4579       memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4580       stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4581       if (stub_sec == NULL)
4582         return NULL;
4583       group->stub_sec = stub_sec;
4584     }
4585
4586   /* Enter this entry into the linker stub hash table.  */
4587   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4588                                      TRUE, FALSE);
4589   if (stub_entry == NULL)
4590     {
4591       info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4592                               section->owner, stub_name);
4593       return NULL;
4594     }
4595
4596   stub_entry->group = group;
4597   stub_entry->stub_offset = 0;
4598   return stub_entry;
4599 }
4600
4601 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4602    not already done.  */
4603
4604 static bfd_boolean
4605 create_got_section (bfd *abfd, struct bfd_link_info *info)
4606 {
4607   asection *got, *relgot;
4608   flagword flags;
4609   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4610
4611   if (!is_ppc64_elf (abfd))
4612     return FALSE;
4613   if (htab == NULL)
4614     return FALSE;
4615
4616   if (!htab->elf.sgot
4617       && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4618     return FALSE;
4619
4620   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4621            | SEC_LINKER_CREATED);
4622
4623   got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4624   if (!got
4625       || !bfd_set_section_alignment (abfd, got, 3))
4626     return FALSE;
4627
4628   relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4629                                                flags | SEC_READONLY);
4630   if (!relgot
4631       || ! bfd_set_section_alignment (abfd, relgot, 3))
4632     return FALSE;
4633
4634   ppc64_elf_tdata (abfd)->got = got;
4635   ppc64_elf_tdata (abfd)->relgot = relgot;
4636   return TRUE;
4637 }
4638
4639 /* Create the dynamic sections, and set up shortcuts.  */
4640
4641 static bfd_boolean
4642 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4643 {
4644   struct ppc_link_hash_table *htab;
4645
4646   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4647     return FALSE;
4648
4649   htab = ppc_hash_table (info);
4650   if (htab == NULL)
4651     return FALSE;
4652
4653   htab->dynbss = bfd_get_linker_section (dynobj, ".dynbss");
4654   if (!bfd_link_pic (info))
4655     htab->relbss = bfd_get_linker_section (dynobj, ".rela.bss");
4656
4657   if (!htab->elf.sgot || !htab->elf.splt || !htab->elf.srelplt || !htab->dynbss
4658       || (!bfd_link_pic (info) && !htab->relbss))
4659     abort ();
4660
4661   return TRUE;
4662 }
4663
4664 /* Follow indirect and warning symbol links.  */
4665
4666 static inline struct bfd_link_hash_entry *
4667 follow_link (struct bfd_link_hash_entry *h)
4668 {
4669   while (h->type == bfd_link_hash_indirect
4670          || h->type == bfd_link_hash_warning)
4671     h = h->u.i.link;
4672   return h;
4673 }
4674
4675 static inline struct elf_link_hash_entry *
4676 elf_follow_link (struct elf_link_hash_entry *h)
4677 {
4678   return (struct elf_link_hash_entry *) follow_link (&h->root);
4679 }
4680
4681 static inline struct ppc_link_hash_entry *
4682 ppc_follow_link (struct ppc_link_hash_entry *h)
4683 {
4684   return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4685 }
4686
4687 /* Merge PLT info on FROM with that on TO.  */
4688
4689 static void
4690 move_plt_plist (struct ppc_link_hash_entry *from,
4691                 struct ppc_link_hash_entry *to)
4692 {
4693   if (from->elf.plt.plist != NULL)
4694     {
4695       if (to->elf.plt.plist != NULL)
4696         {
4697           struct plt_entry **entp;
4698           struct plt_entry *ent;
4699
4700           for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4701             {
4702               struct plt_entry *dent;
4703
4704               for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4705                 if (dent->addend == ent->addend)
4706                   {
4707                     dent->plt.refcount += ent->plt.refcount;
4708                     *entp = ent->next;
4709                     break;
4710                   }
4711               if (dent == NULL)
4712                 entp = &ent->next;
4713             }
4714           *entp = to->elf.plt.plist;
4715         }
4716
4717       to->elf.plt.plist = from->elf.plt.plist;
4718       from->elf.plt.plist = NULL;
4719     }
4720 }
4721
4722 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
4723
4724 static void
4725 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4726                                 struct elf_link_hash_entry *dir,
4727                                 struct elf_link_hash_entry *ind)
4728 {
4729   struct ppc_link_hash_entry *edir, *eind;
4730
4731   edir = (struct ppc_link_hash_entry *) dir;
4732   eind = (struct ppc_link_hash_entry *) ind;
4733
4734   edir->is_func |= eind->is_func;
4735   edir->is_func_descriptor |= eind->is_func_descriptor;
4736   edir->tls_mask |= eind->tls_mask;
4737   if (eind->oh != NULL)
4738     edir->oh = ppc_follow_link (eind->oh);
4739
4740   /* If called to transfer flags for a weakdef during processing
4741      of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4742      We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
4743   if (!(ELIMINATE_COPY_RELOCS
4744         && eind->elf.root.type != bfd_link_hash_indirect
4745         && edir->elf.dynamic_adjusted))
4746     edir->elf.non_got_ref |= eind->elf.non_got_ref;
4747
4748   edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4749   edir->elf.ref_regular |= eind->elf.ref_regular;
4750   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4751   edir->elf.needs_plt |= eind->elf.needs_plt;
4752   edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4753
4754   /* If we were called to copy over info for a weak sym, don't copy
4755      dyn_relocs, plt/got info, or dynindx.  We used to copy dyn_relocs
4756      in order to simplify readonly_dynrelocs and save a field in the
4757      symbol hash entry, but that means dyn_relocs can't be used in any
4758      tests about a specific symbol, or affect other symbol flags which
4759      are then tested.
4760      Chain weakdefs so we can get from the weakdef back to an alias.
4761      The list is circular so that we don't need to use u.weakdef as
4762      well as this list to look at all aliases.  */
4763   if (eind->elf.root.type != bfd_link_hash_indirect)
4764     {
4765       struct ppc_link_hash_entry *cur, *add, *next;
4766
4767       add = eind;
4768       do
4769         {
4770           cur = edir->weakref;
4771           if (cur != NULL)
4772             {
4773               do
4774                 {
4775                   /* We can be called twice for the same symbols.
4776                      Don't make multiple loops.  */
4777                   if (cur == add)
4778                     return;
4779                   cur = cur->weakref;
4780                 } while (cur != edir);
4781             }
4782           next = add->weakref;
4783           if (cur != add)
4784             {
4785               add->weakref = edir->weakref != NULL ? edir->weakref : edir;
4786               edir->weakref = add;
4787             }
4788           add = next;
4789         } while (add != NULL && add != eind);
4790       return;
4791     }
4792
4793   /* Copy over any dynamic relocs we may have on the indirect sym.  */
4794   if (eind->dyn_relocs != NULL)
4795     {
4796       if (edir->dyn_relocs != NULL)
4797         {
4798           struct elf_dyn_relocs **pp;
4799           struct elf_dyn_relocs *p;
4800
4801           /* Add reloc counts against the indirect sym to the direct sym
4802              list.  Merge any entries against the same section.  */
4803           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4804             {
4805               struct elf_dyn_relocs *q;
4806
4807               for (q = edir->dyn_relocs; q != NULL; q = q->next)
4808                 if (q->sec == p->sec)
4809                   {
4810                     q->pc_count += p->pc_count;
4811                     q->count += p->count;
4812                     *pp = p->next;
4813                     break;
4814                   }
4815               if (q == NULL)
4816                 pp = &p->next;
4817             }
4818           *pp = edir->dyn_relocs;
4819         }
4820
4821       edir->dyn_relocs = eind->dyn_relocs;
4822       eind->dyn_relocs = NULL;
4823     }
4824
4825   /* Copy over got entries that we may have already seen to the
4826      symbol which just became indirect.  */
4827   if (eind->elf.got.glist != NULL)
4828     {
4829       if (edir->elf.got.glist != NULL)
4830         {
4831           struct got_entry **entp;
4832           struct got_entry *ent;
4833
4834           for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4835             {
4836               struct got_entry *dent;
4837
4838               for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4839                 if (dent->addend == ent->addend
4840                     && dent->owner == ent->owner
4841                     && dent->tls_type == ent->tls_type)
4842                   {
4843                     dent->got.refcount += ent->got.refcount;
4844                     *entp = ent->next;
4845                     break;
4846                   }
4847               if (dent == NULL)
4848                 entp = &ent->next;
4849             }
4850           *entp = edir->elf.got.glist;
4851         }
4852
4853       edir->elf.got.glist = eind->elf.got.glist;
4854       eind->elf.got.glist = NULL;
4855     }
4856
4857   /* And plt entries.  */
4858   move_plt_plist (eind, edir);
4859
4860   if (eind->elf.dynindx != -1)
4861     {
4862       if (edir->elf.dynindx != -1)
4863         _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4864                                 edir->elf.dynstr_index);
4865       edir->elf.dynindx = eind->elf.dynindx;
4866       edir->elf.dynstr_index = eind->elf.dynstr_index;
4867       eind->elf.dynindx = -1;
4868       eind->elf.dynstr_index = 0;
4869     }
4870 }
4871
4872 /* Find the function descriptor hash entry from the given function code
4873    hash entry FH.  Link the entries via their OH fields.  */
4874
4875 static struct ppc_link_hash_entry *
4876 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4877 {
4878   struct ppc_link_hash_entry *fdh = fh->oh;
4879
4880   if (fdh == NULL)
4881     {
4882       const char *fd_name = fh->elf.root.root.string + 1;
4883
4884       fdh = (struct ppc_link_hash_entry *)
4885         elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4886       if (fdh == NULL)
4887         return fdh;
4888
4889       fdh->is_func_descriptor = 1;
4890       fdh->oh = fh;
4891       fh->is_func = 1;
4892       fh->oh = fdh;
4893     }
4894
4895   return ppc_follow_link (fdh);
4896 }
4897
4898 /* Make a fake function descriptor sym for the code sym FH.  */
4899
4900 static struct ppc_link_hash_entry *
4901 make_fdh (struct bfd_link_info *info,
4902           struct ppc_link_hash_entry *fh)
4903 {
4904   bfd *abfd;
4905   asymbol *newsym;
4906   struct bfd_link_hash_entry *bh;
4907   struct ppc_link_hash_entry *fdh;
4908
4909   abfd = fh->elf.root.u.undef.abfd;
4910   newsym = bfd_make_empty_symbol (abfd);
4911   newsym->name = fh->elf.root.root.string + 1;
4912   newsym->section = bfd_und_section_ptr;
4913   newsym->value = 0;
4914   newsym->flags = BSF_WEAK;
4915
4916   bh = NULL;
4917   if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4918                                          newsym->flags, newsym->section,
4919                                          newsym->value, NULL, FALSE, FALSE,
4920                                          &bh))
4921     return NULL;
4922
4923   fdh = (struct ppc_link_hash_entry *) bh;
4924   fdh->elf.non_elf = 0;
4925   fdh->fake = 1;
4926   fdh->is_func_descriptor = 1;
4927   fdh->oh = fh;
4928   fh->is_func = 1;
4929   fh->oh = fdh;
4930   return fdh;
4931 }
4932
4933 /* Fix function descriptor symbols defined in .opd sections to be
4934    function type.  */
4935
4936 static bfd_boolean
4937 ppc64_elf_add_symbol_hook (bfd *ibfd,
4938                            struct bfd_link_info *info,
4939                            Elf_Internal_Sym *isym,
4940                            const char **name,
4941                            flagword *flags ATTRIBUTE_UNUSED,
4942                            asection **sec,
4943                            bfd_vma *value)
4944 {
4945   if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4946       && (ibfd->flags & DYNAMIC) == 0
4947       && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
4948     elf_tdata (info->output_bfd)->has_gnu_symbols |= elf_gnu_symbol_ifunc;
4949
4950   if (*sec != NULL
4951       && strcmp ((*sec)->name, ".opd") == 0)
4952     {
4953       asection *code_sec;
4954
4955       if (!(ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4956             || ELF_ST_TYPE (isym->st_info) == STT_FUNC))
4957         isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4958
4959       /* If the symbol is a function defined in .opd, and the function
4960          code is in a discarded group, let it appear to be undefined.  */
4961       if (!bfd_link_relocatable (info)
4962           && (*sec)->reloc_count != 0
4963           && opd_entry_value (*sec, *value, &code_sec, NULL,
4964                               FALSE) != (bfd_vma) -1
4965           && discarded_section (code_sec))
4966         {
4967           *sec = bfd_und_section_ptr;
4968           isym->st_shndx = SHN_UNDEF;
4969         }
4970     }
4971   else if (*sec != NULL
4972            && strcmp ((*sec)->name, ".toc") == 0
4973            && ELF_ST_TYPE (isym->st_info) == STT_OBJECT)
4974     {
4975       struct ppc_link_hash_table *htab = ppc_hash_table (info);
4976       if (htab != NULL)
4977         htab->params->object_in_toc = 1;
4978     }
4979
4980   if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4981     {
4982       if (abiversion (ibfd) == 0)
4983         set_abiversion (ibfd, 2);
4984       else if (abiversion (ibfd) == 1)
4985         {
4986           info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other"
4987                                     " for ABI version 1\n"), name);
4988           bfd_set_error (bfd_error_bad_value);
4989           return FALSE;
4990         }
4991     }
4992
4993   return TRUE;
4994 }
4995
4996 /* Merge non-visibility st_other attributes: local entry point.  */
4997
4998 static void
4999 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
5000                                   const Elf_Internal_Sym *isym,
5001                                   bfd_boolean definition,
5002                                   bfd_boolean dynamic)
5003 {
5004   if (definition && !dynamic)
5005     h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
5006                 | ELF_ST_VISIBILITY (h->other));
5007 }
5008
5009 /* This function makes an old ABI object reference to ".bar" cause the
5010    inclusion of a new ABI object archive that defines "bar".
5011    NAME is a symbol defined in an archive.  Return a symbol in the hash
5012    table that might be satisfied by the archive symbols.  */
5013
5014 static struct elf_link_hash_entry *
5015 ppc64_elf_archive_symbol_lookup (bfd *abfd,
5016                                  struct bfd_link_info *info,
5017                                  const char *name)
5018 {
5019   struct elf_link_hash_entry *h;
5020   char *dot_name;
5021   size_t len;
5022
5023   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
5024   if (h != NULL
5025       /* Don't return this sym if it is a fake function descriptor
5026          created by add_symbol_adjust.  */
5027       && !(h->root.type == bfd_link_hash_undefweak
5028            && ((struct ppc_link_hash_entry *) h)->fake))
5029     return h;
5030
5031   if (name[0] == '.')
5032     return h;
5033
5034   len = strlen (name);
5035   dot_name = bfd_alloc (abfd, len + 2);
5036   if (dot_name == NULL)
5037     return (struct elf_link_hash_entry *) 0 - 1;
5038   dot_name[0] = '.';
5039   memcpy (dot_name + 1, name, len + 1);
5040   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
5041   bfd_release (abfd, dot_name);
5042   return h;
5043 }
5044
5045 /* This function satisfies all old ABI object references to ".bar" if a
5046    new ABI object defines "bar".  Well, at least, undefined dot symbols
5047    are made weak.  This stops later archive searches from including an
5048    object if we already have a function descriptor definition.  It also
5049    prevents the linker complaining about undefined symbols.
5050    We also check and correct mismatched symbol visibility here.  The
5051    most restrictive visibility of the function descriptor and the
5052    function entry symbol is used.  */
5053
5054 static bfd_boolean
5055 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
5056 {
5057   struct ppc_link_hash_table *htab;
5058   struct ppc_link_hash_entry *fdh;
5059
5060   if (eh->elf.root.type == bfd_link_hash_indirect)
5061     return TRUE;
5062
5063   if (eh->elf.root.type == bfd_link_hash_warning)
5064     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
5065
5066   if (eh->elf.root.root.string[0] != '.')
5067     abort ();
5068
5069   htab = ppc_hash_table (info);
5070   if (htab == NULL)
5071     return FALSE;
5072
5073   fdh = lookup_fdh (eh, htab);
5074   if (fdh == NULL)
5075     {
5076       if (!bfd_link_relocatable (info)
5077           && (eh->elf.root.type == bfd_link_hash_undefined
5078               || eh->elf.root.type == bfd_link_hash_undefweak)
5079           && eh->elf.ref_regular)
5080         {
5081           /* Make an undefweak function descriptor sym, which is enough to
5082              pull in an --as-needed shared lib, but won't cause link
5083              errors.  Archives are handled elsewhere.  */
5084           fdh = make_fdh (info, eh);
5085           if (fdh == NULL)
5086             return FALSE;
5087           fdh->elf.ref_regular = 1;
5088         }
5089     }
5090   else
5091     {
5092       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
5093       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
5094       if (entry_vis < descr_vis)
5095         fdh->elf.other += entry_vis - descr_vis;
5096       else if (entry_vis > descr_vis)
5097         eh->elf.other += descr_vis - entry_vis;
5098
5099       if ((fdh->elf.root.type == bfd_link_hash_defined
5100            || fdh->elf.root.type == bfd_link_hash_defweak)
5101           && eh->elf.root.type == bfd_link_hash_undefined)
5102         {
5103           eh->elf.root.type = bfd_link_hash_undefweak;
5104           eh->was_undefined = 1;
5105           htab->twiddled_syms = 1;
5106         }
5107     }
5108
5109   return TRUE;
5110 }
5111
5112 /* Set up opd section info and abiversion for IBFD, and process list
5113    of dot-symbols we made in link_hash_newfunc.  */
5114
5115 static bfd_boolean
5116 ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
5117 {
5118   struct ppc_link_hash_table *htab;
5119   struct ppc_link_hash_entry **p, *eh;
5120   asection *opd = bfd_get_section_by_name (ibfd, ".opd");
5121
5122   if (opd != NULL && opd->size != 0)
5123     {
5124       if (abiversion (ibfd) == 0)
5125         set_abiversion (ibfd, 1);
5126       else if (abiversion (ibfd) >= 2)
5127         {
5128           info->callbacks->einfo (_("%P: %B .opd not allowed in ABI"
5129                                     " version %d\n"),
5130                                   ibfd, abiversion (ibfd));
5131           bfd_set_error (bfd_error_bad_value);
5132           return FALSE;
5133         }
5134
5135       if ((ibfd->flags & DYNAMIC) == 0
5136           && (opd->flags & SEC_RELOC) != 0
5137           && opd->reloc_count != 0
5138           && !bfd_is_abs_section (opd->output_section))
5139         {
5140           /* Garbage collection needs some extra help with .opd sections.
5141              We don't want to necessarily keep everything referenced by
5142              relocs in .opd, as that would keep all functions.  Instead,
5143              if we reference an .opd symbol (a function descriptor), we
5144              want to keep the function code symbol's section.  This is
5145              easy for global symbols, but for local syms we need to keep
5146              information about the associated function section.  */
5147           bfd_size_type amt;
5148           asection **opd_sym_map;
5149
5150           amt = OPD_NDX (opd->size) * sizeof (*opd_sym_map);
5151           opd_sym_map = bfd_zalloc (ibfd, amt);
5152           if (opd_sym_map == NULL)
5153             return FALSE;
5154           ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
5155           BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
5156           ppc64_elf_section_data (opd)->sec_type = sec_opd;
5157         }
5158     }
5159
5160   if (!is_ppc64_elf (info->output_bfd))
5161     return TRUE;
5162   htab = ppc_hash_table (info);
5163   if (htab == NULL)
5164     return FALSE;
5165
5166   /* For input files without an explicit abiversion in e_flags
5167      we should have flagged any with symbol st_other bits set
5168      as ELFv1 and above flagged those with .opd as ELFv2.
5169      Set the output abiversion if not yet set, and for any input
5170      still ambiguous, take its abiversion from the output.
5171      Differences in ABI are reported later.  */
5172   if (abiversion (info->output_bfd) == 0)
5173     set_abiversion (info->output_bfd, abiversion (ibfd));
5174   else if (abiversion (ibfd) == 0)
5175     set_abiversion (ibfd, abiversion (info->output_bfd));
5176
5177   p = &htab->dot_syms;
5178   while ((eh = *p) != NULL)
5179     {
5180       *p = NULL;
5181       if (&eh->elf == htab->elf.hgot)
5182         ;
5183       else if (htab->elf.hgot == NULL
5184                && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
5185         htab->elf.hgot = &eh->elf;
5186       else if (!add_symbol_adjust (eh, info))
5187         return FALSE;
5188       p = &eh->u.next_dot_sym;
5189     }
5190
5191   /* Clear the list for non-ppc64 input files.  */
5192   p = &htab->dot_syms;
5193   while ((eh = *p) != NULL)
5194     {
5195       *p = NULL;
5196       p = &eh->u.next_dot_sym;
5197     }
5198
5199   /* We need to fix the undefs list for any syms we have twiddled to
5200      undefweak.  */
5201   if (htab->twiddled_syms)
5202     {
5203       bfd_link_repair_undef_list (&htab->elf.root);
5204       htab->twiddled_syms = 0;
5205     }
5206   return TRUE;
5207 }
5208
5209 /* Undo hash table changes when an --as-needed input file is determined
5210    not to be needed.  */
5211
5212 static bfd_boolean
5213 ppc64_elf_notice_as_needed (bfd *ibfd,
5214                             struct bfd_link_info *info,
5215                             enum notice_asneeded_action act)
5216 {
5217   if (act == notice_not_needed)
5218     {
5219       struct ppc_link_hash_table *htab = ppc_hash_table (info);
5220
5221       if (htab == NULL)
5222         return FALSE;
5223
5224       htab->dot_syms = NULL;
5225     }
5226   return _bfd_elf_notice_as_needed (ibfd, info, act);
5227 }
5228
5229 /* If --just-symbols against a final linked binary, then assume we need
5230    toc adjusting stubs when calling functions defined there.  */
5231
5232 static void
5233 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5234 {
5235   if ((sec->flags & SEC_CODE) != 0
5236       && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5237       && is_ppc64_elf (sec->owner))
5238     {
5239       if (abiversion (sec->owner) >= 2
5240           || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5241         sec->has_toc_reloc = 1;
5242     }
5243   _bfd_elf_link_just_syms (sec, info);
5244 }
5245
5246 static struct plt_entry **
5247 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5248                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5249 {
5250   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5251   struct plt_entry **local_plt;
5252   unsigned char *local_got_tls_masks;
5253
5254   if (local_got_ents == NULL)
5255     {
5256       bfd_size_type size = symtab_hdr->sh_info;
5257
5258       size *= (sizeof (*local_got_ents)
5259                + sizeof (*local_plt)
5260                + sizeof (*local_got_tls_masks));
5261       local_got_ents = bfd_zalloc (abfd, size);
5262       if (local_got_ents == NULL)
5263         return NULL;
5264       elf_local_got_ents (abfd) = local_got_ents;
5265     }
5266
5267   if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
5268     {
5269       struct got_entry *ent;
5270
5271       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5272         if (ent->addend == r_addend
5273             && ent->owner == abfd
5274             && ent->tls_type == tls_type)
5275           break;
5276       if (ent == NULL)
5277         {
5278           bfd_size_type amt = sizeof (*ent);
5279           ent = bfd_alloc (abfd, amt);
5280           if (ent == NULL)
5281             return FALSE;
5282           ent->next = local_got_ents[r_symndx];
5283           ent->addend = r_addend;
5284           ent->owner = abfd;
5285           ent->tls_type = tls_type;
5286           ent->is_indirect = FALSE;
5287           ent->got.refcount = 0;
5288           local_got_ents[r_symndx] = ent;
5289         }
5290       ent->got.refcount += 1;
5291     }
5292
5293   local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5294   local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5295   local_got_tls_masks[r_symndx] |= tls_type;
5296
5297   return local_plt + r_symndx;
5298 }
5299
5300 static bfd_boolean
5301 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5302 {
5303   struct plt_entry *ent;
5304
5305   for (ent = *plist; ent != NULL; ent = ent->next)
5306     if (ent->addend == addend)
5307       break;
5308   if (ent == NULL)
5309     {
5310       bfd_size_type amt = sizeof (*ent);
5311       ent = bfd_alloc (abfd, amt);
5312       if (ent == NULL)
5313         return FALSE;
5314       ent->next = *plist;
5315       ent->addend = addend;
5316       ent->plt.refcount = 0;
5317       *plist = ent;
5318     }
5319   ent->plt.refcount += 1;
5320   return TRUE;
5321 }
5322
5323 static bfd_boolean
5324 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5325 {
5326   return (r_type == R_PPC64_REL24
5327           || r_type == R_PPC64_REL14
5328           || r_type == R_PPC64_REL14_BRTAKEN
5329           || r_type == R_PPC64_REL14_BRNTAKEN
5330           || r_type == R_PPC64_ADDR24
5331           || r_type == R_PPC64_ADDR14
5332           || r_type == R_PPC64_ADDR14_BRTAKEN
5333           || r_type == R_PPC64_ADDR14_BRNTAKEN);
5334 }
5335
5336 /* Look through the relocs for a section during the first phase, and
5337    calculate needed space in the global offset table, procedure
5338    linkage table, and dynamic reloc sections.  */
5339
5340 static bfd_boolean
5341 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5342                         asection *sec, const Elf_Internal_Rela *relocs)
5343 {
5344   struct ppc_link_hash_table *htab;
5345   Elf_Internal_Shdr *symtab_hdr;
5346   struct elf_link_hash_entry **sym_hashes;
5347   const Elf_Internal_Rela *rel;
5348   const Elf_Internal_Rela *rel_end;
5349   asection *sreloc;
5350   asection **opd_sym_map;
5351   struct elf_link_hash_entry *tga, *dottga;
5352
5353   if (bfd_link_relocatable (info))
5354     return TRUE;
5355
5356   /* Don't do anything special with non-loaded, non-alloced sections.
5357      In particular, any relocs in such sections should not affect GOT
5358      and PLT reference counting (ie. we don't allow them to create GOT
5359      or PLT entries), there's no possibility or desire to optimize TLS
5360      relocs, and there's not much point in propagating relocs to shared
5361      libs that the dynamic linker won't relocate.  */
5362   if ((sec->flags & SEC_ALLOC) == 0)
5363     return TRUE;
5364
5365   BFD_ASSERT (is_ppc64_elf (abfd));
5366
5367   htab = ppc_hash_table (info);
5368   if (htab == NULL)
5369     return FALSE;
5370
5371   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5372                               FALSE, FALSE, TRUE);
5373   dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5374                                  FALSE, FALSE, TRUE);
5375   symtab_hdr = &elf_symtab_hdr (abfd);
5376   sym_hashes = elf_sym_hashes (abfd);
5377   sreloc = NULL;
5378   opd_sym_map = NULL;
5379   if (ppc64_elf_section_data (sec) != NULL
5380       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
5381     opd_sym_map = ppc64_elf_section_data (sec)->u.opd.func_sec;
5382
5383   rel_end = relocs + sec->reloc_count;
5384   for (rel = relocs; rel < rel_end; rel++)
5385     {
5386       unsigned long r_symndx;
5387       struct elf_link_hash_entry *h;
5388       enum elf_ppc64_reloc_type r_type;
5389       int tls_type;
5390       struct _ppc64_elf_section_data *ppc64_sec;
5391       struct plt_entry **ifunc, **plt_list;
5392
5393       r_symndx = ELF64_R_SYM (rel->r_info);
5394       if (r_symndx < symtab_hdr->sh_info)
5395         h = NULL;
5396       else
5397         {
5398           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5399           h = elf_follow_link (h);
5400
5401           /* PR15323, ref flags aren't set for references in the same
5402              object.  */
5403           h->root.non_ir_ref = 1;
5404
5405           if (h == htab->elf.hgot)
5406             sec->has_toc_reloc = 1;
5407         }
5408
5409       tls_type = 0;
5410       ifunc = NULL;
5411       if (h != NULL)
5412         {
5413           if (h->type == STT_GNU_IFUNC)
5414             {
5415               h->needs_plt = 1;
5416               ifunc = &h->plt.plist;
5417             }
5418         }
5419       else
5420         {
5421           Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5422                                                           abfd, r_symndx);
5423           if (isym == NULL)
5424             return FALSE;
5425
5426           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5427             {
5428               ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5429                                              rel->r_addend, PLT_IFUNC);
5430               if (ifunc == NULL)
5431                 return FALSE;
5432             }
5433         }
5434
5435       r_type = ELF64_R_TYPE (rel->r_info);
5436       switch (r_type)
5437         {
5438         case R_PPC64_TLSGD:
5439         case R_PPC64_TLSLD:
5440           /* These special tls relocs tie a call to __tls_get_addr with
5441              its parameter symbol.  */
5442           break;
5443
5444         case R_PPC64_GOT_TLSLD16:
5445         case R_PPC64_GOT_TLSLD16_LO:
5446         case R_PPC64_GOT_TLSLD16_HI:
5447         case R_PPC64_GOT_TLSLD16_HA:
5448           tls_type = TLS_TLS | TLS_LD;
5449           goto dogottls;
5450
5451         case R_PPC64_GOT_TLSGD16:
5452         case R_PPC64_GOT_TLSGD16_LO:
5453         case R_PPC64_GOT_TLSGD16_HI:
5454         case R_PPC64_GOT_TLSGD16_HA:
5455           tls_type = TLS_TLS | TLS_GD;
5456           goto dogottls;
5457
5458         case R_PPC64_GOT_TPREL16_DS:
5459         case R_PPC64_GOT_TPREL16_LO_DS:
5460         case R_PPC64_GOT_TPREL16_HI:
5461         case R_PPC64_GOT_TPREL16_HA:
5462           if (bfd_link_pic (info))
5463             info->flags |= DF_STATIC_TLS;
5464           tls_type = TLS_TLS | TLS_TPREL;
5465           goto dogottls;
5466
5467         case R_PPC64_GOT_DTPREL16_DS:
5468         case R_PPC64_GOT_DTPREL16_LO_DS:
5469         case R_PPC64_GOT_DTPREL16_HI:
5470         case R_PPC64_GOT_DTPREL16_HA:
5471           tls_type = TLS_TLS | TLS_DTPREL;
5472         dogottls:
5473           sec->has_tls_reloc = 1;
5474           /* Fall thru */
5475
5476         case R_PPC64_GOT16:
5477         case R_PPC64_GOT16_DS:
5478         case R_PPC64_GOT16_HA:
5479         case R_PPC64_GOT16_HI:
5480         case R_PPC64_GOT16_LO:
5481         case R_PPC64_GOT16_LO_DS:
5482           /* This symbol requires a global offset table entry.  */
5483           sec->has_toc_reloc = 1;
5484           if (r_type == R_PPC64_GOT_TLSLD16
5485               || r_type == R_PPC64_GOT_TLSGD16
5486               || r_type == R_PPC64_GOT_TPREL16_DS
5487               || r_type == R_PPC64_GOT_DTPREL16_DS
5488               || r_type == R_PPC64_GOT16
5489               || r_type == R_PPC64_GOT16_DS)
5490             {
5491               htab->do_multi_toc = 1;
5492               ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5493             }
5494
5495           if (ppc64_elf_tdata (abfd)->got == NULL
5496               && !create_got_section (abfd, info))
5497             return FALSE;
5498
5499           if (h != NULL)
5500             {
5501               struct ppc_link_hash_entry *eh;
5502               struct got_entry *ent;
5503
5504               eh = (struct ppc_link_hash_entry *) h;
5505               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5506                 if (ent->addend == rel->r_addend
5507                     && ent->owner == abfd
5508                     && ent->tls_type == tls_type)
5509                   break;
5510               if (ent == NULL)
5511                 {
5512                   bfd_size_type amt = sizeof (*ent);
5513                   ent = bfd_alloc (abfd, amt);
5514                   if (ent == NULL)
5515                     return FALSE;
5516                   ent->next = eh->elf.got.glist;
5517                   ent->addend = rel->r_addend;
5518                   ent->owner = abfd;
5519                   ent->tls_type = tls_type;
5520                   ent->is_indirect = FALSE;
5521                   ent->got.refcount = 0;
5522                   eh->elf.got.glist = ent;
5523                 }
5524               ent->got.refcount += 1;
5525               eh->tls_mask |= tls_type;
5526             }
5527           else
5528             /* This is a global offset table entry for a local symbol.  */
5529             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5530                                         rel->r_addend, tls_type))
5531               return FALSE;
5532
5533           /* We may also need a plt entry if the symbol turns out to be
5534              an ifunc.  */
5535           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1)
5536             {
5537               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5538                 return FALSE;
5539             }
5540           break;
5541
5542         case R_PPC64_PLT16_HA:
5543         case R_PPC64_PLT16_HI:
5544         case R_PPC64_PLT16_LO:
5545         case R_PPC64_PLT32:
5546         case R_PPC64_PLT64:
5547           /* This symbol requires a procedure linkage table entry.  */
5548           plt_list = ifunc;
5549           if (h != NULL)
5550             {
5551               h->needs_plt = 1;
5552               if (h->root.root.string[0] == '.'
5553                   && h->root.root.string[1] != '\0')
5554                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5555               plt_list = &h->plt.plist;
5556             }
5557           if (plt_list == NULL)
5558             {
5559               /* It does not make sense to have a procedure linkage
5560                  table entry for a non-ifunc local symbol.  */
5561               info->callbacks->einfo
5562                 (_("%P: %H: %s reloc against local symbol\n"),
5563                  abfd, sec, rel->r_offset,
5564                  ppc64_elf_howto_table[r_type]->name);
5565               bfd_set_error (bfd_error_bad_value);
5566               return FALSE;
5567             }
5568           if (!update_plt_info (abfd, plt_list, rel->r_addend))
5569             return FALSE;
5570           break;
5571
5572           /* The following relocations don't need to propagate the
5573              relocation if linking a shared object since they are
5574              section relative.  */
5575         case R_PPC64_SECTOFF:
5576         case R_PPC64_SECTOFF_LO:
5577         case R_PPC64_SECTOFF_HI:
5578         case R_PPC64_SECTOFF_HA:
5579         case R_PPC64_SECTOFF_DS:
5580         case R_PPC64_SECTOFF_LO_DS:
5581         case R_PPC64_DTPREL16:
5582         case R_PPC64_DTPREL16_LO:
5583         case R_PPC64_DTPREL16_HI:
5584         case R_PPC64_DTPREL16_HA:
5585         case R_PPC64_DTPREL16_DS:
5586         case R_PPC64_DTPREL16_LO_DS:
5587         case R_PPC64_DTPREL16_HIGH:
5588         case R_PPC64_DTPREL16_HIGHA:
5589         case R_PPC64_DTPREL16_HIGHER:
5590         case R_PPC64_DTPREL16_HIGHERA:
5591         case R_PPC64_DTPREL16_HIGHEST:
5592         case R_PPC64_DTPREL16_HIGHESTA:
5593           break;
5594
5595           /* Nor do these.  */
5596         case R_PPC64_REL16:
5597         case R_PPC64_REL16_LO:
5598         case R_PPC64_REL16_HI:
5599         case R_PPC64_REL16_HA:
5600         case R_PPC64_REL16DX_HA:
5601           break;
5602
5603           /* Not supported as a dynamic relocation.  */
5604         case R_PPC64_ADDR64_LOCAL:
5605           if (bfd_link_pic (info))
5606             {
5607               if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5608                 ppc_howto_init ();
5609               info->callbacks->einfo (_("%P: %H: %s reloc unsupported "
5610                                         "in shared libraries and PIEs.\n"),
5611                                       abfd, sec, rel->r_offset,
5612                                       ppc64_elf_howto_table[r_type]->name);
5613               bfd_set_error (bfd_error_bad_value);
5614               return FALSE;
5615             }
5616           break;
5617
5618         case R_PPC64_TOC16:
5619         case R_PPC64_TOC16_DS:
5620           htab->do_multi_toc = 1;
5621           ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5622         case R_PPC64_TOC16_LO:
5623         case R_PPC64_TOC16_HI:
5624         case R_PPC64_TOC16_HA:
5625         case R_PPC64_TOC16_LO_DS:
5626           sec->has_toc_reloc = 1;
5627           break;
5628
5629           /* Marker reloc.  */
5630         case R_PPC64_ENTRY:
5631           break;
5632
5633           /* This relocation describes the C++ object vtable hierarchy.
5634              Reconstruct it for later use during GC.  */
5635         case R_PPC64_GNU_VTINHERIT:
5636           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5637             return FALSE;
5638           break;
5639
5640           /* This relocation describes which C++ vtable entries are actually
5641              used.  Record for later use during GC.  */
5642         case R_PPC64_GNU_VTENTRY:
5643           BFD_ASSERT (h != NULL);
5644           if (h != NULL
5645               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5646             return FALSE;
5647           break;
5648
5649         case R_PPC64_REL14:
5650         case R_PPC64_REL14_BRTAKEN:
5651         case R_PPC64_REL14_BRNTAKEN:
5652           {
5653             asection *dest = NULL;
5654
5655             /* Heuristic: If jumping outside our section, chances are
5656                we are going to need a stub.  */
5657             if (h != NULL)
5658               {
5659                 /* If the sym is weak it may be overridden later, so
5660                    don't assume we know where a weak sym lives.  */
5661                 if (h->root.type == bfd_link_hash_defined)
5662                   dest = h->root.u.def.section;
5663               }
5664             else
5665               {
5666                 Elf_Internal_Sym *isym;
5667
5668                 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5669                                               abfd, r_symndx);
5670                 if (isym == NULL)
5671                   return FALSE;
5672
5673                 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5674               }
5675
5676             if (dest != sec)
5677               ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5678           }
5679           /* Fall through.  */
5680
5681         case R_PPC64_REL24:
5682           plt_list = ifunc;
5683           if (h != NULL)
5684             {
5685               h->needs_plt = 1;
5686               if (h->root.root.string[0] == '.'
5687                   && h->root.root.string[1] != '\0')
5688                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5689
5690               if (h == tga || h == dottga)
5691                 {
5692                   sec->has_tls_reloc = 1;
5693                   if (rel != relocs
5694                       && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5695                           || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5696                     /* We have a new-style __tls_get_addr call with
5697                        a marker reloc.  */
5698                     ;
5699                   else
5700                     /* Mark this section as having an old-style call.  */
5701                     sec->has_tls_get_addr_call = 1;
5702                 }
5703               plt_list = &h->plt.plist;
5704             }
5705
5706           /* We may need a .plt entry if the function this reloc
5707              refers to is in a shared lib.  */
5708           if (plt_list
5709               && !update_plt_info (abfd, plt_list, rel->r_addend))
5710             return FALSE;
5711           break;
5712
5713         case R_PPC64_ADDR14:
5714         case R_PPC64_ADDR14_BRNTAKEN:
5715         case R_PPC64_ADDR14_BRTAKEN:
5716         case R_PPC64_ADDR24:
5717           goto dodyn;
5718
5719         case R_PPC64_TPREL64:
5720           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5721           if (bfd_link_pic (info))
5722             info->flags |= DF_STATIC_TLS;
5723           goto dotlstoc;
5724
5725         case R_PPC64_DTPMOD64:
5726           if (rel + 1 < rel_end
5727               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5728               && rel[1].r_offset == rel->r_offset + 8)
5729             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5730           else
5731             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5732           goto dotlstoc;
5733
5734         case R_PPC64_DTPREL64:
5735           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5736           if (rel != relocs
5737               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5738               && rel[-1].r_offset == rel->r_offset - 8)
5739             /* This is the second reloc of a dtpmod, dtprel pair.
5740                Don't mark with TLS_DTPREL.  */
5741             goto dodyn;
5742
5743         dotlstoc:
5744           sec->has_tls_reloc = 1;
5745           if (h != NULL)
5746             {
5747               struct ppc_link_hash_entry *eh;
5748               eh = (struct ppc_link_hash_entry *) h;
5749               eh->tls_mask |= tls_type;
5750             }
5751           else
5752             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5753                                         rel->r_addend, tls_type))
5754               return FALSE;
5755
5756           ppc64_sec = ppc64_elf_section_data (sec);
5757           if (ppc64_sec->sec_type != sec_toc)
5758             {
5759               bfd_size_type amt;
5760
5761               /* One extra to simplify get_tls_mask.  */
5762               amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5763               ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5764               if (ppc64_sec->u.toc.symndx == NULL)
5765                 return FALSE;
5766               amt = sec->size * sizeof (bfd_vma) / 8;
5767               ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5768               if (ppc64_sec->u.toc.add == NULL)
5769                 return FALSE;
5770               BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5771               ppc64_sec->sec_type = sec_toc;
5772             }
5773           BFD_ASSERT (rel->r_offset % 8 == 0);
5774           ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5775           ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5776
5777           /* Mark the second slot of a GD or LD entry.
5778              -1 to indicate GD and -2 to indicate LD.  */
5779           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5780             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5781           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5782             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5783           goto dodyn;
5784
5785         case R_PPC64_TPREL16:
5786         case R_PPC64_TPREL16_LO:
5787         case R_PPC64_TPREL16_HI:
5788         case R_PPC64_TPREL16_HA:
5789         case R_PPC64_TPREL16_DS:
5790         case R_PPC64_TPREL16_LO_DS:
5791         case R_PPC64_TPREL16_HIGH:
5792         case R_PPC64_TPREL16_HIGHA:
5793         case R_PPC64_TPREL16_HIGHER:
5794         case R_PPC64_TPREL16_HIGHERA:
5795         case R_PPC64_TPREL16_HIGHEST:
5796         case R_PPC64_TPREL16_HIGHESTA:
5797           if (bfd_link_pic (info))
5798             {
5799               info->flags |= DF_STATIC_TLS;
5800               goto dodyn;
5801             }
5802           break;
5803
5804         case R_PPC64_ADDR64:
5805           if (opd_sym_map != NULL
5806               && rel + 1 < rel_end
5807               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5808             {
5809               if (h != NULL)
5810                 {
5811                   if (h->root.root.string[0] == '.'
5812                       && h->root.root.string[1] != 0
5813                       && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
5814                     ;
5815                   else
5816                     ((struct ppc_link_hash_entry *) h)->is_func = 1;
5817                 }
5818               else
5819                 {
5820                   asection *s;
5821                   Elf_Internal_Sym *isym;
5822
5823                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5824                                                 abfd, r_symndx);
5825                   if (isym == NULL)
5826                     return FALSE;
5827
5828                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5829                   if (s != NULL && s != sec)
5830                     opd_sym_map[OPD_NDX (rel->r_offset)] = s;
5831                 }
5832             }
5833           /* Fall through.  */
5834
5835         case R_PPC64_ADDR16:
5836         case R_PPC64_ADDR16_DS:
5837         case R_PPC64_ADDR16_HA:
5838         case R_PPC64_ADDR16_HI:
5839         case R_PPC64_ADDR16_HIGH:
5840         case R_PPC64_ADDR16_HIGHA:
5841         case R_PPC64_ADDR16_HIGHER:
5842         case R_PPC64_ADDR16_HIGHERA:
5843         case R_PPC64_ADDR16_HIGHEST:
5844         case R_PPC64_ADDR16_HIGHESTA:
5845         case R_PPC64_ADDR16_LO:
5846         case R_PPC64_ADDR16_LO_DS:
5847           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1
5848               && rel->r_addend == 0)
5849             {
5850               /* We may need a .plt entry if this reloc refers to a
5851                  function in a shared lib.  */
5852               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5853                 return FALSE;
5854               h->pointer_equality_needed = 1;
5855             }
5856           /* Fall through.  */
5857
5858         case R_PPC64_REL30:
5859         case R_PPC64_REL32:
5860         case R_PPC64_REL64:
5861         case R_PPC64_ADDR32:
5862         case R_PPC64_UADDR16:
5863         case R_PPC64_UADDR32:
5864         case R_PPC64_UADDR64:
5865         case R_PPC64_TOC:
5866           if (h != NULL && !bfd_link_pic (info))
5867             /* We may need a copy reloc.  */
5868             h->non_got_ref = 1;
5869
5870           /* Don't propagate .opd relocs.  */
5871           if (NO_OPD_RELOCS && opd_sym_map != NULL)
5872             break;
5873
5874           /* If we are creating a shared library, and this is a reloc
5875              against a global symbol, or a non PC relative reloc
5876              against a local symbol, then we need to copy the reloc
5877              into the shared library.  However, if we are linking with
5878              -Bsymbolic, we do not need to copy a reloc against a
5879              global symbol which is defined in an object we are
5880              including in the link (i.e., DEF_REGULAR is set).  At
5881              this point we have not seen all the input files, so it is
5882              possible that DEF_REGULAR is not set now but will be set
5883              later (it is never cleared).  In case of a weak definition,
5884              DEF_REGULAR may be cleared later by a strong definition in
5885              a shared library.  We account for that possibility below by
5886              storing information in the dyn_relocs field of the hash
5887              table entry.  A similar situation occurs when creating
5888              shared libraries and symbol visibility changes render the
5889              symbol local.
5890
5891              If on the other hand, we are creating an executable, we
5892              may need to keep relocations for symbols satisfied by a
5893              dynamic library if we manage to avoid copy relocs for the
5894              symbol.  */
5895         dodyn:
5896           if ((bfd_link_pic (info)
5897                && (must_be_dyn_reloc (info, r_type)
5898                    || (h != NULL
5899                        && (!SYMBOLIC_BIND (info, h)
5900                            || h->root.type == bfd_link_hash_defweak
5901                            || !h->def_regular))))
5902               || (ELIMINATE_COPY_RELOCS
5903                   && !bfd_link_pic (info)
5904                   && h != NULL
5905                   && (h->root.type == bfd_link_hash_defweak
5906                       || !h->def_regular))
5907               || (!bfd_link_pic (info)
5908                   && ifunc != NULL))
5909             {
5910               /* We must copy these reloc types into the output file.
5911                  Create a reloc section in dynobj and make room for
5912                  this reloc.  */
5913               if (sreloc == NULL)
5914                 {
5915                   sreloc = _bfd_elf_make_dynamic_reloc_section
5916                     (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5917
5918                   if (sreloc == NULL)
5919                     return FALSE;
5920                 }
5921
5922               /* If this is a global symbol, we count the number of
5923                  relocations we need for this symbol.  */
5924               if (h != NULL)
5925                 {
5926                   struct elf_dyn_relocs *p;
5927                   struct elf_dyn_relocs **head;
5928
5929                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5930                   p = *head;
5931                   if (p == NULL || p->sec != sec)
5932                     {
5933                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5934                       if (p == NULL)
5935                         return FALSE;
5936                       p->next = *head;
5937                       *head = p;
5938                       p->sec = sec;
5939                       p->count = 0;
5940                       p->pc_count = 0;
5941                     }
5942                   p->count += 1;
5943                   if (!must_be_dyn_reloc (info, r_type))
5944                     p->pc_count += 1;
5945                 }
5946               else
5947                 {
5948                   /* Track dynamic relocs needed for local syms too.
5949                      We really need local syms available to do this
5950                      easily.  Oh well.  */
5951                   struct ppc_dyn_relocs *p;
5952                   struct ppc_dyn_relocs **head;
5953                   bfd_boolean is_ifunc;
5954                   asection *s;
5955                   void *vpp;
5956                   Elf_Internal_Sym *isym;
5957
5958                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5959                                                 abfd, r_symndx);
5960                   if (isym == NULL)
5961                     return FALSE;
5962
5963                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5964                   if (s == NULL)
5965                     s = sec;
5966
5967                   vpp = &elf_section_data (s)->local_dynrel;
5968                   head = (struct ppc_dyn_relocs **) vpp;
5969                   is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5970                   p = *head;
5971                   if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5972                     p = p->next;
5973                   if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5974                     {
5975                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5976                       if (p == NULL)
5977                         return FALSE;
5978                       p->next = *head;
5979                       *head = p;
5980                       p->sec = sec;
5981                       p->ifunc = is_ifunc;
5982                       p->count = 0;
5983                     }
5984                   p->count += 1;
5985                 }
5986             }
5987           break;
5988
5989         default:
5990           break;
5991         }
5992     }
5993
5994   return TRUE;
5995 }
5996
5997 /* Merge backend specific data from an object file to the output
5998    object file when linking.  */
5999
6000 static bfd_boolean
6001 ppc64_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
6002 {
6003   unsigned long iflags, oflags;
6004
6005   if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
6006     return TRUE;
6007
6008   if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
6009     return TRUE;
6010
6011   if (!_bfd_generic_verify_endian_match (ibfd, obfd))
6012     return FALSE;
6013
6014   iflags = elf_elfheader (ibfd)->e_flags;
6015   oflags = elf_elfheader (obfd)->e_flags;
6016
6017   if (iflags & ~EF_PPC64_ABI)
6018     {
6019       _bfd_error_handler
6020         (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
6021       bfd_set_error (bfd_error_bad_value);
6022       return FALSE;
6023     }
6024   else if (iflags != oflags && iflags != 0)
6025     {
6026       _bfd_error_handler
6027         (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
6028          ibfd, iflags, oflags);
6029       bfd_set_error (bfd_error_bad_value);
6030       return FALSE;
6031     }
6032
6033   _bfd_elf_ppc_merge_fp_attributes (ibfd, obfd);
6034
6035   /* Merge Tag_compatibility attributes and any common GNU ones.  */
6036   _bfd_elf_merge_object_attributes (ibfd, obfd);
6037
6038   return TRUE;
6039 }
6040
6041 static bfd_boolean
6042 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
6043 {
6044   /* Print normal ELF private data.  */
6045   _bfd_elf_print_private_bfd_data (abfd, ptr);
6046
6047   if (elf_elfheader (abfd)->e_flags != 0)
6048     {
6049       FILE *file = ptr;
6050
6051       /* xgettext:c-format */
6052       fprintf (file, _("private flags = 0x%lx:"),
6053                elf_elfheader (abfd)->e_flags);
6054
6055       if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
6056         fprintf (file, _(" [abiv%ld]"),
6057                  elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
6058       fputc ('\n', file);
6059     }
6060
6061   return TRUE;
6062 }
6063
6064 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
6065    of the code entry point, and its section, which must be in the same
6066    object as OPD_SEC.  Returns (bfd_vma) -1 on error.  */
6067
6068 static bfd_vma
6069 opd_entry_value (asection *opd_sec,
6070                  bfd_vma offset,
6071                  asection **code_sec,
6072                  bfd_vma *code_off,
6073                  bfd_boolean in_code_sec)
6074 {
6075   bfd *opd_bfd = opd_sec->owner;
6076   Elf_Internal_Rela *relocs;
6077   Elf_Internal_Rela *lo, *hi, *look;
6078   bfd_vma val;
6079
6080   /* No relocs implies we are linking a --just-symbols object, or looking
6081      at a final linked executable with addr2line or somesuch.  */
6082   if (opd_sec->reloc_count == 0)
6083     {
6084       bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
6085
6086       if (contents == NULL)
6087         {
6088           if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
6089             return (bfd_vma) -1;
6090           ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
6091         }
6092
6093       /* PR 17512: file: 64b9dfbb.  */
6094       if (offset + 7 >= opd_sec->size || offset + 7 < offset)
6095         return (bfd_vma) -1;
6096
6097       val = bfd_get_64 (opd_bfd, contents + offset);
6098       if (code_sec != NULL)
6099         {
6100           asection *sec, *likely = NULL;
6101
6102           if (in_code_sec)
6103             {
6104               sec = *code_sec;
6105               if (sec->vma <= val
6106                   && val < sec->vma + sec->size)
6107                 likely = sec;
6108               else
6109                 val = -1;
6110             }
6111           else
6112             for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
6113               if (sec->vma <= val
6114                   && (sec->flags & SEC_LOAD) != 0
6115                   && (sec->flags & SEC_ALLOC) != 0)
6116                 likely = sec;
6117           if (likely != NULL)
6118             {
6119               *code_sec = likely;
6120               if (code_off != NULL)
6121                 *code_off = val - likely->vma;
6122             }
6123         }
6124       return val;
6125     }
6126
6127   BFD_ASSERT (is_ppc64_elf (opd_bfd));
6128
6129   relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
6130   if (relocs == NULL)
6131     relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
6132   /* PR 17512: file: df8e1fd6.  */
6133   if (relocs == NULL)
6134     return (bfd_vma) -1;
6135
6136   /* Go find the opd reloc at the sym address.  */
6137   lo = relocs;
6138   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
6139   val = (bfd_vma) -1;
6140   while (lo < hi)
6141     {
6142       look = lo + (hi - lo) / 2;
6143       if (look->r_offset < offset)
6144         lo = look + 1;
6145       else if (look->r_offset > offset)
6146         hi = look;
6147       else
6148         {
6149           Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
6150
6151           if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
6152               && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
6153             {
6154               unsigned long symndx = ELF64_R_SYM (look->r_info);
6155               asection *sec = NULL;
6156
6157               if (symndx >= symtab_hdr->sh_info
6158                   && elf_sym_hashes (opd_bfd) != NULL)
6159                 {
6160                   struct elf_link_hash_entry **sym_hashes;
6161                   struct elf_link_hash_entry *rh;
6162
6163                   sym_hashes = elf_sym_hashes (opd_bfd);
6164                   rh = sym_hashes[symndx - symtab_hdr->sh_info];
6165                   if (rh != NULL)
6166                     {
6167                       rh = elf_follow_link (rh);
6168                       if (rh->root.type != bfd_link_hash_defined
6169                           && rh->root.type != bfd_link_hash_defweak)
6170                         break;
6171                       if (rh->root.u.def.section->owner == opd_bfd)
6172                         {
6173                           val = rh->root.u.def.value;
6174                           sec = rh->root.u.def.section;
6175                         }
6176                     }
6177                 }
6178
6179               if (sec == NULL)
6180                 {
6181                   Elf_Internal_Sym *sym;
6182
6183                   if (symndx < symtab_hdr->sh_info)
6184                     {
6185                       sym = (Elf_Internal_Sym *) symtab_hdr->contents;
6186                       if (sym == NULL)
6187                         {
6188                           size_t symcnt = symtab_hdr->sh_info;
6189                           sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6190                                                       symcnt, 0,
6191                                                       NULL, NULL, NULL);
6192                           if (sym == NULL)
6193                             break;
6194                           symtab_hdr->contents = (bfd_byte *) sym;
6195                         }
6196                       sym += symndx;
6197                     }
6198                   else
6199                     {
6200                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6201                                                   1, symndx,
6202                                                   NULL, NULL, NULL);
6203                       if (sym == NULL)
6204                         break;
6205                     }
6206                   sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6207                   if (sec == NULL)
6208                     break;
6209                   BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
6210                   val = sym->st_value;
6211                 }
6212
6213               val += look->r_addend;
6214               if (code_off != NULL)
6215                 *code_off = val;
6216               if (code_sec != NULL)
6217                 {
6218                   if (in_code_sec && *code_sec != sec)
6219                     return -1;
6220                   else
6221                     *code_sec = sec;
6222                 }
6223               if (sec->output_section != NULL)
6224                 val += sec->output_section->vma + sec->output_offset;
6225             }
6226           break;
6227         }
6228     }
6229
6230   return val;
6231 }
6232
6233 /* If the ELF symbol SYM might be a function in SEC, return the
6234    function size and set *CODE_OFF to the function's entry point,
6235    otherwise return zero.  */
6236
6237 static bfd_size_type
6238 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6239                               bfd_vma *code_off)
6240 {
6241   bfd_size_type size;
6242
6243   if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6244                      | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6245     return 0;
6246
6247   size = 0;
6248   if (!(sym->flags & BSF_SYNTHETIC))
6249     size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6250
6251   if (strcmp (sym->section->name, ".opd") == 0)
6252     {
6253       struct _opd_sec_data *opd = get_opd_info (sym->section);
6254       bfd_vma symval = sym->value;
6255
6256       if (opd != NULL
6257           && opd->adjust != NULL
6258           && elf_section_data (sym->section)->relocs != NULL)
6259         {
6260           /* opd_entry_value will use cached relocs that have been
6261              adjusted, but with raw symbols.  That means both local
6262              and global symbols need adjusting.  */
6263           long adjust = opd->adjust[OPD_NDX (symval)];
6264           if (adjust == -1)
6265             return 0;
6266           symval += adjust;
6267         }
6268
6269       if (opd_entry_value (sym->section, symval,
6270                            &sec, code_off, TRUE) == (bfd_vma) -1)
6271         return 0;
6272       /* An old ABI binary with dot-syms has a size of 24 on the .opd
6273          symbol.  This size has nothing to do with the code size of the
6274          function, which is what we're supposed to return, but the
6275          code size isn't available without looking up the dot-sym.
6276          However, doing that would be a waste of time particularly
6277          since elf_find_function will look at the dot-sym anyway.
6278          Now, elf_find_function will keep the largest size of any
6279          function sym found at the code address of interest, so return
6280          1 here to avoid it incorrectly caching a larger function size
6281          for a small function.  This does mean we return the wrong
6282          size for a new-ABI function of size 24, but all that does is
6283          disable caching for such functions.  */
6284       if (size == 24)
6285         size = 1;
6286     }
6287   else
6288     {
6289       if (sym->section != sec)
6290         return 0;
6291       *code_off = sym->value;
6292     }
6293   if (size == 0)
6294     size = 1;
6295   return size;
6296 }
6297
6298 /* Return true if symbol is defined in a regular object file.  */
6299
6300 static bfd_boolean
6301 is_static_defined (struct elf_link_hash_entry *h)
6302 {
6303   return ((h->root.type == bfd_link_hash_defined
6304            || h->root.type == bfd_link_hash_defweak)
6305           && h->root.u.def.section != NULL
6306           && h->root.u.def.section->output_section != NULL);
6307 }
6308
6309 /* If FDH is a function descriptor symbol, return the associated code
6310    entry symbol if it is defined.  Return NULL otherwise.  */
6311
6312 static struct ppc_link_hash_entry *
6313 defined_code_entry (struct ppc_link_hash_entry *fdh)
6314 {
6315   if (fdh->is_func_descriptor)
6316     {
6317       struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6318       if (fh->elf.root.type == bfd_link_hash_defined
6319           || fh->elf.root.type == bfd_link_hash_defweak)
6320         return fh;
6321     }
6322   return NULL;
6323 }
6324
6325 /* If FH is a function code entry symbol, return the associated
6326    function descriptor symbol if it is defined.  Return NULL otherwise.  */
6327
6328 static struct ppc_link_hash_entry *
6329 defined_func_desc (struct ppc_link_hash_entry *fh)
6330 {
6331   if (fh->oh != NULL
6332       && fh->oh->is_func_descriptor)
6333     {
6334       struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6335       if (fdh->elf.root.type == bfd_link_hash_defined
6336           || fdh->elf.root.type == bfd_link_hash_defweak)
6337         return fdh;
6338     }
6339   return NULL;
6340 }
6341
6342 /* Mark all our entry sym sections, both opd and code section.  */
6343
6344 static void
6345 ppc64_elf_gc_keep (struct bfd_link_info *info)
6346 {
6347   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6348   struct bfd_sym_chain *sym;
6349
6350   if (htab == NULL)
6351     return;
6352
6353   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6354     {
6355       struct ppc_link_hash_entry *eh, *fh;
6356       asection *sec;
6357
6358       eh = (struct ppc_link_hash_entry *)
6359         elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6360       if (eh == NULL)
6361         continue;
6362       if (eh->elf.root.type != bfd_link_hash_defined
6363           && eh->elf.root.type != bfd_link_hash_defweak)
6364         continue;
6365
6366       fh = defined_code_entry (eh);
6367       if (fh != NULL)
6368         {
6369           sec = fh->elf.root.u.def.section;
6370           sec->flags |= SEC_KEEP;
6371         }
6372       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6373                && opd_entry_value (eh->elf.root.u.def.section,
6374                                    eh->elf.root.u.def.value,
6375                                    &sec, NULL, FALSE) != (bfd_vma) -1)
6376         sec->flags |= SEC_KEEP;
6377
6378       sec = eh->elf.root.u.def.section;
6379       sec->flags |= SEC_KEEP;
6380     }
6381 }
6382
6383 /* Mark sections containing dynamically referenced symbols.  When
6384    building shared libraries, we must assume that any visible symbol is
6385    referenced.  */
6386
6387 static bfd_boolean
6388 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6389 {
6390   struct bfd_link_info *info = (struct bfd_link_info *) inf;
6391   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6392   struct ppc_link_hash_entry *fdh;
6393   struct bfd_elf_dynamic_list *d = info->dynamic_list;
6394
6395   /* Dynamic linking info is on the func descriptor sym.  */
6396   fdh = defined_func_desc (eh);
6397   if (fdh != NULL)
6398     eh = fdh;
6399
6400   if ((eh->elf.root.type == bfd_link_hash_defined
6401        || eh->elf.root.type == bfd_link_hash_defweak)
6402       && (eh->elf.ref_dynamic
6403           || ((eh->elf.def_regular || ELF_COMMON_DEF_P (&eh->elf))
6404               && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6405               && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6406               && (!bfd_link_executable (info)
6407                   || info->export_dynamic
6408                   || (eh->elf.dynamic
6409                       && d != NULL
6410                       && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
6411               && (strchr (eh->elf.root.root.string, ELF_VER_CHR) != NULL
6412                   || !bfd_hide_sym_by_version (info->version_info,
6413                                                eh->elf.root.root.string)))))
6414     {
6415       asection *code_sec;
6416       struct ppc_link_hash_entry *fh;
6417
6418       eh->elf.root.u.def.section->flags |= SEC_KEEP;
6419
6420       /* Function descriptor syms cause the associated
6421          function code sym section to be marked.  */
6422       fh = defined_code_entry (eh);
6423       if (fh != NULL)
6424         {
6425           code_sec = fh->elf.root.u.def.section;
6426           code_sec->flags |= SEC_KEEP;
6427         }
6428       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6429                && opd_entry_value (eh->elf.root.u.def.section,
6430                                    eh->elf.root.u.def.value,
6431                                    &code_sec, NULL, FALSE) != (bfd_vma) -1)
6432         code_sec->flags |= SEC_KEEP;
6433     }
6434
6435   return TRUE;
6436 }
6437
6438 /* Return the section that should be marked against GC for a given
6439    relocation.  */
6440
6441 static asection *
6442 ppc64_elf_gc_mark_hook (asection *sec,
6443                         struct bfd_link_info *info,
6444                         Elf_Internal_Rela *rel,
6445                         struct elf_link_hash_entry *h,
6446                         Elf_Internal_Sym *sym)
6447 {
6448   asection *rsec;
6449
6450   /* Syms return NULL if we're marking .opd, so we avoid marking all
6451      function sections, as all functions are referenced in .opd.  */
6452   rsec = NULL;
6453   if (get_opd_info (sec) != NULL)
6454     return rsec;
6455
6456   if (h != NULL)
6457     {
6458       enum elf_ppc64_reloc_type r_type;
6459       struct ppc_link_hash_entry *eh, *fh, *fdh;
6460
6461       r_type = ELF64_R_TYPE (rel->r_info);
6462       switch (r_type)
6463         {
6464         case R_PPC64_GNU_VTINHERIT:
6465         case R_PPC64_GNU_VTENTRY:
6466           break;
6467
6468         default:
6469           switch (h->root.type)
6470             {
6471             case bfd_link_hash_defined:
6472             case bfd_link_hash_defweak:
6473               eh = (struct ppc_link_hash_entry *) h;
6474               fdh = defined_func_desc (eh);
6475               if (fdh != NULL)
6476                 eh = fdh;
6477
6478               /* Function descriptor syms cause the associated
6479                  function code sym section to be marked.  */
6480               fh = defined_code_entry (eh);
6481               if (fh != NULL)
6482                 {
6483                   /* They also mark their opd section.  */
6484                   eh->elf.root.u.def.section->gc_mark = 1;
6485
6486                   rsec = fh->elf.root.u.def.section;
6487                 }
6488               else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6489                        && opd_entry_value (eh->elf.root.u.def.section,
6490                                            eh->elf.root.u.def.value,
6491                                            &rsec, NULL, FALSE) != (bfd_vma) -1)
6492                 eh->elf.root.u.def.section->gc_mark = 1;
6493               else
6494                 rsec = h->root.u.def.section;
6495               break;
6496
6497             case bfd_link_hash_common:
6498               rsec = h->root.u.c.p->section;
6499               break;
6500
6501             default:
6502               return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6503             }
6504         }
6505     }
6506   else
6507     {
6508       struct _opd_sec_data *opd;
6509
6510       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6511       opd = get_opd_info (rsec);
6512       if (opd != NULL && opd->func_sec != NULL)
6513         {
6514           rsec->gc_mark = 1;
6515
6516           rsec = opd->func_sec[OPD_NDX (sym->st_value + rel->r_addend)];
6517         }
6518     }
6519
6520   return rsec;
6521 }
6522
6523 /* Update the .got, .plt. and dynamic reloc reference counts for the
6524    section being removed.  */
6525
6526 static bfd_boolean
6527 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
6528                          asection *sec, const Elf_Internal_Rela *relocs)
6529 {
6530   struct ppc_link_hash_table *htab;
6531   Elf_Internal_Shdr *symtab_hdr;
6532   struct elf_link_hash_entry **sym_hashes;
6533   struct got_entry **local_got_ents;
6534   const Elf_Internal_Rela *rel, *relend;
6535
6536   if (bfd_link_relocatable (info))
6537     return TRUE;
6538
6539   if ((sec->flags & SEC_ALLOC) == 0)
6540     return TRUE;
6541
6542   elf_section_data (sec)->local_dynrel = NULL;
6543
6544   htab = ppc_hash_table (info);
6545   if (htab == NULL)
6546     return FALSE;
6547
6548   symtab_hdr = &elf_symtab_hdr (abfd);
6549   sym_hashes = elf_sym_hashes (abfd);
6550   local_got_ents = elf_local_got_ents (abfd);
6551
6552   relend = relocs + sec->reloc_count;
6553   for (rel = relocs; rel < relend; rel++)
6554     {
6555       unsigned long r_symndx;
6556       enum elf_ppc64_reloc_type r_type;
6557       struct elf_link_hash_entry *h = NULL;
6558       struct plt_entry **plt_list;
6559       unsigned char tls_type = 0;
6560
6561       r_symndx = ELF64_R_SYM (rel->r_info);
6562       r_type = ELF64_R_TYPE (rel->r_info);
6563       if (r_symndx >= symtab_hdr->sh_info)
6564         {
6565           struct ppc_link_hash_entry *eh;
6566           struct elf_dyn_relocs **pp;
6567           struct elf_dyn_relocs *p;
6568
6569           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6570           h = elf_follow_link (h);
6571           eh = (struct ppc_link_hash_entry *) h;
6572
6573           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6574             if (p->sec == sec)
6575               {
6576                 /* Everything must go for SEC.  */
6577                 *pp = p->next;
6578                 break;
6579               }
6580         }
6581
6582       switch (r_type)
6583         {
6584         case R_PPC64_GOT_TLSLD16:
6585         case R_PPC64_GOT_TLSLD16_LO:
6586         case R_PPC64_GOT_TLSLD16_HI:
6587         case R_PPC64_GOT_TLSLD16_HA:
6588           tls_type = TLS_TLS | TLS_LD;
6589           goto dogot;
6590
6591         case R_PPC64_GOT_TLSGD16:
6592         case R_PPC64_GOT_TLSGD16_LO:
6593         case R_PPC64_GOT_TLSGD16_HI:
6594         case R_PPC64_GOT_TLSGD16_HA:
6595           tls_type = TLS_TLS | TLS_GD;
6596           goto dogot;
6597
6598         case R_PPC64_GOT_TPREL16_DS:
6599         case R_PPC64_GOT_TPREL16_LO_DS:
6600         case R_PPC64_GOT_TPREL16_HI:
6601         case R_PPC64_GOT_TPREL16_HA:
6602           tls_type = TLS_TLS | TLS_TPREL;
6603           goto dogot;
6604
6605         case R_PPC64_GOT_DTPREL16_DS:
6606         case R_PPC64_GOT_DTPREL16_LO_DS:
6607         case R_PPC64_GOT_DTPREL16_HI:
6608         case R_PPC64_GOT_DTPREL16_HA:
6609           tls_type = TLS_TLS | TLS_DTPREL;
6610           goto dogot;
6611
6612         case R_PPC64_GOT16:
6613         case R_PPC64_GOT16_DS:
6614         case R_PPC64_GOT16_HA:
6615         case R_PPC64_GOT16_HI:
6616         case R_PPC64_GOT16_LO:
6617         case R_PPC64_GOT16_LO_DS:
6618         dogot:
6619           {
6620             struct got_entry *ent;
6621
6622             if (h != NULL)
6623               ent = h->got.glist;
6624             else
6625               ent = local_got_ents[r_symndx];
6626
6627             for (; ent != NULL; ent = ent->next)
6628               if (ent->addend == rel->r_addend
6629                   && ent->owner == abfd
6630                   && ent->tls_type == tls_type)
6631                 break;
6632             if (ent == NULL)
6633               abort ();
6634             if (ent->got.refcount > 0)
6635               ent->got.refcount -= 1;
6636           }
6637           break;
6638
6639         case R_PPC64_PLT16_HA:
6640         case R_PPC64_PLT16_HI:
6641         case R_PPC64_PLT16_LO:
6642         case R_PPC64_PLT32:
6643         case R_PPC64_PLT64:
6644         case R_PPC64_REL14:
6645         case R_PPC64_REL14_BRNTAKEN:
6646         case R_PPC64_REL14_BRTAKEN:
6647         case R_PPC64_REL24:
6648           plt_list = NULL;
6649           if (h != NULL)
6650             plt_list = &h->plt.plist;
6651           else if (local_got_ents != NULL)
6652             {
6653               struct plt_entry **local_plt = (struct plt_entry **)
6654                 (local_got_ents + symtab_hdr->sh_info);
6655               unsigned char *local_got_tls_masks = (unsigned char *)
6656                 (local_plt + symtab_hdr->sh_info);
6657               if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6658                 plt_list = local_plt + r_symndx;
6659             }
6660           if (plt_list)
6661             {
6662               struct plt_entry *ent;
6663
6664               for (ent = *plt_list; ent != NULL; ent = ent->next)
6665                 if (ent->addend == rel->r_addend)
6666                   break;
6667               if (ent != NULL && ent->plt.refcount > 0)
6668                 ent->plt.refcount -= 1;
6669             }
6670           break;
6671
6672         default:
6673           break;
6674         }
6675     }
6676   return TRUE;
6677 }
6678
6679 /* The maximum size of .sfpr.  */
6680 #define SFPR_MAX (218*4)
6681
6682 struct sfpr_def_parms
6683 {
6684   const char name[12];
6685   unsigned char lo, hi;
6686   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6687   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6688 };
6689
6690 /* Auto-generate _save*, _rest* functions in .sfpr.
6691    If STUB_SEC is non-null, define alias symbols in STUB_SEC
6692    instead.  */
6693
6694 static bfd_boolean
6695 sfpr_define (struct bfd_link_info *info,
6696              const struct sfpr_def_parms *parm,
6697              asection *stub_sec)
6698 {
6699   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6700   unsigned int i;
6701   size_t len = strlen (parm->name);
6702   bfd_boolean writing = FALSE;
6703   char sym[16];
6704
6705   if (htab == NULL)
6706     return FALSE;
6707
6708   memcpy (sym, parm->name, len);
6709   sym[len + 2] = 0;
6710
6711   for (i = parm->lo; i <= parm->hi; i++)
6712     {
6713       struct ppc_link_hash_entry *h;
6714
6715       sym[len + 0] = i / 10 + '0';
6716       sym[len + 1] = i % 10 + '0';
6717       h = (struct ppc_link_hash_entry *)
6718         elf_link_hash_lookup (&htab->elf, sym, writing, TRUE, TRUE);
6719       if (stub_sec != NULL)
6720         {
6721           if (h != NULL
6722               && h->elf.root.type == bfd_link_hash_defined
6723               && h->elf.root.u.def.section == htab->sfpr)
6724             {
6725               struct elf_link_hash_entry *s;
6726               char buf[32];
6727               sprintf (buf, "%08x.%s", stub_sec->id & 0xffffffff, sym);
6728               s = elf_link_hash_lookup (&htab->elf, buf, TRUE, TRUE, FALSE);
6729               if (s == NULL)
6730                 return FALSE;
6731               if (s->root.type == bfd_link_hash_new
6732                   || (s->root.type = bfd_link_hash_defined
6733                       && s->root.u.def.section == stub_sec))
6734                 {
6735                   s->root.type = bfd_link_hash_defined;
6736                   s->root.u.def.section = stub_sec;
6737                   s->root.u.def.value = (stub_sec->size
6738                                          + h->elf.root.u.def.value);
6739                   s->ref_regular = 1;
6740                   s->def_regular = 1;
6741                   s->ref_regular_nonweak = 1;
6742                   s->forced_local = 1;
6743                   s->non_elf = 0;
6744                   s->root.linker_def = 1;
6745                 }
6746             }
6747           continue;
6748         }
6749       if (h != NULL)
6750         {
6751           h->save_res = 1;
6752           if (!h->elf.def_regular)
6753             {
6754               h->elf.root.type = bfd_link_hash_defined;
6755               h->elf.root.u.def.section = htab->sfpr;
6756               h->elf.root.u.def.value = htab->sfpr->size;
6757               h->elf.type = STT_FUNC;
6758               h->elf.def_regular = 1;
6759               h->elf.non_elf = 0;
6760               _bfd_elf_link_hash_hide_symbol (info, &h->elf, TRUE);
6761               writing = TRUE;
6762               if (htab->sfpr->contents == NULL)
6763                 {
6764                   htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6765                   if (htab->sfpr->contents == NULL)
6766                     return FALSE;
6767                 }
6768             }
6769         }
6770       if (writing)
6771         {
6772           bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6773           if (i != parm->hi)
6774             p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6775           else
6776             p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6777           htab->sfpr->size = p - htab->sfpr->contents;
6778         }
6779     }
6780
6781   return TRUE;
6782 }
6783
6784 static bfd_byte *
6785 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6786 {
6787   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6788   return p + 4;
6789 }
6790
6791 static bfd_byte *
6792 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6793 {
6794   p = savegpr0 (abfd, p, r);
6795   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6796   p = p + 4;
6797   bfd_put_32 (abfd, BLR, p);
6798   return p + 4;
6799 }
6800
6801 static bfd_byte *
6802 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6803 {
6804   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6805   return p + 4;
6806 }
6807
6808 static bfd_byte *
6809 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6810 {
6811   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6812   p = p + 4;
6813   p = restgpr0 (abfd, p, r);
6814   bfd_put_32 (abfd, MTLR_R0, p);
6815   p = p + 4;
6816   if (r == 29)
6817     {
6818       p = restgpr0 (abfd, p, 30);
6819       p = restgpr0 (abfd, p, 31);
6820     }
6821   bfd_put_32 (abfd, BLR, p);
6822   return p + 4;
6823 }
6824
6825 static bfd_byte *
6826 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6827 {
6828   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6829   return p + 4;
6830 }
6831
6832 static bfd_byte *
6833 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6834 {
6835   p = savegpr1 (abfd, p, r);
6836   bfd_put_32 (abfd, BLR, p);
6837   return p + 4;
6838 }
6839
6840 static bfd_byte *
6841 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6842 {
6843   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6844   return p + 4;
6845 }
6846
6847 static bfd_byte *
6848 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6849 {
6850   p = restgpr1 (abfd, p, r);
6851   bfd_put_32 (abfd, BLR, p);
6852   return p + 4;
6853 }
6854
6855 static bfd_byte *
6856 savefpr (bfd *abfd, bfd_byte *p, int r)
6857 {
6858   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6859   return p + 4;
6860 }
6861
6862 static bfd_byte *
6863 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6864 {
6865   p = savefpr (abfd, p, r);
6866   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6867   p = p + 4;
6868   bfd_put_32 (abfd, BLR, p);
6869   return p + 4;
6870 }
6871
6872 static bfd_byte *
6873 restfpr (bfd *abfd, bfd_byte *p, int r)
6874 {
6875   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6876   return p + 4;
6877 }
6878
6879 static bfd_byte *
6880 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6881 {
6882   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6883   p = p + 4;
6884   p = restfpr (abfd, p, r);
6885   bfd_put_32 (abfd, MTLR_R0, p);
6886   p = p + 4;
6887   if (r == 29)
6888     {
6889       p = restfpr (abfd, p, 30);
6890       p = restfpr (abfd, p, 31);
6891     }
6892   bfd_put_32 (abfd, BLR, p);
6893   return p + 4;
6894 }
6895
6896 static bfd_byte *
6897 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6898 {
6899   p = savefpr (abfd, p, r);
6900   bfd_put_32 (abfd, BLR, p);
6901   return p + 4;
6902 }
6903
6904 static bfd_byte *
6905 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6906 {
6907   p = restfpr (abfd, p, r);
6908   bfd_put_32 (abfd, BLR, p);
6909   return p + 4;
6910 }
6911
6912 static bfd_byte *
6913 savevr (bfd *abfd, bfd_byte *p, int r)
6914 {
6915   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6916   p = p + 4;
6917   bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6918   return p + 4;
6919 }
6920
6921 static bfd_byte *
6922 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6923 {
6924   p = savevr (abfd, p, r);
6925   bfd_put_32 (abfd, BLR, p);
6926   return p + 4;
6927 }
6928
6929 static bfd_byte *
6930 restvr (bfd *abfd, bfd_byte *p, int r)
6931 {
6932   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6933   p = p + 4;
6934   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6935   return p + 4;
6936 }
6937
6938 static bfd_byte *
6939 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6940 {
6941   p = restvr (abfd, p, r);
6942   bfd_put_32 (abfd, BLR, p);
6943   return p + 4;
6944 }
6945
6946 /* Called via elf_link_hash_traverse to transfer dynamic linking
6947    information on function code symbol entries to their corresponding
6948    function descriptor symbol entries.  */
6949
6950 static bfd_boolean
6951 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6952 {
6953   struct bfd_link_info *info;
6954   struct ppc_link_hash_table *htab;
6955   struct plt_entry *ent;
6956   struct ppc_link_hash_entry *fh;
6957   struct ppc_link_hash_entry *fdh;
6958   bfd_boolean force_local;
6959
6960   fh = (struct ppc_link_hash_entry *) h;
6961   if (fh->elf.root.type == bfd_link_hash_indirect)
6962     return TRUE;
6963
6964   info = inf;
6965   htab = ppc_hash_table (info);
6966   if (htab == NULL)
6967     return FALSE;
6968
6969   /* Resolve undefined references to dot-symbols as the value
6970      in the function descriptor, if we have one in a regular object.
6971      This is to satisfy cases like ".quad .foo".  Calls to functions
6972      in dynamic objects are handled elsewhere.  */
6973   if (fh->elf.root.type == bfd_link_hash_undefweak
6974       && fh->was_undefined
6975       && (fdh = defined_func_desc (fh)) != NULL
6976       && get_opd_info (fdh->elf.root.u.def.section) != NULL
6977       && opd_entry_value (fdh->elf.root.u.def.section,
6978                           fdh->elf.root.u.def.value,
6979                           &fh->elf.root.u.def.section,
6980                           &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
6981     {
6982       fh->elf.root.type = fdh->elf.root.type;
6983       fh->elf.forced_local = 1;
6984       fh->elf.def_regular = fdh->elf.def_regular;
6985       fh->elf.def_dynamic = fdh->elf.def_dynamic;
6986     }
6987
6988   /* If this is a function code symbol, transfer dynamic linking
6989      information to the function descriptor symbol.  */
6990   if (!fh->is_func)
6991     return TRUE;
6992
6993   for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6994     if (ent->plt.refcount > 0)
6995       break;
6996   if (ent == NULL
6997       || fh->elf.root.root.string[0] != '.'
6998       || fh->elf.root.root.string[1] == '\0')
6999     return TRUE;
7000
7001   /* Find the corresponding function descriptor symbol.  Create it
7002      as undefined if necessary.  */
7003
7004   fdh = lookup_fdh (fh, htab);
7005   if (fdh == NULL
7006       && !bfd_link_executable (info)
7007       && (fh->elf.root.type == bfd_link_hash_undefined
7008           || fh->elf.root.type == bfd_link_hash_undefweak))
7009     {
7010       fdh = make_fdh (info, fh);
7011       if (fdh == NULL)
7012         return FALSE;
7013     }
7014
7015   /* Fake function descriptors are made undefweak.  If the function
7016      code symbol is strong undefined, make the fake sym the same.
7017      If the function code symbol is defined, then force the fake
7018      descriptor local;  We can't support overriding of symbols in a
7019      shared library on a fake descriptor.  */
7020
7021   if (fdh != NULL
7022       && fdh->fake
7023       && fdh->elf.root.type == bfd_link_hash_undefweak)
7024     {
7025       if (fh->elf.root.type == bfd_link_hash_undefined)
7026         {
7027           fdh->elf.root.type = bfd_link_hash_undefined;
7028           bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
7029         }
7030       else if (fh->elf.root.type == bfd_link_hash_defined
7031                || fh->elf.root.type == bfd_link_hash_defweak)
7032         {
7033           _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
7034         }
7035     }
7036
7037   if (fdh != NULL
7038       && !fdh->elf.forced_local
7039       && (!bfd_link_executable (info)
7040           || fdh->elf.def_dynamic
7041           || fdh->elf.ref_dynamic
7042           || (fdh->elf.root.type == bfd_link_hash_undefweak
7043               && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
7044     {
7045       if (fdh->elf.dynindx == -1)
7046         if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
7047           return FALSE;
7048       fdh->elf.ref_regular |= fh->elf.ref_regular;
7049       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
7050       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
7051       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
7052       if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
7053         {
7054           move_plt_plist (fh, fdh);
7055           fdh->elf.needs_plt = 1;
7056         }
7057       fdh->is_func_descriptor = 1;
7058       fdh->oh = fh;
7059       fh->oh = fdh;
7060     }
7061
7062   /* Now that the info is on the function descriptor, clear the
7063      function code sym info.  Any function code syms for which we
7064      don't have a definition in a regular file, we force local.
7065      This prevents a shared library from exporting syms that have
7066      been imported from another library.  Function code syms that
7067      are really in the library we must leave global to prevent the
7068      linker dragging in a definition from a static library.  */
7069   force_local = (!fh->elf.def_regular
7070                  || fdh == NULL
7071                  || !fdh->elf.def_regular
7072                  || fdh->elf.forced_local);
7073   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7074
7075   return TRUE;
7076 }
7077
7078 static const struct sfpr_def_parms save_res_funcs[] =
7079   {
7080     { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
7081     { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
7082     { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
7083     { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
7084     { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
7085     { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
7086     { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
7087     { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
7088     { "._savef", 14, 31, savefpr, savefpr1_tail },
7089     { "._restf", 14, 31, restfpr, restfpr1_tail },
7090     { "_savevr_", 20, 31, savevr, savevr_tail },
7091     { "_restvr_", 20, 31, restvr, restvr_tail }
7092   };
7093
7094 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
7095    this hook to a) provide some gcc support functions, and b) transfer
7096    dynamic linking information gathered so far on function code symbol
7097    entries, to their corresponding function descriptor symbol entries.  */
7098
7099 static bfd_boolean
7100 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
7101                             struct bfd_link_info *info)
7102 {
7103   struct ppc_link_hash_table *htab;
7104
7105   htab = ppc_hash_table (info);
7106   if (htab == NULL)
7107     return FALSE;
7108
7109   /* Provide any missing _save* and _rest* functions.  */
7110   if (htab->sfpr != NULL)
7111     {
7112       unsigned int i;
7113
7114       htab->sfpr->size = 0;
7115       for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
7116         if (!sfpr_define (info, &save_res_funcs[i], NULL))
7117           return FALSE;
7118       if (htab->sfpr->size == 0)
7119         htab->sfpr->flags |= SEC_EXCLUDE;
7120     }
7121
7122   if (bfd_link_relocatable (info))
7123     return TRUE;
7124
7125   if (htab->elf.hgot != NULL)
7126     {
7127       _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
7128       /* Make .TOC. defined so as to prevent it being made dynamic.
7129          The wrong value here is fixed later in ppc64_elf_set_toc.  */
7130       if (!htab->elf.hgot->def_regular
7131           || htab->elf.hgot->root.type != bfd_link_hash_defined)
7132         {
7133           htab->elf.hgot->root.type = bfd_link_hash_defined;
7134           htab->elf.hgot->root.u.def.value = 0;
7135           htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
7136           htab->elf.hgot->def_regular = 1;
7137           htab->elf.hgot->root.linker_def = 1;
7138         }
7139       htab->elf.hgot->type = STT_OBJECT;
7140       htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
7141                                | STV_HIDDEN);
7142     }
7143
7144   elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
7145
7146   return TRUE;
7147 }
7148
7149 /* Return true if we have dynamic relocs against H that apply to
7150    read-only sections.  */
7151
7152 static bfd_boolean
7153 readonly_dynrelocs (struct elf_link_hash_entry *h)
7154 {
7155   struct ppc_link_hash_entry *eh;
7156   struct elf_dyn_relocs *p;
7157
7158   eh = (struct ppc_link_hash_entry *) h;
7159   for (p = eh->dyn_relocs; p != NULL; p = p->next)
7160     {
7161       asection *s = p->sec->output_section;
7162
7163       if (s != NULL && (s->flags & SEC_READONLY) != 0)
7164         return TRUE;
7165     }
7166   return FALSE;
7167 }
7168
7169 /* Return true if we have dynamic relocs against H or any of its weak
7170    aliases, that apply to read-only sections.  */
7171
7172 static bfd_boolean
7173 alias_readonly_dynrelocs (struct elf_link_hash_entry *h)
7174 {
7175   struct ppc_link_hash_entry *eh;
7176
7177   eh = (struct ppc_link_hash_entry *) h;
7178   do
7179     {
7180       if (readonly_dynrelocs (&eh->elf))
7181         return TRUE;
7182       eh = eh->weakref;
7183     } while (eh != NULL && &eh->elf != h);
7184
7185   return FALSE;
7186 }
7187
7188 /* Return whether EH has pc-relative dynamic relocs.  */
7189
7190 static bfd_boolean
7191 pc_dynrelocs (struct ppc_link_hash_entry *eh)
7192 {
7193   struct elf_dyn_relocs *p;
7194
7195   for (p = eh->dyn_relocs; p != NULL; p = p->next)
7196     if (p->pc_count != 0)
7197       return TRUE;
7198   return FALSE;
7199 }
7200
7201 /* Return true if a global entry stub will be created for H.  Valid
7202    for ELFv2 before plt entries have been allocated.  */
7203
7204 static bfd_boolean
7205 global_entry_stub (struct elf_link_hash_entry *h)
7206 {
7207   struct plt_entry *pent;
7208
7209   if (!h->pointer_equality_needed
7210       || h->def_regular)
7211     return FALSE;
7212
7213   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
7214     if (pent->plt.refcount > 0
7215         && pent->addend == 0)
7216       return TRUE;
7217
7218   return FALSE;
7219 }
7220
7221 /* Adjust a symbol defined by a dynamic object and referenced by a
7222    regular object.  The current definition is in some section of the
7223    dynamic object, but we're not including those sections.  We have to
7224    change the definition to something the rest of the link can
7225    understand.  */
7226
7227 static bfd_boolean
7228 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
7229                                  struct elf_link_hash_entry *h)
7230 {
7231   struct ppc_link_hash_table *htab;
7232   asection *s;
7233
7234   htab = ppc_hash_table (info);
7235   if (htab == NULL)
7236     return FALSE;
7237
7238   /* Deal with function syms.  */
7239   if (h->type == STT_FUNC
7240       || h->type == STT_GNU_IFUNC
7241       || h->needs_plt)
7242     {
7243       /* Clear procedure linkage table information for any symbol that
7244          won't need a .plt entry.  */
7245       struct plt_entry *ent;
7246       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
7247         if (ent->plt.refcount > 0)
7248           break;
7249       if (ent == NULL
7250           || (h->type != STT_GNU_IFUNC
7251               && (SYMBOL_CALLS_LOCAL (info, h)
7252                   || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
7253                       && h->root.type == bfd_link_hash_undefweak)))
7254           || ((struct ppc_link_hash_entry *) h)->save_res)
7255         {
7256           h->plt.plist = NULL;
7257           h->needs_plt = 0;
7258           h->pointer_equality_needed = 0;
7259         }
7260       else if (abiversion (info->output_bfd) >= 2)
7261         {
7262           /* Taking a function's address in a read/write section
7263              doesn't require us to define the function symbol in the
7264              executable on a global entry stub.  A dynamic reloc can
7265              be used instead.  The reason we prefer a few more dynamic
7266              relocs is that calling via a global entry stub costs a
7267              few more instructions, and pointer_equality_needed causes
7268              extra work in ld.so when resolving these symbols.  */
7269           if (global_entry_stub (h)
7270               && !alias_readonly_dynrelocs (h))
7271             {
7272               h->pointer_equality_needed = 0;
7273               /* After adjust_dynamic_symbol, non_got_ref set in
7274                  the non-pic case means that dyn_relocs for this
7275                  symbol should be discarded.  */
7276               h->non_got_ref = 0;
7277             }
7278
7279           /* If making a plt entry, then we don't need copy relocs.  */
7280           return TRUE;
7281         }
7282     }
7283   else
7284     h->plt.plist = NULL;
7285
7286   /* If this is a weak symbol, and there is a real definition, the
7287      processor independent code will have arranged for us to see the
7288      real definition first, and we can just use the same value.  */
7289   if (h->u.weakdef != NULL)
7290     {
7291       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
7292                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
7293       h->root.u.def.section = h->u.weakdef->root.u.def.section;
7294       h->root.u.def.value = h->u.weakdef->root.u.def.value;
7295       if (ELIMINATE_COPY_RELOCS)
7296         h->non_got_ref = h->u.weakdef->non_got_ref;
7297       return TRUE;
7298     }
7299
7300   /* If we are creating a shared library, we must presume that the
7301      only references to the symbol are via the global offset table.
7302      For such cases we need not do anything here; the relocations will
7303      be handled correctly by relocate_section.  */
7304   if (bfd_link_pic (info))
7305     return TRUE;
7306
7307   /* If there are no references to this symbol that do not use the
7308      GOT, we don't need to generate a copy reloc.  */
7309   if (!h->non_got_ref)
7310     return TRUE;
7311
7312   /* Don't generate a copy reloc for symbols defined in the executable.  */
7313   if (!h->def_dynamic || !h->ref_regular || h->def_regular
7314
7315       /* If -z nocopyreloc was given, don't generate them either.  */
7316       || info->nocopyreloc
7317
7318       /* If we didn't find any dynamic relocs in read-only sections, then
7319          we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
7320       || (ELIMINATE_COPY_RELOCS && !alias_readonly_dynrelocs (h))
7321
7322       /* Protected variables do not work with .dynbss.  The copy in
7323          .dynbss won't be used by the shared library with the protected
7324          definition for the variable.  Text relocations are preferable
7325          to an incorrect program.  */
7326       || h->protected_def)
7327     {
7328       h->non_got_ref = 0;
7329       return TRUE;
7330     }
7331
7332   if (h->plt.plist != NULL)
7333     {
7334       /* We should never get here, but unfortunately there are versions
7335          of gcc out there that improperly (for this ABI) put initialized
7336          function pointers, vtable refs and suchlike in read-only
7337          sections.  Allow them to proceed, but warn that this might
7338          break at runtime.  */
7339       info->callbacks->einfo
7340         (_("%P: copy reloc against `%T' requires lazy plt linking; "
7341            "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7342          h->root.root.string);
7343     }
7344
7345   /* This is a reference to a symbol defined by a dynamic object which
7346      is not a function.  */
7347
7348   /* We must allocate the symbol in our .dynbss section, which will
7349      become part of the .bss section of the executable.  There will be
7350      an entry for this symbol in the .dynsym section.  The dynamic
7351      object will contain position independent code, so all references
7352      from the dynamic object to this symbol will go through the global
7353      offset table.  The dynamic linker will use the .dynsym entry to
7354      determine the address it must put in the global offset table, so
7355      both the dynamic object and the regular object will refer to the
7356      same memory location for the variable.  */
7357
7358   /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
7359      to copy the initial value out of the dynamic object and into the
7360      runtime process image.  We need to remember the offset into the
7361      .rela.bss section we are going to use.  */
7362   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7363     {
7364       htab->relbss->size += sizeof (Elf64_External_Rela);
7365       h->needs_copy = 1;
7366     }
7367
7368   s = htab->dynbss;
7369
7370   return _bfd_elf_adjust_dynamic_copy (info, h, s);
7371 }
7372
7373 /* If given a function descriptor symbol, hide both the function code
7374    sym and the descriptor.  */
7375 static void
7376 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7377                        struct elf_link_hash_entry *h,
7378                        bfd_boolean force_local)
7379 {
7380   struct ppc_link_hash_entry *eh;
7381   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7382
7383   eh = (struct ppc_link_hash_entry *) h;
7384   if (eh->is_func_descriptor)
7385     {
7386       struct ppc_link_hash_entry *fh = eh->oh;
7387
7388       if (fh == NULL)
7389         {
7390           const char *p, *q;
7391           struct ppc_link_hash_table *htab;
7392           char save;
7393
7394           /* We aren't supposed to use alloca in BFD because on
7395              systems which do not have alloca the version in libiberty
7396              calls xmalloc, which might cause the program to crash
7397              when it runs out of memory.  This function doesn't have a
7398              return status, so there's no way to gracefully return an
7399              error.  So cheat.  We know that string[-1] can be safely
7400              accessed;  It's either a string in an ELF string table,
7401              or allocated in an objalloc structure.  */
7402
7403           p = eh->elf.root.root.string - 1;
7404           save = *p;
7405           *(char *) p = '.';
7406           htab = ppc_hash_table (info);
7407           if (htab == NULL)
7408             return;
7409
7410           fh = (struct ppc_link_hash_entry *)
7411             elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7412           *(char *) p = save;
7413
7414           /* Unfortunately, if it so happens that the string we were
7415              looking for was allocated immediately before this string,
7416              then we overwrote the string terminator.  That's the only
7417              reason the lookup should fail.  */
7418           if (fh == NULL)
7419             {
7420               q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7421               while (q >= eh->elf.root.root.string && *q == *p)
7422                 --q, --p;
7423               if (q < eh->elf.root.root.string && *p == '.')
7424                 fh = (struct ppc_link_hash_entry *)
7425                   elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7426             }
7427           if (fh != NULL)
7428             {
7429               eh->oh = fh;
7430               fh->oh = eh;
7431             }
7432         }
7433       if (fh != NULL)
7434         _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7435     }
7436 }
7437
7438 static bfd_boolean
7439 get_sym_h (struct elf_link_hash_entry **hp,
7440            Elf_Internal_Sym **symp,
7441            asection **symsecp,
7442            unsigned char **tls_maskp,
7443            Elf_Internal_Sym **locsymsp,
7444            unsigned long r_symndx,
7445            bfd *ibfd)
7446 {
7447   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7448
7449   if (r_symndx >= symtab_hdr->sh_info)
7450     {
7451       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7452       struct elf_link_hash_entry *h;
7453
7454       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7455       h = elf_follow_link (h);
7456
7457       if (hp != NULL)
7458         *hp = h;
7459
7460       if (symp != NULL)
7461         *symp = NULL;
7462
7463       if (symsecp != NULL)
7464         {
7465           asection *symsec = NULL;
7466           if (h->root.type == bfd_link_hash_defined
7467               || h->root.type == bfd_link_hash_defweak)
7468             symsec = h->root.u.def.section;
7469           *symsecp = symsec;
7470         }
7471
7472       if (tls_maskp != NULL)
7473         {
7474           struct ppc_link_hash_entry *eh;
7475
7476           eh = (struct ppc_link_hash_entry *) h;
7477           *tls_maskp = &eh->tls_mask;
7478         }
7479     }
7480   else
7481     {
7482       Elf_Internal_Sym *sym;
7483       Elf_Internal_Sym *locsyms = *locsymsp;
7484
7485       if (locsyms == NULL)
7486         {
7487           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7488           if (locsyms == NULL)
7489             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7490                                             symtab_hdr->sh_info,
7491                                             0, NULL, NULL, NULL);
7492           if (locsyms == NULL)
7493             return FALSE;
7494           *locsymsp = locsyms;
7495         }
7496       sym = locsyms + r_symndx;
7497
7498       if (hp != NULL)
7499         *hp = NULL;
7500
7501       if (symp != NULL)
7502         *symp = sym;
7503
7504       if (symsecp != NULL)
7505         *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7506
7507       if (tls_maskp != NULL)
7508         {
7509           struct got_entry **lgot_ents;
7510           unsigned char *tls_mask;
7511
7512           tls_mask = NULL;
7513           lgot_ents = elf_local_got_ents (ibfd);
7514           if (lgot_ents != NULL)
7515             {
7516               struct plt_entry **local_plt = (struct plt_entry **)
7517                 (lgot_ents + symtab_hdr->sh_info);
7518               unsigned char *lgot_masks = (unsigned char *)
7519                 (local_plt + symtab_hdr->sh_info);
7520               tls_mask = &lgot_masks[r_symndx];
7521             }
7522           *tls_maskp = tls_mask;
7523         }
7524     }
7525   return TRUE;
7526 }
7527
7528 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
7529    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7530    type suitable for optimization, and 1 otherwise.  */
7531
7532 static int
7533 get_tls_mask (unsigned char **tls_maskp,
7534               unsigned long *toc_symndx,
7535               bfd_vma *toc_addend,
7536               Elf_Internal_Sym **locsymsp,
7537               const Elf_Internal_Rela *rel,
7538               bfd *ibfd)
7539 {
7540   unsigned long r_symndx;
7541   int next_r;
7542   struct elf_link_hash_entry *h;
7543   Elf_Internal_Sym *sym;
7544   asection *sec;
7545   bfd_vma off;
7546
7547   r_symndx = ELF64_R_SYM (rel->r_info);
7548   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7549     return 0;
7550
7551   if ((*tls_maskp != NULL && **tls_maskp != 0)
7552       || sec == NULL
7553       || ppc64_elf_section_data (sec) == NULL
7554       || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7555     return 1;
7556
7557   /* Look inside a TOC section too.  */
7558   if (h != NULL)
7559     {
7560       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7561       off = h->root.u.def.value;
7562     }
7563   else
7564     off = sym->st_value;
7565   off += rel->r_addend;
7566   BFD_ASSERT (off % 8 == 0);
7567   r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7568   next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7569   if (toc_symndx != NULL)
7570     *toc_symndx = r_symndx;
7571   if (toc_addend != NULL)
7572     *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7573   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7574     return 0;
7575   if ((h == NULL || is_static_defined (h))
7576       && (next_r == -1 || next_r == -2))
7577     return 1 - next_r;
7578   return 1;
7579 }
7580
7581 /* Find (or create) an entry in the tocsave hash table.  */
7582
7583 static struct tocsave_entry *
7584 tocsave_find (struct ppc_link_hash_table *htab,
7585               enum insert_option insert,
7586               Elf_Internal_Sym **local_syms,
7587               const Elf_Internal_Rela *irela,
7588               bfd *ibfd)
7589 {
7590   unsigned long r_indx;
7591   struct elf_link_hash_entry *h;
7592   Elf_Internal_Sym *sym;
7593   struct tocsave_entry ent, *p;
7594   hashval_t hash;
7595   struct tocsave_entry **slot;
7596
7597   r_indx = ELF64_R_SYM (irela->r_info);
7598   if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7599     return NULL;
7600   if (ent.sec == NULL || ent.sec->output_section == NULL)
7601     {
7602       _bfd_error_handler
7603         (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"));
7604       return NULL;
7605     }
7606
7607   if (h != NULL)
7608     ent.offset = h->root.u.def.value;
7609   else
7610     ent.offset = sym->st_value;
7611   ent.offset += irela->r_addend;
7612
7613   hash = tocsave_htab_hash (&ent);
7614   slot = ((struct tocsave_entry **)
7615           htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7616   if (slot == NULL)
7617     return NULL;
7618
7619   if (*slot == NULL)
7620     {
7621       p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7622       if (p == NULL)
7623         return NULL;
7624       *p = ent;
7625       *slot = p;
7626     }
7627   return *slot;
7628 }
7629
7630 /* Adjust all global syms defined in opd sections.  In gcc generated
7631    code for the old ABI, these will already have been done.  */
7632
7633 static bfd_boolean
7634 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7635 {
7636   struct ppc_link_hash_entry *eh;
7637   asection *sym_sec;
7638   struct _opd_sec_data *opd;
7639
7640   if (h->root.type == bfd_link_hash_indirect)
7641     return TRUE;
7642
7643   if (h->root.type != bfd_link_hash_defined
7644       && h->root.type != bfd_link_hash_defweak)
7645     return TRUE;
7646
7647   eh = (struct ppc_link_hash_entry *) h;
7648   if (eh->adjust_done)
7649     return TRUE;
7650
7651   sym_sec = eh->elf.root.u.def.section;
7652   opd = get_opd_info (sym_sec);
7653   if (opd != NULL && opd->adjust != NULL)
7654     {
7655       long adjust = opd->adjust[OPD_NDX (eh->elf.root.u.def.value)];
7656       if (adjust == -1)
7657         {
7658           /* This entry has been deleted.  */
7659           asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7660           if (dsec == NULL)
7661             {
7662               for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7663                 if (discarded_section (dsec))
7664                   {
7665                     ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7666                     break;
7667                   }
7668             }
7669           eh->elf.root.u.def.value = 0;
7670           eh->elf.root.u.def.section = dsec;
7671         }
7672       else
7673         eh->elf.root.u.def.value += adjust;
7674       eh->adjust_done = 1;
7675     }
7676   return TRUE;
7677 }
7678
7679 /* Handles decrementing dynamic reloc counts for the reloc specified by
7680    R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM
7681    have already been determined.  */
7682
7683 static bfd_boolean
7684 dec_dynrel_count (bfd_vma r_info,
7685                   asection *sec,
7686                   struct bfd_link_info *info,
7687                   Elf_Internal_Sym **local_syms,
7688                   struct elf_link_hash_entry *h,
7689                   Elf_Internal_Sym *sym)
7690 {
7691   enum elf_ppc64_reloc_type r_type;
7692   asection *sym_sec = NULL;
7693
7694   /* Can this reloc be dynamic?  This switch, and later tests here
7695      should be kept in sync with the code in check_relocs.  */
7696   r_type = ELF64_R_TYPE (r_info);
7697   switch (r_type)
7698     {
7699     default:
7700       return TRUE;
7701
7702     case R_PPC64_TPREL16:
7703     case R_PPC64_TPREL16_LO:
7704     case R_PPC64_TPREL16_HI:
7705     case R_PPC64_TPREL16_HA:
7706     case R_PPC64_TPREL16_DS:
7707     case R_PPC64_TPREL16_LO_DS:
7708     case R_PPC64_TPREL16_HIGH:
7709     case R_PPC64_TPREL16_HIGHA:
7710     case R_PPC64_TPREL16_HIGHER:
7711     case R_PPC64_TPREL16_HIGHERA:
7712     case R_PPC64_TPREL16_HIGHEST:
7713     case R_PPC64_TPREL16_HIGHESTA:
7714       if (!bfd_link_pic (info))
7715         return TRUE;
7716
7717     case R_PPC64_TPREL64:
7718     case R_PPC64_DTPMOD64:
7719     case R_PPC64_DTPREL64:
7720     case R_PPC64_ADDR64:
7721     case R_PPC64_REL30:
7722     case R_PPC64_REL32:
7723     case R_PPC64_REL64:
7724     case R_PPC64_ADDR14:
7725     case R_PPC64_ADDR14_BRNTAKEN:
7726     case R_PPC64_ADDR14_BRTAKEN:
7727     case R_PPC64_ADDR16:
7728     case R_PPC64_ADDR16_DS:
7729     case R_PPC64_ADDR16_HA:
7730     case R_PPC64_ADDR16_HI:
7731     case R_PPC64_ADDR16_HIGH:
7732     case R_PPC64_ADDR16_HIGHA:
7733     case R_PPC64_ADDR16_HIGHER:
7734     case R_PPC64_ADDR16_HIGHERA:
7735     case R_PPC64_ADDR16_HIGHEST:
7736     case R_PPC64_ADDR16_HIGHESTA:
7737     case R_PPC64_ADDR16_LO:
7738     case R_PPC64_ADDR16_LO_DS:
7739     case R_PPC64_ADDR24:
7740     case R_PPC64_ADDR32:
7741     case R_PPC64_UADDR16:
7742     case R_PPC64_UADDR32:
7743     case R_PPC64_UADDR64:
7744     case R_PPC64_TOC:
7745       break;
7746     }
7747
7748   if (local_syms != NULL)
7749     {
7750       unsigned long r_symndx;
7751       bfd *ibfd = sec->owner;
7752
7753       r_symndx = ELF64_R_SYM (r_info);
7754       if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7755         return FALSE;
7756     }
7757
7758   if ((bfd_link_pic (info)
7759        && (must_be_dyn_reloc (info, r_type)
7760            || (h != NULL
7761                && (!SYMBOLIC_BIND (info, h)
7762                    || h->root.type == bfd_link_hash_defweak
7763                    || !h->def_regular))))
7764       || (ELIMINATE_COPY_RELOCS
7765           && !bfd_link_pic (info)
7766           && h != NULL
7767           && (h->root.type == bfd_link_hash_defweak
7768               || !h->def_regular)))
7769     ;
7770   else
7771     return TRUE;
7772
7773   if (h != NULL)
7774     {
7775       struct elf_dyn_relocs *p;
7776       struct elf_dyn_relocs **pp;
7777       pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7778
7779       /* elf_gc_sweep may have already removed all dyn relocs associated
7780          with local syms for a given section.  Also, symbol flags are
7781          changed by elf_gc_sweep_symbol, confusing the test above.  Don't
7782          report a dynreloc miscount.  */
7783       if (*pp == NULL && info->gc_sections)
7784         return TRUE;
7785
7786       while ((p = *pp) != NULL)
7787         {
7788           if (p->sec == sec)
7789             {
7790               if (!must_be_dyn_reloc (info, r_type))
7791                 p->pc_count -= 1;
7792               p->count -= 1;
7793               if (p->count == 0)
7794                 *pp = p->next;
7795               return TRUE;
7796             }
7797           pp = &p->next;
7798         }
7799     }
7800   else
7801     {
7802       struct ppc_dyn_relocs *p;
7803       struct ppc_dyn_relocs **pp;
7804       void *vpp;
7805       bfd_boolean is_ifunc;
7806
7807       if (local_syms == NULL)
7808         sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7809       if (sym_sec == NULL)
7810         sym_sec = sec;
7811
7812       vpp = &elf_section_data (sym_sec)->local_dynrel;
7813       pp = (struct ppc_dyn_relocs **) vpp;
7814
7815       if (*pp == NULL && info->gc_sections)
7816         return TRUE;
7817
7818       is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7819       while ((p = *pp) != NULL)
7820         {
7821           if (p->sec == sec && p->ifunc == is_ifunc)
7822             {
7823               p->count -= 1;
7824               if (p->count == 0)
7825                 *pp = p->next;
7826               return TRUE;
7827             }
7828           pp = &p->next;
7829         }
7830     }
7831
7832   info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7833                           sec->owner, sec);
7834   bfd_set_error (bfd_error_bad_value);
7835   return FALSE;
7836 }
7837
7838 /* Remove unused Official Procedure Descriptor entries.  Currently we
7839    only remove those associated with functions in discarded link-once
7840    sections, or weakly defined functions that have been overridden.  It
7841    would be possible to remove many more entries for statically linked
7842    applications.  */
7843
7844 bfd_boolean
7845 ppc64_elf_edit_opd (struct bfd_link_info *info)
7846 {
7847   bfd *ibfd;
7848   bfd_boolean some_edited = FALSE;
7849   asection *need_pad = NULL;
7850   struct ppc_link_hash_table *htab;
7851
7852   htab = ppc_hash_table (info);
7853   if (htab == NULL)
7854     return FALSE;
7855
7856   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
7857     {
7858       asection *sec;
7859       Elf_Internal_Rela *relstart, *rel, *relend;
7860       Elf_Internal_Shdr *symtab_hdr;
7861       Elf_Internal_Sym *local_syms;
7862       struct _opd_sec_data *opd;
7863       bfd_boolean need_edit, add_aux_fields, broken;
7864       bfd_size_type cnt_16b = 0;
7865
7866       if (!is_ppc64_elf (ibfd))
7867         continue;
7868
7869       sec = bfd_get_section_by_name (ibfd, ".opd");
7870       if (sec == NULL || sec->size == 0)
7871         continue;
7872
7873       if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7874         continue;
7875
7876       if (sec->output_section == bfd_abs_section_ptr)
7877         continue;
7878
7879       /* Look through the section relocs.  */
7880       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7881         continue;
7882
7883       local_syms = NULL;
7884       symtab_hdr = &elf_symtab_hdr (ibfd);
7885
7886       /* Read the relocations.  */
7887       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7888                                             info->keep_memory);
7889       if (relstart == NULL)
7890         return FALSE;
7891
7892       /* First run through the relocs to check they are sane, and to
7893          determine whether we need to edit this opd section.  */
7894       need_edit = FALSE;
7895       broken = FALSE;
7896       need_pad = sec;
7897       relend = relstart + sec->reloc_count;
7898       for (rel = relstart; rel < relend; )
7899         {
7900           enum elf_ppc64_reloc_type r_type;
7901           unsigned long r_symndx;
7902           asection *sym_sec;
7903           struct elf_link_hash_entry *h;
7904           Elf_Internal_Sym *sym;
7905           bfd_vma offset;
7906
7907           /* .opd contains an array of 16 or 24 byte entries.  We're
7908              only interested in the reloc pointing to a function entry
7909              point.  */
7910           offset = rel->r_offset;
7911           if (rel + 1 == relend
7912               || rel[1].r_offset != offset + 8)
7913             {
7914               /* If someone messes with .opd alignment then after a
7915                  "ld -r" we might have padding in the middle of .opd.
7916                  Also, there's nothing to prevent someone putting
7917                  something silly in .opd with the assembler.  No .opd
7918                  optimization for them!  */
7919             broken_opd:
7920               _bfd_error_handler
7921                 (_("%B: .opd is not a regular array of opd entries"), ibfd);
7922               broken = TRUE;
7923               break;
7924             }
7925
7926           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7927               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7928             {
7929               _bfd_error_handler
7930                 (_("%B: unexpected reloc type %u in .opd section"),
7931                  ibfd, r_type);
7932               broken = TRUE;
7933               break;
7934             }
7935
7936           r_symndx = ELF64_R_SYM (rel->r_info);
7937           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7938                           r_symndx, ibfd))
7939             goto error_ret;
7940
7941           if (sym_sec == NULL || sym_sec->owner == NULL)
7942             {
7943               const char *sym_name;
7944               if (h != NULL)
7945                 sym_name = h->root.root.string;
7946               else
7947                 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7948                                              sym_sec);
7949
7950               _bfd_error_handler
7951                 (_("%B: undefined sym `%s' in .opd section"),
7952                  ibfd, sym_name);
7953               broken = TRUE;
7954               break;
7955             }
7956
7957           /* opd entries are always for functions defined in the
7958              current input bfd.  If the symbol isn't defined in the
7959              input bfd, then we won't be using the function in this
7960              bfd;  It must be defined in a linkonce section in another
7961              bfd, or is weak.  It's also possible that we are
7962              discarding the function due to a linker script /DISCARD/,
7963              which we test for via the output_section.  */
7964           if (sym_sec->owner != ibfd
7965               || sym_sec->output_section == bfd_abs_section_ptr)
7966             need_edit = TRUE;
7967
7968           rel += 2;
7969           if (rel + 1 == relend
7970               || (rel + 2 < relend
7971                   && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC))
7972             ++rel;
7973
7974           if (rel == relend)
7975             {
7976               if (sec->size == offset + 24)
7977                 {
7978                   need_pad = NULL;
7979                   break;
7980                 }
7981               if (sec->size == offset + 16)
7982                 {
7983                   cnt_16b++;
7984                   break;
7985                 }
7986               goto broken_opd;
7987             }
7988           else if (rel + 1 < relend
7989                    && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7990                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7991             {
7992               if (rel[0].r_offset == offset + 16)
7993                 cnt_16b++;
7994               else if (rel[0].r_offset != offset + 24)
7995                 goto broken_opd;
7996             }
7997           else
7998             goto broken_opd;
7999         }
8000
8001       add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
8002
8003       if (!broken && (need_edit || add_aux_fields))
8004         {
8005           Elf_Internal_Rela *write_rel;
8006           Elf_Internal_Shdr *rel_hdr;
8007           bfd_byte *rptr, *wptr;
8008           bfd_byte *new_contents;
8009           bfd_size_type amt;
8010
8011           new_contents = NULL;
8012           amt = OPD_NDX (sec->size) * sizeof (long);
8013           opd = &ppc64_elf_section_data (sec)->u.opd;
8014           opd->adjust = bfd_zalloc (sec->owner, amt);
8015           if (opd->adjust == NULL)
8016             return FALSE;
8017           ppc64_elf_section_data (sec)->sec_type = sec_opd;
8018
8019           /* This seems a waste of time as input .opd sections are all
8020              zeros as generated by gcc, but I suppose there's no reason
8021              this will always be so.  We might start putting something in
8022              the third word of .opd entries.  */
8023           if ((sec->flags & SEC_IN_MEMORY) == 0)
8024             {
8025               bfd_byte *loc;
8026               if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
8027                 {
8028                   if (loc != NULL)
8029                     free (loc);
8030                 error_ret:
8031                   if (local_syms != NULL
8032                       && symtab_hdr->contents != (unsigned char *) local_syms)
8033                     free (local_syms);
8034                   if (elf_section_data (sec)->relocs != relstart)
8035                     free (relstart);
8036                   return FALSE;
8037                 }
8038               sec->contents = loc;
8039               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8040             }
8041
8042           elf_section_data (sec)->relocs = relstart;
8043
8044           new_contents = sec->contents;
8045           if (add_aux_fields)
8046             {
8047               new_contents = bfd_malloc (sec->size + cnt_16b * 8);
8048               if (new_contents == NULL)
8049                 return FALSE;
8050               need_pad = NULL;
8051             }
8052           wptr = new_contents;
8053           rptr = sec->contents;
8054           write_rel = relstart;
8055           for (rel = relstart; rel < relend; )
8056             {
8057               unsigned long r_symndx;
8058               asection *sym_sec;
8059               struct elf_link_hash_entry *h;
8060               struct ppc_link_hash_entry *fdh = NULL;
8061               Elf_Internal_Sym *sym;
8062               long opd_ent_size;
8063               Elf_Internal_Rela *next_rel;
8064               bfd_boolean skip;
8065
8066               r_symndx = ELF64_R_SYM (rel->r_info);
8067               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8068                               r_symndx, ibfd))
8069                 goto error_ret;
8070
8071               next_rel = rel + 2;
8072               if (next_rel + 1 == relend
8073                   || (next_rel + 2 < relend
8074                       && ELF64_R_TYPE (next_rel[2].r_info) == R_PPC64_TOC))
8075                 ++next_rel;
8076
8077               /* See if the .opd entry is full 24 byte or
8078                  16 byte (with fd_aux entry overlapped with next
8079                  fd_func).  */
8080               opd_ent_size = 24;
8081               if (next_rel == relend)
8082                 {
8083                   if (sec->size == rel->r_offset + 16)
8084                     opd_ent_size = 16;
8085                 }
8086               else if (next_rel->r_offset == rel->r_offset + 16)
8087                 opd_ent_size = 16;
8088
8089               if (h != NULL
8090                   && h->root.root.string[0] == '.')
8091                 {
8092                   fdh = lookup_fdh ((struct ppc_link_hash_entry *) h, htab);
8093                   if (fdh != NULL
8094                       && fdh->elf.root.type != bfd_link_hash_defined
8095                       && fdh->elf.root.type != bfd_link_hash_defweak)
8096                     fdh = NULL;
8097                 }
8098
8099               skip = (sym_sec->owner != ibfd
8100                       || sym_sec->output_section == bfd_abs_section_ptr);
8101               if (skip)
8102                 {
8103                   if (fdh != NULL && sym_sec->owner == ibfd)
8104                     {
8105                       /* Arrange for the function descriptor sym
8106                          to be dropped.  */
8107                       fdh->elf.root.u.def.value = 0;
8108                       fdh->elf.root.u.def.section = sym_sec;
8109                     }
8110                   opd->adjust[OPD_NDX (rel->r_offset)] = -1;
8111
8112                   if (NO_OPD_RELOCS || bfd_link_relocatable (info))
8113                     rel = next_rel;
8114                   else
8115                     while (1)
8116                       {
8117                         if (!dec_dynrel_count (rel->r_info, sec, info,
8118                                                NULL, h, sym))
8119                           goto error_ret;
8120
8121                         if (++rel == next_rel)
8122                           break;
8123
8124                         r_symndx = ELF64_R_SYM (rel->r_info);
8125                         if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8126                                         r_symndx, ibfd))
8127                           goto error_ret;
8128                       }
8129                 }
8130               else
8131                 {
8132                   /* We'll be keeping this opd entry.  */
8133                   long adjust;
8134
8135                   if (fdh != NULL)
8136                     {
8137                       /* Redefine the function descriptor symbol to
8138                          this location in the opd section.  It is
8139                          necessary to update the value here rather
8140                          than using an array of adjustments as we do
8141                          for local symbols, because various places
8142                          in the generic ELF code use the value
8143                          stored in u.def.value.  */
8144                       fdh->elf.root.u.def.value = wptr - new_contents;
8145                       fdh->adjust_done = 1;
8146                     }
8147
8148                   /* Local syms are a bit tricky.  We could
8149                      tweak them as they can be cached, but
8150                      we'd need to look through the local syms
8151                      for the function descriptor sym which we
8152                      don't have at the moment.  So keep an
8153                      array of adjustments.  */
8154                   adjust = (wptr - new_contents) - (rptr - sec->contents);
8155                   opd->adjust[OPD_NDX (rel->r_offset)] = adjust;
8156
8157                   if (wptr != rptr)
8158                     memcpy (wptr, rptr, opd_ent_size);
8159                   wptr += opd_ent_size;
8160                   if (add_aux_fields && opd_ent_size == 16)
8161                     {
8162                       memset (wptr, '\0', 8);
8163                       wptr += 8;
8164                     }
8165
8166                   /* We need to adjust any reloc offsets to point to the
8167                      new opd entries.  */
8168                   for ( ; rel != next_rel; ++rel)
8169                     {
8170                       rel->r_offset += adjust;
8171                       if (write_rel != rel)
8172                         memcpy (write_rel, rel, sizeof (*rel));
8173                       ++write_rel;
8174                     }
8175                 }
8176
8177               rptr += opd_ent_size;
8178             }
8179
8180           sec->size = wptr - new_contents;
8181           sec->reloc_count = write_rel - relstart;
8182           if (add_aux_fields)
8183             {
8184               free (sec->contents);
8185               sec->contents = new_contents;
8186             }
8187
8188           /* Fudge the header size too, as this is used later in
8189              elf_bfd_final_link if we are emitting relocs.  */
8190           rel_hdr = _bfd_elf_single_rel_hdr (sec);
8191           rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
8192           some_edited = TRUE;
8193         }
8194       else if (elf_section_data (sec)->relocs != relstart)
8195         free (relstart);
8196
8197       if (local_syms != NULL
8198           && symtab_hdr->contents != (unsigned char *) local_syms)
8199         {
8200           if (!info->keep_memory)
8201             free (local_syms);
8202           else
8203             symtab_hdr->contents = (unsigned char *) local_syms;
8204         }
8205     }
8206
8207   if (some_edited)
8208     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
8209
8210   /* If we are doing a final link and the last .opd entry is just 16 byte
8211      long, add a 8 byte padding after it.  */
8212   if (need_pad != NULL && !bfd_link_relocatable (info))
8213     {
8214       bfd_byte *p;
8215
8216       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
8217         {
8218           BFD_ASSERT (need_pad->size > 0);
8219
8220           p = bfd_malloc (need_pad->size + 8);
8221           if (p == NULL)
8222             return FALSE;
8223
8224           if (! bfd_get_section_contents (need_pad->owner, need_pad,
8225                                           p, 0, need_pad->size))
8226             return FALSE;
8227
8228           need_pad->contents = p;
8229           need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8230         }
8231       else
8232         {
8233           p = bfd_realloc (need_pad->contents, need_pad->size + 8);
8234           if (p == NULL)
8235             return FALSE;
8236
8237           need_pad->contents = p;
8238         }
8239
8240       memset (need_pad->contents + need_pad->size, 0, 8);
8241       need_pad->size += 8;
8242     }
8243
8244   return TRUE;
8245 }
8246
8247 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
8248
8249 asection *
8250 ppc64_elf_tls_setup (struct bfd_link_info *info)
8251 {
8252   struct ppc_link_hash_table *htab;
8253
8254   htab = ppc_hash_table (info);
8255   if (htab == NULL)
8256     return NULL;
8257
8258   if (abiversion (info->output_bfd) == 1)
8259     htab->opd_abi = 1;
8260
8261   if (htab->params->no_multi_toc)
8262     htab->do_multi_toc = 0;
8263   else if (!htab->do_multi_toc)
8264     htab->params->no_multi_toc = 1;
8265
8266   htab->tls_get_addr = ((struct ppc_link_hash_entry *)
8267                         elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
8268                                               FALSE, FALSE, TRUE));
8269   /* Move dynamic linking info to the function descriptor sym.  */
8270   if (htab->tls_get_addr != NULL)
8271     func_desc_adjust (&htab->tls_get_addr->elf, info);
8272   htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
8273                            elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
8274                                                  FALSE, FALSE, TRUE));
8275   if (htab->params->tls_get_addr_opt)
8276     {
8277       struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
8278
8279       opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
8280                                   FALSE, FALSE, TRUE);
8281       if (opt != NULL)
8282         func_desc_adjust (opt, info);
8283       opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
8284                                      FALSE, FALSE, TRUE);
8285       if (opt_fd != NULL
8286           && (opt_fd->root.type == bfd_link_hash_defined
8287               || opt_fd->root.type == bfd_link_hash_defweak))
8288         {
8289           /* If glibc supports an optimized __tls_get_addr call stub,
8290              signalled by the presence of __tls_get_addr_opt, and we'll
8291              be calling __tls_get_addr via a plt call stub, then
8292              make __tls_get_addr point to __tls_get_addr_opt.  */
8293           tga_fd = &htab->tls_get_addr_fd->elf;
8294           if (htab->elf.dynamic_sections_created
8295               && tga_fd != NULL
8296               && (tga_fd->type == STT_FUNC
8297                   || tga_fd->needs_plt)
8298               && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
8299                    || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
8300                        && tga_fd->root.type == bfd_link_hash_undefweak)))
8301             {
8302               struct plt_entry *ent;
8303
8304               for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
8305                 if (ent->plt.refcount > 0)
8306                   break;
8307               if (ent != NULL)
8308                 {
8309                   tga_fd->root.type = bfd_link_hash_indirect;
8310                   tga_fd->root.u.i.link = &opt_fd->root;
8311                   ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
8312                   opt_fd->forced_local = 0;
8313                   if (opt_fd->dynindx != -1)
8314                     {
8315                       /* Use __tls_get_addr_opt in dynamic relocations.  */
8316                       opt_fd->dynindx = -1;
8317                       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8318                                               opt_fd->dynstr_index);
8319                       if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8320                         return NULL;
8321                     }
8322                   htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8323                   tga = &htab->tls_get_addr->elf;
8324                   if (opt != NULL && tga != NULL)
8325                     {
8326                       tga->root.type = bfd_link_hash_indirect;
8327                       tga->root.u.i.link = &opt->root;
8328                       ppc64_elf_copy_indirect_symbol (info, opt, tga);
8329                       opt->forced_local = 0;
8330                       _bfd_elf_link_hash_hide_symbol (info, opt,
8331                                                       tga->forced_local);
8332                       htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8333                     }
8334                   htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8335                   htab->tls_get_addr_fd->is_func_descriptor = 1;
8336                   if (htab->tls_get_addr != NULL)
8337                     {
8338                       htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8339                       htab->tls_get_addr->is_func = 1;
8340                     }
8341                 }
8342             }
8343         }
8344       else if (htab->params->tls_get_addr_opt < 0)
8345         htab->params->tls_get_addr_opt = 0;
8346     }
8347   return _bfd_elf_tls_setup (info->output_bfd, info);
8348 }
8349
8350 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8351    HASH1 or HASH2.  */
8352
8353 static bfd_boolean
8354 branch_reloc_hash_match (const bfd *ibfd,
8355                          const Elf_Internal_Rela *rel,
8356                          const struct ppc_link_hash_entry *hash1,
8357                          const struct ppc_link_hash_entry *hash2)
8358 {
8359   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8360   enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8361   unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8362
8363   if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8364     {
8365       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8366       struct elf_link_hash_entry *h;
8367
8368       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8369       h = elf_follow_link (h);
8370       if (h == &hash1->elf || h == &hash2->elf)
8371         return TRUE;
8372     }
8373   return FALSE;
8374 }
8375
8376 /* Run through all the TLS relocs looking for optimization
8377    opportunities.  The linker has been hacked (see ppc64elf.em) to do
8378    a preliminary section layout so that we know the TLS segment
8379    offsets.  We can't optimize earlier because some optimizations need
8380    to know the tp offset, and we need to optimize before allocating
8381    dynamic relocations.  */
8382
8383 bfd_boolean
8384 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8385 {
8386   bfd *ibfd;
8387   asection *sec;
8388   struct ppc_link_hash_table *htab;
8389   unsigned char *toc_ref;
8390   int pass;
8391
8392   if (!bfd_link_executable (info))
8393     return TRUE;
8394
8395   htab = ppc_hash_table (info);
8396   if (htab == NULL)
8397     return FALSE;
8398
8399   /* Make two passes over the relocs.  On the first pass, mark toc
8400      entries involved with tls relocs, and check that tls relocs
8401      involved in setting up a tls_get_addr call are indeed followed by
8402      such a call.  If they are not, we can't do any tls optimization.
8403      On the second pass twiddle tls_mask flags to notify
8404      relocate_section that optimization can be done, and adjust got
8405      and plt refcounts.  */
8406   toc_ref = NULL;
8407   for (pass = 0; pass < 2; ++pass)
8408     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8409       {
8410         Elf_Internal_Sym *locsyms = NULL;
8411         asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8412
8413         for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8414           if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8415             {
8416               Elf_Internal_Rela *relstart, *rel, *relend;
8417               bfd_boolean found_tls_get_addr_arg = 0;
8418
8419               /* Read the relocations.  */
8420               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8421                                                     info->keep_memory);
8422               if (relstart == NULL)
8423                 {
8424                   free (toc_ref);
8425                   return FALSE;
8426                 }
8427
8428               relend = relstart + sec->reloc_count;
8429               for (rel = relstart; rel < relend; rel++)
8430                 {
8431                   enum elf_ppc64_reloc_type r_type;
8432                   unsigned long r_symndx;
8433                   struct elf_link_hash_entry *h;
8434                   Elf_Internal_Sym *sym;
8435                   asection *sym_sec;
8436                   unsigned char *tls_mask;
8437                   unsigned char tls_set, tls_clear, tls_type = 0;
8438                   bfd_vma value;
8439                   bfd_boolean ok_tprel, is_local;
8440                   long toc_ref_index = 0;
8441                   int expecting_tls_get_addr = 0;
8442                   bfd_boolean ret = FALSE;
8443
8444                   r_symndx = ELF64_R_SYM (rel->r_info);
8445                   if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8446                                   r_symndx, ibfd))
8447                     {
8448                     err_free_rel:
8449                       if (elf_section_data (sec)->relocs != relstart)
8450                         free (relstart);
8451                       if (toc_ref != NULL)
8452                         free (toc_ref);
8453                       if (locsyms != NULL
8454                           && (elf_symtab_hdr (ibfd).contents
8455                               != (unsigned char *) locsyms))
8456                         free (locsyms);
8457                       return ret;
8458                     }
8459
8460                   if (h != NULL)
8461                     {
8462                       if (h->root.type == bfd_link_hash_defined
8463                           || h->root.type == bfd_link_hash_defweak)
8464                         value = h->root.u.def.value;
8465                       else if (h->root.type == bfd_link_hash_undefweak)
8466                         value = 0;
8467                       else
8468                         {
8469                           found_tls_get_addr_arg = 0;
8470                           continue;
8471                         }
8472                     }
8473                   else
8474                     /* Symbols referenced by TLS relocs must be of type
8475                        STT_TLS.  So no need for .opd local sym adjust.  */
8476                     value = sym->st_value;
8477
8478                   ok_tprel = FALSE;
8479                   is_local = FALSE;
8480                   if (h == NULL
8481                       || !h->def_dynamic)
8482                     {
8483                       is_local = TRUE;
8484                       if (h != NULL
8485                           && h->root.type == bfd_link_hash_undefweak)
8486                         ok_tprel = TRUE;
8487                       else if (sym_sec != NULL
8488                                && sym_sec->output_section != NULL)
8489                         {
8490                           value += sym_sec->output_offset;
8491                           value += sym_sec->output_section->vma;
8492                           value -= htab->elf.tls_sec->vma;
8493                           ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8494                                       < (bfd_vma) 1 << 32);
8495                         }
8496                     }
8497
8498                   r_type = ELF64_R_TYPE (rel->r_info);
8499                   /* If this section has old-style __tls_get_addr calls
8500                      without marker relocs, then check that each
8501                      __tls_get_addr call reloc is preceded by a reloc
8502                      that conceivably belongs to the __tls_get_addr arg
8503                      setup insn.  If we don't find matching arg setup
8504                      relocs, don't do any tls optimization.  */
8505                   if (pass == 0
8506                       && sec->has_tls_get_addr_call
8507                       && h != NULL
8508                       && (h == &htab->tls_get_addr->elf
8509                           || h == &htab->tls_get_addr_fd->elf)
8510                       && !found_tls_get_addr_arg
8511                       && is_branch_reloc (r_type))
8512                     {
8513                       info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8514                                                 "TLS optimization disabled\n"),
8515                                               ibfd, sec, rel->r_offset);
8516                       ret = TRUE;
8517                       goto err_free_rel;
8518                     }
8519
8520                   found_tls_get_addr_arg = 0;
8521                   switch (r_type)
8522                     {
8523                     case R_PPC64_GOT_TLSLD16:
8524                     case R_PPC64_GOT_TLSLD16_LO:
8525                       expecting_tls_get_addr = 1;
8526                       found_tls_get_addr_arg = 1;
8527                       /* Fall thru */
8528
8529                     case R_PPC64_GOT_TLSLD16_HI:
8530                     case R_PPC64_GOT_TLSLD16_HA:
8531                       /* These relocs should never be against a symbol
8532                          defined in a shared lib.  Leave them alone if
8533                          that turns out to be the case.  */
8534                       if (!is_local)
8535                         continue;
8536
8537                       /* LD -> LE */
8538                       tls_set = 0;
8539                       tls_clear = TLS_LD;
8540                       tls_type = TLS_TLS | TLS_LD;
8541                       break;
8542
8543                     case R_PPC64_GOT_TLSGD16:
8544                     case R_PPC64_GOT_TLSGD16_LO:
8545                       expecting_tls_get_addr = 1;
8546                       found_tls_get_addr_arg = 1;
8547                       /* Fall thru */
8548
8549                     case R_PPC64_GOT_TLSGD16_HI:
8550                     case R_PPC64_GOT_TLSGD16_HA:
8551                       if (ok_tprel)
8552                         /* GD -> LE */
8553                         tls_set = 0;
8554                       else
8555                         /* GD -> IE */
8556                         tls_set = TLS_TLS | TLS_TPRELGD;
8557                       tls_clear = TLS_GD;
8558                       tls_type = TLS_TLS | TLS_GD;
8559                       break;
8560
8561                     case R_PPC64_GOT_TPREL16_DS:
8562                     case R_PPC64_GOT_TPREL16_LO_DS:
8563                     case R_PPC64_GOT_TPREL16_HI:
8564                     case R_PPC64_GOT_TPREL16_HA:
8565                       if (ok_tprel)
8566                         {
8567                           /* IE -> LE */
8568                           tls_set = 0;
8569                           tls_clear = TLS_TPREL;
8570                           tls_type = TLS_TLS | TLS_TPREL;
8571                           break;
8572                         }
8573                       continue;
8574
8575                     case R_PPC64_TLSGD:
8576                     case R_PPC64_TLSLD:
8577                       found_tls_get_addr_arg = 1;
8578                       /* Fall thru */
8579
8580                     case R_PPC64_TLS:
8581                     case R_PPC64_TOC16:
8582                     case R_PPC64_TOC16_LO:
8583                       if (sym_sec == NULL || sym_sec != toc)
8584                         continue;
8585
8586                       /* Mark this toc entry as referenced by a TLS
8587                          code sequence.  We can do that now in the
8588                          case of R_PPC64_TLS, and after checking for
8589                          tls_get_addr for the TOC16 relocs.  */
8590                       if (toc_ref == NULL)
8591                         toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8592                       if (toc_ref == NULL)
8593                         goto err_free_rel;
8594
8595                       if (h != NULL)
8596                         value = h->root.u.def.value;
8597                       else
8598                         value = sym->st_value;
8599                       value += rel->r_addend;
8600                       if (value % 8 != 0)
8601                         continue;
8602                       BFD_ASSERT (value < toc->size
8603                                   && toc->output_offset % 8 == 0);
8604                       toc_ref_index = (value + toc->output_offset) / 8;
8605                       if (r_type == R_PPC64_TLS
8606                           || r_type == R_PPC64_TLSGD
8607                           || r_type == R_PPC64_TLSLD)
8608                         {
8609                           toc_ref[toc_ref_index] = 1;
8610                           continue;
8611                         }
8612
8613                       if (pass != 0 && toc_ref[toc_ref_index] == 0)
8614                         continue;
8615
8616                       tls_set = 0;
8617                       tls_clear = 0;
8618                       expecting_tls_get_addr = 2;
8619                       break;
8620
8621                     case R_PPC64_TPREL64:
8622                       if (pass == 0
8623                           || sec != toc
8624                           || toc_ref == NULL
8625                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8626                         continue;
8627                       if (ok_tprel)
8628                         {
8629                           /* IE -> LE */
8630                           tls_set = TLS_EXPLICIT;
8631                           tls_clear = TLS_TPREL;
8632                           break;
8633                         }
8634                       continue;
8635
8636                     case R_PPC64_DTPMOD64:
8637                       if (pass == 0
8638                           || sec != toc
8639                           || toc_ref == NULL
8640                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8641                         continue;
8642                       if (rel + 1 < relend
8643                           && (rel[1].r_info
8644                               == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8645                           && rel[1].r_offset == rel->r_offset + 8)
8646                         {
8647                           if (ok_tprel)
8648                             /* GD -> LE */
8649                             tls_set = TLS_EXPLICIT | TLS_GD;
8650                           else
8651                             /* GD -> IE */
8652                             tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8653                           tls_clear = TLS_GD;
8654                         }
8655                       else
8656                         {
8657                           if (!is_local)
8658                             continue;
8659
8660                           /* LD -> LE */
8661                           tls_set = TLS_EXPLICIT;
8662                           tls_clear = TLS_LD;
8663                         }
8664                       break;
8665
8666                     default:
8667                       continue;
8668                     }
8669
8670                   if (pass == 0)
8671                     {
8672                       if (!expecting_tls_get_addr
8673                           || !sec->has_tls_get_addr_call)
8674                         continue;
8675
8676                       if (rel + 1 < relend
8677                           && branch_reloc_hash_match (ibfd, rel + 1,
8678                                                       htab->tls_get_addr,
8679                                                       htab->tls_get_addr_fd))
8680                         {
8681                           if (expecting_tls_get_addr == 2)
8682                             {
8683                               /* Check for toc tls entries.  */
8684                               unsigned char *toc_tls;
8685                               int retval;
8686
8687                               retval = get_tls_mask (&toc_tls, NULL, NULL,
8688                                                      &locsyms,
8689                                                      rel, ibfd);
8690                               if (retval == 0)
8691                                 goto err_free_rel;
8692                               if (toc_tls != NULL)
8693                                 {
8694                                   if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8695                                     found_tls_get_addr_arg = 1;
8696                                   if (retval > 1)
8697                                     toc_ref[toc_ref_index] = 1;
8698                                 }
8699                             }
8700                           continue;
8701                         }
8702
8703                       if (expecting_tls_get_addr != 1)
8704                         continue;
8705
8706                       /* Uh oh, we didn't find the expected call.  We
8707                          could just mark this symbol to exclude it
8708                          from tls optimization but it's safer to skip
8709                          the entire optimization.  */
8710                       info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8711                                                 "TLS optimization disabled\n"),
8712                                               ibfd, sec, rel->r_offset);
8713                       ret = TRUE;
8714                       goto err_free_rel;
8715                     }
8716
8717                   if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8718                     {
8719                       struct plt_entry *ent;
8720                       for (ent = htab->tls_get_addr->elf.plt.plist;
8721                            ent != NULL;
8722                            ent = ent->next)
8723                         if (ent->addend == 0)
8724                           {
8725                             if (ent->plt.refcount > 0)
8726                               {
8727                                 ent->plt.refcount -= 1;
8728                                 expecting_tls_get_addr = 0;
8729                               }
8730                             break;
8731                           }
8732                     }
8733
8734                   if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8735                     {
8736                       struct plt_entry *ent;
8737                       for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8738                            ent != NULL;
8739                            ent = ent->next)
8740                         if (ent->addend == 0)
8741                           {
8742                             if (ent->plt.refcount > 0)
8743                               ent->plt.refcount -= 1;
8744                             break;
8745                           }
8746                     }
8747
8748                   if (tls_clear == 0)
8749                     continue;
8750
8751                   if ((tls_set & TLS_EXPLICIT) == 0)
8752                     {
8753                       struct got_entry *ent;
8754
8755                       /* Adjust got entry for this reloc.  */
8756                       if (h != NULL)
8757                         ent = h->got.glist;
8758                       else
8759                         ent = elf_local_got_ents (ibfd)[r_symndx];
8760
8761                       for (; ent != NULL; ent = ent->next)
8762                         if (ent->addend == rel->r_addend
8763                             && ent->owner == ibfd
8764                             && ent->tls_type == tls_type)
8765                           break;
8766                       if (ent == NULL)
8767                         abort ();
8768
8769                       if (tls_set == 0)
8770                         {
8771                           /* We managed to get rid of a got entry.  */
8772                           if (ent->got.refcount > 0)
8773                             ent->got.refcount -= 1;
8774                         }
8775                     }
8776                   else
8777                     {
8778                       /* If we got rid of a DTPMOD/DTPREL reloc pair then
8779                          we'll lose one or two dyn relocs.  */
8780                       if (!dec_dynrel_count (rel->r_info, sec, info,
8781                                              NULL, h, sym))
8782                         return FALSE;
8783
8784                       if (tls_set == (TLS_EXPLICIT | TLS_GD))
8785                         {
8786                           if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8787                                                  NULL, h, sym))
8788                             return FALSE;
8789                         }
8790                     }
8791
8792                   *tls_mask |= tls_set;
8793                   *tls_mask &= ~tls_clear;
8794                 }
8795
8796               if (elf_section_data (sec)->relocs != relstart)
8797                 free (relstart);
8798             }
8799
8800         if (locsyms != NULL
8801             && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8802           {
8803             if (!info->keep_memory)
8804               free (locsyms);
8805             else
8806               elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8807           }
8808       }
8809
8810   if (toc_ref != NULL)
8811     free (toc_ref);
8812   return TRUE;
8813 }
8814
8815 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8816    the values of any global symbols in a toc section that has been
8817    edited.  Globals in toc sections should be a rarity, so this function
8818    sets a flag if any are found in toc sections other than the one just
8819    edited, so that futher hash table traversals can be avoided.  */
8820
8821 struct adjust_toc_info
8822 {
8823   asection *toc;
8824   unsigned long *skip;
8825   bfd_boolean global_toc_syms;
8826 };
8827
8828 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8829
8830 static bfd_boolean
8831 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8832 {
8833   struct ppc_link_hash_entry *eh;
8834   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8835   unsigned long i;
8836
8837   if (h->root.type != bfd_link_hash_defined
8838       && h->root.type != bfd_link_hash_defweak)
8839     return TRUE;
8840
8841   eh = (struct ppc_link_hash_entry *) h;
8842   if (eh->adjust_done)
8843     return TRUE;
8844
8845   if (eh->elf.root.u.def.section == toc_inf->toc)
8846     {
8847       if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8848         i = toc_inf->toc->rawsize >> 3;
8849       else
8850         i = eh->elf.root.u.def.value >> 3;
8851
8852       if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8853         {
8854           _bfd_error_handler
8855             (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8856           do
8857             ++i;
8858           while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8859           eh->elf.root.u.def.value = (bfd_vma) i << 3;
8860         }
8861
8862       eh->elf.root.u.def.value -= toc_inf->skip[i];
8863       eh->adjust_done = 1;
8864     }
8865   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8866     toc_inf->global_toc_syms = TRUE;
8867
8868   return TRUE;
8869 }
8870
8871 /* Return TRUE iff INSN is one we expect on a _LO variety toc/got reloc.  */
8872
8873 static bfd_boolean
8874 ok_lo_toc_insn (unsigned int insn)
8875 {
8876   return ((insn & (0x3f << 26)) == 14u << 26 /* addi */
8877           || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8878           || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8879           || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8880           || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8881           || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8882           || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8883           || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8884           || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8885           || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8886           || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8887           || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8888           || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8889           || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8890           || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
8891               && (insn & 3) != 1)
8892           || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
8893               && ((insn & 3) == 0 || (insn & 3) == 3))
8894           || (insn & (0x3f << 26)) == 12u << 26 /* addic */);
8895 }
8896
8897 /* Examine all relocs referencing .toc sections in order to remove
8898    unused .toc entries.  */
8899
8900 bfd_boolean
8901 ppc64_elf_edit_toc (struct bfd_link_info *info)
8902 {
8903   bfd *ibfd;
8904   struct adjust_toc_info toc_inf;
8905   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8906
8907   htab->do_toc_opt = 1;
8908   toc_inf.global_toc_syms = TRUE;
8909   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8910     {
8911       asection *toc, *sec;
8912       Elf_Internal_Shdr *symtab_hdr;
8913       Elf_Internal_Sym *local_syms;
8914       Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8915       unsigned long *skip, *drop;
8916       unsigned char *used;
8917       unsigned char *keep, last, some_unused;
8918
8919       if (!is_ppc64_elf (ibfd))
8920         continue;
8921
8922       toc = bfd_get_section_by_name (ibfd, ".toc");
8923       if (toc == NULL
8924           || toc->size == 0
8925           || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8926           || discarded_section (toc))
8927         continue;
8928
8929       toc_relocs = NULL;
8930       local_syms = NULL;
8931       symtab_hdr = &elf_symtab_hdr (ibfd);
8932
8933       /* Look at sections dropped from the final link.  */
8934       skip = NULL;
8935       relstart = NULL;
8936       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8937         {
8938           if (sec->reloc_count == 0
8939               || !discarded_section (sec)
8940               || get_opd_info (sec)
8941               || (sec->flags & SEC_ALLOC) == 0
8942               || (sec->flags & SEC_DEBUGGING) != 0)
8943             continue;
8944
8945           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8946           if (relstart == NULL)
8947             goto error_ret;
8948
8949           /* Run through the relocs to see which toc entries might be
8950              unused.  */
8951           for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8952             {
8953               enum elf_ppc64_reloc_type r_type;
8954               unsigned long r_symndx;
8955               asection *sym_sec;
8956               struct elf_link_hash_entry *h;
8957               Elf_Internal_Sym *sym;
8958               bfd_vma val;
8959
8960               r_type = ELF64_R_TYPE (rel->r_info);
8961               switch (r_type)
8962                 {
8963                 default:
8964                   continue;
8965
8966                 case R_PPC64_TOC16:
8967                 case R_PPC64_TOC16_LO:
8968                 case R_PPC64_TOC16_HI:
8969                 case R_PPC64_TOC16_HA:
8970                 case R_PPC64_TOC16_DS:
8971                 case R_PPC64_TOC16_LO_DS:
8972                   break;
8973                 }
8974
8975               r_symndx = ELF64_R_SYM (rel->r_info);
8976               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8977                               r_symndx, ibfd))
8978                 goto error_ret;
8979
8980               if (sym_sec != toc)
8981                 continue;
8982
8983               if (h != NULL)
8984                 val = h->root.u.def.value;
8985               else
8986                 val = sym->st_value;
8987               val += rel->r_addend;
8988
8989               if (val >= toc->size)
8990                 continue;
8991
8992               /* Anything in the toc ought to be aligned to 8 bytes.
8993                  If not, don't mark as unused.  */
8994               if (val & 7)
8995                 continue;
8996
8997               if (skip == NULL)
8998                 {
8999                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9000                   if (skip == NULL)
9001                     goto error_ret;
9002                 }
9003
9004               skip[val >> 3] = ref_from_discarded;
9005             }
9006
9007           if (elf_section_data (sec)->relocs != relstart)
9008             free (relstart);
9009         }
9010
9011       /* For largetoc loads of address constants, we can convert
9012          .  addis rx,2,addr@got@ha
9013          .  ld ry,addr@got@l(rx)
9014          to
9015          .  addis rx,2,addr@toc@ha
9016          .  addi ry,rx,addr@toc@l
9017          when addr is within 2G of the toc pointer.  This then means
9018          that the word storing "addr" in the toc is no longer needed.  */
9019
9020       if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
9021           && toc->output_section->rawsize < (bfd_vma) 1 << 31
9022           && toc->reloc_count != 0)
9023         {
9024           /* Read toc relocs.  */
9025           toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9026                                                   info->keep_memory);
9027           if (toc_relocs == NULL)
9028             goto error_ret;
9029
9030           for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9031             {
9032               enum elf_ppc64_reloc_type r_type;
9033               unsigned long r_symndx;
9034               asection *sym_sec;
9035               struct elf_link_hash_entry *h;
9036               Elf_Internal_Sym *sym;
9037               bfd_vma val, addr;
9038
9039               r_type = ELF64_R_TYPE (rel->r_info);
9040               if (r_type != R_PPC64_ADDR64)
9041                 continue;
9042
9043               r_symndx = ELF64_R_SYM (rel->r_info);
9044               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9045                               r_symndx, ibfd))
9046                 goto error_ret;
9047
9048               if (sym_sec == NULL
9049                   || sym_sec->output_section == NULL
9050                   || discarded_section (sym_sec))
9051                 continue;
9052
9053               if (!SYMBOL_REFERENCES_LOCAL (info, h))
9054                 continue;
9055
9056               if (h != NULL)
9057                 {
9058                   if (h->type == STT_GNU_IFUNC)
9059                     continue;
9060                   val = h->root.u.def.value;
9061                 }
9062               else
9063                 {
9064                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
9065                     continue;
9066                   val = sym->st_value;
9067                 }
9068               val += rel->r_addend;
9069               val += sym_sec->output_section->vma + sym_sec->output_offset;
9070
9071               /* We don't yet know the exact toc pointer value, but we
9072                  know it will be somewhere in the toc section.  Don't
9073                  optimize if the difference from any possible toc
9074                  pointer is outside [ff..f80008000, 7fff7fff].  */
9075               addr = toc->output_section->vma + TOC_BASE_OFF;
9076               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9077                 continue;
9078
9079               addr = toc->output_section->vma + toc->output_section->rawsize;
9080               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9081                 continue;
9082
9083               if (skip == NULL)
9084                 {
9085                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9086                   if (skip == NULL)
9087                     goto error_ret;
9088                 }
9089
9090               skip[rel->r_offset >> 3]
9091                 |= can_optimize | ((rel - toc_relocs) << 2);
9092             }
9093         }
9094
9095       if (skip == NULL)
9096         continue;
9097
9098       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
9099       if (used == NULL)
9100         {
9101         error_ret:
9102           if (local_syms != NULL
9103               && symtab_hdr->contents != (unsigned char *) local_syms)
9104             free (local_syms);
9105           if (sec != NULL
9106               && relstart != NULL
9107               && elf_section_data (sec)->relocs != relstart)
9108             free (relstart);
9109           if (toc_relocs != NULL
9110               && elf_section_data (toc)->relocs != toc_relocs)
9111             free (toc_relocs);
9112           if (skip != NULL)
9113             free (skip);
9114           return FALSE;
9115         }
9116
9117       /* Now check all kept sections that might reference the toc.
9118          Check the toc itself last.  */
9119       for (sec = (ibfd->sections == toc && toc->next ? toc->next
9120                   : ibfd->sections);
9121            sec != NULL;
9122            sec = (sec == toc ? NULL
9123                   : sec->next == NULL ? toc
9124                   : sec->next == toc && toc->next ? toc->next
9125                   : sec->next))
9126         {
9127           int repeat;
9128
9129           if (sec->reloc_count == 0
9130               || discarded_section (sec)
9131               || get_opd_info (sec)
9132               || (sec->flags & SEC_ALLOC) == 0
9133               || (sec->flags & SEC_DEBUGGING) != 0)
9134             continue;
9135
9136           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9137                                                 info->keep_memory);
9138           if (relstart == NULL)
9139             {
9140               free (used);
9141               goto error_ret;
9142             }
9143
9144           /* Mark toc entries referenced as used.  */
9145           do
9146             {
9147               repeat = 0;
9148               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9149                 {
9150                   enum elf_ppc64_reloc_type r_type;
9151                   unsigned long r_symndx;
9152                   asection *sym_sec;
9153                   struct elf_link_hash_entry *h;
9154                   Elf_Internal_Sym *sym;
9155                   bfd_vma val;
9156                   enum {no_check, check_lo, check_ha} insn_check;
9157
9158                   r_type = ELF64_R_TYPE (rel->r_info);
9159                   switch (r_type)
9160                     {
9161                     default:
9162                       insn_check = no_check;
9163                       break;
9164
9165                     case R_PPC64_GOT_TLSLD16_HA:
9166                     case R_PPC64_GOT_TLSGD16_HA:
9167                     case R_PPC64_GOT_TPREL16_HA:
9168                     case R_PPC64_GOT_DTPREL16_HA:
9169                     case R_PPC64_GOT16_HA:
9170                     case R_PPC64_TOC16_HA:
9171                       insn_check = check_ha;
9172                       break;
9173
9174                     case R_PPC64_GOT_TLSLD16_LO:
9175                     case R_PPC64_GOT_TLSGD16_LO:
9176                     case R_PPC64_GOT_TPREL16_LO_DS:
9177                     case R_PPC64_GOT_DTPREL16_LO_DS:
9178                     case R_PPC64_GOT16_LO:
9179                     case R_PPC64_GOT16_LO_DS:
9180                     case R_PPC64_TOC16_LO:
9181                     case R_PPC64_TOC16_LO_DS:
9182                       insn_check = check_lo;
9183                       break;
9184                     }
9185
9186                   if (insn_check != no_check)
9187                     {
9188                       bfd_vma off = rel->r_offset & ~3;
9189                       unsigned char buf[4];
9190                       unsigned int insn;
9191
9192                       if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
9193                         {
9194                           free (used);
9195                           goto error_ret;
9196                         }
9197                       insn = bfd_get_32 (ibfd, buf);
9198                       if (insn_check == check_lo
9199                           ? !ok_lo_toc_insn (insn)
9200                           : ((insn & ((0x3f << 26) | 0x1f << 16))
9201                              != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9202                         {
9203                           char str[12];
9204
9205                           ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
9206                           sprintf (str, "%#08x", insn);
9207                           info->callbacks->einfo
9208                             (_("%P: %H: toc optimization is not supported for"
9209                                " %s instruction.\n"),
9210                              ibfd, sec, rel->r_offset & ~3, str);
9211                         }
9212                     }
9213
9214                   switch (r_type)
9215                     {
9216                     case R_PPC64_TOC16:
9217                     case R_PPC64_TOC16_LO:
9218                     case R_PPC64_TOC16_HI:
9219                     case R_PPC64_TOC16_HA:
9220                     case R_PPC64_TOC16_DS:
9221                     case R_PPC64_TOC16_LO_DS:
9222                       /* In case we're taking addresses of toc entries.  */
9223                     case R_PPC64_ADDR64:
9224                       break;
9225
9226                     default:
9227                       continue;
9228                     }
9229
9230                   r_symndx = ELF64_R_SYM (rel->r_info);
9231                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9232                                   r_symndx, ibfd))
9233                     {
9234                       free (used);
9235                       goto error_ret;
9236                     }
9237
9238                   if (sym_sec != toc)
9239                     continue;
9240
9241                   if (h != NULL)
9242                     val = h->root.u.def.value;
9243                   else
9244                     val = sym->st_value;
9245                   val += rel->r_addend;
9246
9247                   if (val >= toc->size)
9248                     continue;
9249
9250                   if ((skip[val >> 3] & can_optimize) != 0)
9251                     {
9252                       bfd_vma off;
9253                       unsigned char opc;
9254
9255                       switch (r_type)
9256                         {
9257                         case R_PPC64_TOC16_HA:
9258                           break;
9259
9260                         case R_PPC64_TOC16_LO_DS:
9261                           off = rel->r_offset;
9262                           off += (bfd_big_endian (ibfd) ? -2 : 3);
9263                           if (!bfd_get_section_contents (ibfd, sec, &opc,
9264                                                          off, 1))
9265                             {
9266                               free (used);
9267                               goto error_ret;
9268                             }
9269                           if ((opc & (0x3f << 2)) == (58u << 2))
9270                             break;
9271                           /* Fall thru */
9272
9273                         default:
9274                           /* Wrong sort of reloc, or not a ld.  We may
9275                              as well clear ref_from_discarded too.  */
9276                           skip[val >> 3] = 0;
9277                         }
9278                     }
9279
9280                   if (sec != toc)
9281                     used[val >> 3] = 1;
9282                   /* For the toc section, we only mark as used if this
9283                      entry itself isn't unused.  */
9284                   else if ((used[rel->r_offset >> 3]
9285                             || !(skip[rel->r_offset >> 3] & ref_from_discarded))
9286                            && !used[val >> 3])
9287                     {
9288                       /* Do all the relocs again, to catch reference
9289                          chains.  */
9290                       repeat = 1;
9291                       used[val >> 3] = 1;
9292                     }
9293                 }
9294             }
9295           while (repeat);
9296
9297           if (elf_section_data (sec)->relocs != relstart)
9298             free (relstart);
9299         }
9300
9301       /* Merge the used and skip arrays.  Assume that TOC
9302          doublewords not appearing as either used or unused belong
9303          to to an entry more than one doubleword in size.  */
9304       for (drop = skip, keep = used, last = 0, some_unused = 0;
9305            drop < skip + (toc->size + 7) / 8;
9306            ++drop, ++keep)
9307         {
9308           if (*keep)
9309             {
9310               *drop &= ~ref_from_discarded;
9311               if ((*drop & can_optimize) != 0)
9312                 some_unused = 1;
9313               last = 0;
9314             }
9315           else if ((*drop & ref_from_discarded) != 0)
9316             {
9317               some_unused = 1;
9318               last = ref_from_discarded;
9319             }
9320           else
9321             *drop = last;
9322         }
9323
9324       free (used);
9325
9326       if (some_unused)
9327         {
9328           bfd_byte *contents, *src;
9329           unsigned long off;
9330           Elf_Internal_Sym *sym;
9331           bfd_boolean local_toc_syms = FALSE;
9332
9333           /* Shuffle the toc contents, and at the same time convert the
9334              skip array from booleans into offsets.  */
9335           if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9336             goto error_ret;
9337
9338           elf_section_data (toc)->this_hdr.contents = contents;
9339
9340           for (src = contents, off = 0, drop = skip;
9341                src < contents + toc->size;
9342                src += 8, ++drop)
9343             {
9344               if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9345                 off += 8;
9346               else if (off != 0)
9347                 {
9348                   *drop = off;
9349                   memcpy (src - off, src, 8);
9350                 }
9351             }
9352           *drop = off;
9353           toc->rawsize = toc->size;
9354           toc->size = src - contents - off;
9355
9356           /* Adjust addends for relocs against the toc section sym,
9357              and optimize any accesses we can.  */
9358           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9359             {
9360               if (sec->reloc_count == 0
9361                   || discarded_section (sec))
9362                 continue;
9363
9364               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9365                                                     info->keep_memory);
9366               if (relstart == NULL)
9367                 goto error_ret;
9368
9369               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9370                 {
9371                   enum elf_ppc64_reloc_type r_type;
9372                   unsigned long r_symndx;
9373                   asection *sym_sec;
9374                   struct elf_link_hash_entry *h;
9375                   bfd_vma val;
9376
9377                   r_type = ELF64_R_TYPE (rel->r_info);
9378                   switch (r_type)
9379                     {
9380                     default:
9381                       continue;
9382
9383                     case R_PPC64_TOC16:
9384                     case R_PPC64_TOC16_LO:
9385                     case R_PPC64_TOC16_HI:
9386                     case R_PPC64_TOC16_HA:
9387                     case R_PPC64_TOC16_DS:
9388                     case R_PPC64_TOC16_LO_DS:
9389                     case R_PPC64_ADDR64:
9390                       break;
9391                     }
9392
9393                   r_symndx = ELF64_R_SYM (rel->r_info);
9394                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9395                                   r_symndx, ibfd))
9396                     goto error_ret;
9397
9398                   if (sym_sec != toc)
9399                     continue;
9400
9401                   if (h != NULL)
9402                     val = h->root.u.def.value;
9403                   else
9404                     {
9405                       val = sym->st_value;
9406                       if (val != 0)
9407                         local_toc_syms = TRUE;
9408                     }
9409
9410                   val += rel->r_addend;
9411
9412                   if (val > toc->rawsize)
9413                     val = toc->rawsize;
9414                   else if ((skip[val >> 3] & ref_from_discarded) != 0)
9415                     continue;
9416                   else if ((skip[val >> 3] & can_optimize) != 0)
9417                     {
9418                       Elf_Internal_Rela *tocrel
9419                         = toc_relocs + (skip[val >> 3] >> 2);
9420                       unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9421
9422                       switch (r_type)
9423                         {
9424                         case R_PPC64_TOC16_HA:
9425                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9426                           break;
9427
9428                         case R_PPC64_TOC16_LO_DS:
9429                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9430                           break;
9431
9432                         default:
9433                           if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9434                             ppc_howto_init ();
9435                           info->callbacks->einfo
9436                             (_("%P: %H: %s references "
9437                                "optimized away TOC entry\n"),
9438                              ibfd, sec, rel->r_offset,
9439                              ppc64_elf_howto_table[r_type]->name);
9440                           bfd_set_error (bfd_error_bad_value);
9441                           goto error_ret;
9442                         }
9443                       rel->r_addend = tocrel->r_addend;
9444                       elf_section_data (sec)->relocs = relstart;
9445                       continue;
9446                     }
9447
9448                   if (h != NULL || sym->st_value != 0)
9449                     continue;
9450
9451                   rel->r_addend -= skip[val >> 3];
9452                   elf_section_data (sec)->relocs = relstart;
9453                 }
9454
9455               if (elf_section_data (sec)->relocs != relstart)
9456                 free (relstart);
9457             }
9458
9459           /* We shouldn't have local or global symbols defined in the TOC,
9460              but handle them anyway.  */
9461           if (local_syms != NULL)
9462             for (sym = local_syms;
9463                  sym < local_syms + symtab_hdr->sh_info;
9464                  ++sym)
9465               if (sym->st_value != 0
9466                   && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9467                 {
9468                   unsigned long i;
9469
9470                   if (sym->st_value > toc->rawsize)
9471                     i = toc->rawsize >> 3;
9472                   else
9473                     i = sym->st_value >> 3;
9474
9475                   if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9476                     {
9477                       if (local_toc_syms)
9478                         _bfd_error_handler
9479                           (_("%s defined on removed toc entry"),
9480                            bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9481                       do
9482                         ++i;
9483                       while ((skip[i] & (ref_from_discarded | can_optimize)));
9484                       sym->st_value = (bfd_vma) i << 3;
9485                     }
9486
9487                   sym->st_value -= skip[i];
9488                   symtab_hdr->contents = (unsigned char *) local_syms;
9489                 }
9490
9491           /* Adjust any global syms defined in this toc input section.  */
9492           if (toc_inf.global_toc_syms)
9493             {
9494               toc_inf.toc = toc;
9495               toc_inf.skip = skip;
9496               toc_inf.global_toc_syms = FALSE;
9497               elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9498                                       &toc_inf);
9499             }
9500
9501           if (toc->reloc_count != 0)
9502             {
9503               Elf_Internal_Shdr *rel_hdr;
9504               Elf_Internal_Rela *wrel;
9505               bfd_size_type sz;
9506
9507               /* Remove unused toc relocs, and adjust those we keep.  */
9508               if (toc_relocs == NULL)
9509                 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9510                                                         info->keep_memory);
9511               if (toc_relocs == NULL)
9512                 goto error_ret;
9513
9514               wrel = toc_relocs;
9515               for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9516                 if ((skip[rel->r_offset >> 3]
9517                      & (ref_from_discarded | can_optimize)) == 0)
9518                   {
9519                     wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9520                     wrel->r_info = rel->r_info;
9521                     wrel->r_addend = rel->r_addend;
9522                     ++wrel;
9523                   }
9524                 else if (!dec_dynrel_count (rel->r_info, toc, info,
9525                                             &local_syms, NULL, NULL))
9526                   goto error_ret;
9527
9528               elf_section_data (toc)->relocs = toc_relocs;
9529               toc->reloc_count = wrel - toc_relocs;
9530               rel_hdr = _bfd_elf_single_rel_hdr (toc);
9531               sz = rel_hdr->sh_entsize;
9532               rel_hdr->sh_size = toc->reloc_count * sz;
9533             }
9534         }
9535       else if (toc_relocs != NULL
9536                && elf_section_data (toc)->relocs != toc_relocs)
9537         free (toc_relocs);
9538
9539       if (local_syms != NULL
9540           && symtab_hdr->contents != (unsigned char *) local_syms)
9541         {
9542           if (!info->keep_memory)
9543             free (local_syms);
9544           else
9545             symtab_hdr->contents = (unsigned char *) local_syms;
9546         }
9547       free (skip);
9548     }
9549
9550   return TRUE;
9551 }
9552
9553 /* Return true iff input section I references the TOC using
9554    instructions limited to +/-32k offsets.  */
9555
9556 bfd_boolean
9557 ppc64_elf_has_small_toc_reloc (asection *i)
9558 {
9559   return (is_ppc64_elf (i->owner)
9560           && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9561 }
9562
9563 /* Allocate space for one GOT entry.  */
9564
9565 static void
9566 allocate_got (struct elf_link_hash_entry *h,
9567               struct bfd_link_info *info,
9568               struct got_entry *gent)
9569 {
9570   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9571   bfd_boolean dyn;
9572   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9573   int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9574                  ? 16 : 8);
9575   int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9576                   ? 2 : 1) * sizeof (Elf64_External_Rela);
9577   asection *got = ppc64_elf_tdata (gent->owner)->got;
9578
9579   gent->got.offset = got->size;
9580   got->size += entsize;
9581
9582   dyn = htab->elf.dynamic_sections_created;
9583   if (h->type == STT_GNU_IFUNC)
9584     {
9585       htab->elf.irelplt->size += rentsize;
9586       htab->got_reli_size += rentsize;
9587     }
9588   else if ((bfd_link_pic (info)
9589             || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
9590            && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9591                || h->root.type != bfd_link_hash_undefweak))
9592     {
9593       asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9594       relgot->size += rentsize;
9595     }
9596 }
9597
9598 /* This function merges got entries in the same toc group.  */
9599
9600 static void
9601 merge_got_entries (struct got_entry **pent)
9602 {
9603   struct got_entry *ent, *ent2;
9604
9605   for (ent = *pent; ent != NULL; ent = ent->next)
9606     if (!ent->is_indirect)
9607       for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9608         if (!ent2->is_indirect
9609             && ent2->addend == ent->addend
9610             && ent2->tls_type == ent->tls_type
9611             && elf_gp (ent2->owner) == elf_gp (ent->owner))
9612           {
9613             ent2->is_indirect = TRUE;
9614             ent2->got.ent = ent;
9615           }
9616 }
9617
9618 /* Allocate space in .plt, .got and associated reloc sections for
9619    dynamic relocs.  */
9620
9621 static bfd_boolean
9622 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9623 {
9624   struct bfd_link_info *info;
9625   struct ppc_link_hash_table *htab;
9626   asection *s;
9627   struct ppc_link_hash_entry *eh;
9628   struct got_entry **pgent, *gent;
9629
9630   if (h->root.type == bfd_link_hash_indirect)
9631     return TRUE;
9632
9633   info = (struct bfd_link_info *) inf;
9634   htab = ppc_hash_table (info);
9635   if (htab == NULL)
9636     return FALSE;
9637
9638   eh = (struct ppc_link_hash_entry *) h;
9639   /* Run through the TLS GD got entries first if we're changing them
9640      to TPREL.  */
9641   if ((eh->tls_mask & TLS_TPRELGD) != 0)
9642     for (gent = h->got.glist; gent != NULL; gent = gent->next)
9643       if (gent->got.refcount > 0
9644           && (gent->tls_type & TLS_GD) != 0)
9645         {
9646           /* This was a GD entry that has been converted to TPREL.  If
9647              there happens to be a TPREL entry we can use that one.  */
9648           struct got_entry *ent;
9649           for (ent = h->got.glist; ent != NULL; ent = ent->next)
9650             if (ent->got.refcount > 0
9651                 && (ent->tls_type & TLS_TPREL) != 0
9652                 && ent->addend == gent->addend
9653                 && ent->owner == gent->owner)
9654               {
9655                 gent->got.refcount = 0;
9656                 break;
9657               }
9658
9659           /* If not, then we'll be using our own TPREL entry.  */
9660           if (gent->got.refcount != 0)
9661             gent->tls_type = TLS_TLS | TLS_TPREL;
9662         }
9663
9664   /* Remove any list entry that won't generate a word in the GOT before
9665      we call merge_got_entries.  Otherwise we risk merging to empty
9666      entries.  */
9667   pgent = &h->got.glist;
9668   while ((gent = *pgent) != NULL)
9669     if (gent->got.refcount > 0)
9670       {
9671         if ((gent->tls_type & TLS_LD) != 0
9672             && !h->def_dynamic)
9673           {
9674             ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9675             *pgent = gent->next;
9676           }
9677         else
9678           pgent = &gent->next;
9679       }
9680     else
9681       *pgent = gent->next;
9682
9683   if (!htab->do_multi_toc)
9684     merge_got_entries (&h->got.glist);
9685
9686   for (gent = h->got.glist; gent != NULL; gent = gent->next)
9687     if (!gent->is_indirect)
9688       {
9689         /* Make sure this symbol is output as a dynamic symbol.
9690            Undefined weak syms won't yet be marked as dynamic,
9691            nor will all TLS symbols.  */
9692         if (h->dynindx == -1
9693             && !h->forced_local
9694             && h->type != STT_GNU_IFUNC
9695             && htab->elf.dynamic_sections_created)
9696           {
9697             if (! bfd_elf_link_record_dynamic_symbol (info, h))
9698               return FALSE;
9699           }
9700
9701         if (!is_ppc64_elf (gent->owner))
9702           abort ();
9703
9704         allocate_got (h, info, gent);
9705       }
9706
9707   if (!htab->elf.dynamic_sections_created
9708       && h->type != STT_GNU_IFUNC)
9709     eh->dyn_relocs = NULL;
9710
9711   if (eh->dyn_relocs != NULL)
9712     {
9713       struct elf_dyn_relocs *p, **pp;
9714
9715       /* In the shared -Bsymbolic case, discard space allocated for
9716          dynamic pc-relative relocs against symbols which turn out to
9717          be defined in regular objects.  For the normal shared case,
9718          discard space for relocs that have become local due to symbol
9719          visibility changes.  */
9720
9721       if (bfd_link_pic (info))
9722         {
9723           /* Relocs that use pc_count are those that appear on a call
9724              insn, or certain REL relocs (see must_be_dyn_reloc) that
9725              can be generated via assembly.  We want calls to
9726              protected symbols to resolve directly to the function
9727              rather than going via the plt.  If people want function
9728              pointer comparisons to work as expected then they should
9729              avoid writing weird assembly.  */
9730           if (SYMBOL_CALLS_LOCAL (info, h))
9731             {
9732               for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9733                 {
9734                   p->count -= p->pc_count;
9735                   p->pc_count = 0;
9736                   if (p->count == 0)
9737                     *pp = p->next;
9738                   else
9739                     pp = &p->next;
9740                 }
9741             }
9742
9743           /* Also discard relocs on undefined weak syms with
9744              non-default visibility.  */
9745           if (eh->dyn_relocs != NULL
9746               && h->root.type == bfd_link_hash_undefweak)
9747             {
9748               if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9749                 eh->dyn_relocs = NULL;
9750
9751               /* Make sure this symbol is output as a dynamic symbol.
9752                  Undefined weak syms won't yet be marked as dynamic.  */
9753               else if (h->dynindx == -1
9754                        && !h->forced_local)
9755                 {
9756                   if (! bfd_elf_link_record_dynamic_symbol (info, h))
9757                     return FALSE;
9758                 }
9759             }
9760         }
9761       else if (h->type == STT_GNU_IFUNC)
9762         {
9763           /* A plt entry is always created when making direct calls to
9764              an ifunc, even when building a static executable, but
9765              that doesn't cover all cases.  We may have only an ifunc
9766              initialised function pointer for a given ifunc symbol.
9767
9768              For ELFv2, dynamic relocations are not required when
9769              generating a global entry PLT stub.  */
9770           if (abiversion (info->output_bfd) >= 2)
9771             {
9772               if (global_entry_stub (h))
9773                 eh->dyn_relocs = NULL;
9774             }
9775
9776           /* For ELFv1 we have function descriptors.  Descriptors need
9777              to be treated like PLT entries and thus have dynamic
9778              relocations.  One exception is when the function
9779              descriptor is copied into .dynbss (which should only
9780              happen with ancient versions of gcc).  */
9781           else if (h->needs_copy)
9782             eh->dyn_relocs = NULL;
9783         }
9784       else if (ELIMINATE_COPY_RELOCS)
9785         {
9786           /* For the non-pic case, discard space for relocs against
9787              symbols which turn out to need copy relocs or are not
9788              dynamic.  */
9789
9790           /* First make sure this symbol is output as a dynamic symbol.
9791              Undefined weak syms won't yet be marked as dynamic.  */
9792           if (h->root.type == bfd_link_hash_undefweak
9793               && !h->non_got_ref
9794               && !h->def_regular
9795               && h->dynindx == -1
9796               && !h->forced_local
9797               && !bfd_elf_link_record_dynamic_symbol (info, h))
9798             return FALSE;
9799
9800           if (h->non_got_ref
9801               || h->def_regular
9802               || h->dynindx == -1)
9803             eh->dyn_relocs = NULL;
9804         }
9805
9806       /* Finally, allocate space.  */
9807       for (p = eh->dyn_relocs; p != NULL; p = p->next)
9808         {
9809           asection *sreloc = elf_section_data (p->sec)->sreloc;
9810           if (eh->elf.type == STT_GNU_IFUNC)
9811             sreloc = htab->elf.irelplt;
9812           sreloc->size += p->count * sizeof (Elf64_External_Rela);
9813         }
9814     }
9815
9816   if ((htab->elf.dynamic_sections_created
9817        && h->dynindx != -1
9818        && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
9819       || h->type == STT_GNU_IFUNC)
9820     {
9821       struct plt_entry *pent;
9822       bfd_boolean doneone = FALSE;
9823       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9824         if (pent->plt.refcount > 0)
9825           {
9826             if (!htab->elf.dynamic_sections_created
9827                 || h->dynindx == -1)
9828               {
9829                 s = htab->elf.iplt;
9830                 pent->plt.offset = s->size;
9831                 s->size += PLT_ENTRY_SIZE (htab);
9832                 s = htab->elf.irelplt;
9833               }
9834             else
9835               {
9836                 /* If this is the first .plt entry, make room for the special
9837                    first entry.  */
9838                 s = htab->elf.splt;
9839                 if (s->size == 0)
9840                   s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9841
9842                 pent->plt.offset = s->size;
9843
9844                 /* Make room for this entry.  */
9845                 s->size += PLT_ENTRY_SIZE (htab);
9846
9847                 /* Make room for the .glink code.  */
9848                 s = htab->glink;
9849                 if (s->size == 0)
9850                   s->size += GLINK_CALL_STUB_SIZE;
9851                 if (htab->opd_abi)
9852                   {
9853                     /* We need bigger stubs past index 32767.  */
9854                     if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9855                       s->size += 4;
9856                     s->size += 2*4;
9857                   }
9858                 else
9859                   s->size += 4;
9860
9861                 /* We also need to make an entry in the .rela.plt section.  */
9862                 s = htab->elf.srelplt;
9863               }
9864             s->size += sizeof (Elf64_External_Rela);
9865             doneone = TRUE;
9866           }
9867         else
9868           pent->plt.offset = (bfd_vma) -1;
9869       if (!doneone)
9870         {
9871           h->plt.plist = NULL;
9872           h->needs_plt = 0;
9873         }
9874     }
9875   else
9876     {
9877       h->plt.plist = NULL;
9878       h->needs_plt = 0;
9879     }
9880
9881   return TRUE;
9882 }
9883
9884 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9885    to set up space for global entry stubs.  These are put in glink,
9886    after the branch table.  */
9887
9888 static bfd_boolean
9889 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
9890 {
9891   struct bfd_link_info *info;
9892   struct ppc_link_hash_table *htab;
9893   struct plt_entry *pent;
9894   asection *s;
9895
9896   if (h->root.type == bfd_link_hash_indirect)
9897     return TRUE;
9898
9899   if (!h->pointer_equality_needed)
9900     return TRUE;
9901
9902   if (h->def_regular)
9903     return TRUE;
9904
9905   info = inf;
9906   htab = ppc_hash_table (info);
9907   if (htab == NULL)
9908     return FALSE;
9909
9910   s = htab->glink;
9911   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9912     if (pent->plt.offset != (bfd_vma) -1
9913         && pent->addend == 0)
9914       {
9915         /* For ELFv2, if this symbol is not defined in a regular file
9916            and we are not generating a shared library or pie, then we
9917            need to define the symbol in the executable on a call stub.
9918            This is to avoid text relocations.  */
9919         s->size = (s->size + 15) & -16;
9920         h->root.type = bfd_link_hash_defined;
9921         h->root.u.def.section = s;
9922         h->root.u.def.value = s->size;
9923         s->size += 16;
9924         break;
9925       }
9926   return TRUE;
9927 }
9928
9929 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9930    read-only sections.  */
9931
9932 static bfd_boolean
9933 maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
9934 {
9935   if (h->root.type == bfd_link_hash_indirect)
9936     return TRUE;
9937
9938   if (readonly_dynrelocs (h))
9939     {
9940       ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
9941
9942       /* Not an error, just cut short the traversal.  */
9943       return FALSE;
9944     }
9945   return TRUE;
9946 }
9947
9948 /* Set the sizes of the dynamic sections.  */
9949
9950 static bfd_boolean
9951 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
9952                                  struct bfd_link_info *info)
9953 {
9954   struct ppc_link_hash_table *htab;
9955   bfd *dynobj;
9956   asection *s;
9957   bfd_boolean relocs;
9958   bfd *ibfd;
9959   struct got_entry *first_tlsld;
9960
9961   htab = ppc_hash_table (info);
9962   if (htab == NULL)
9963     return FALSE;
9964
9965   dynobj = htab->elf.dynobj;
9966   if (dynobj == NULL)
9967     abort ();
9968
9969   if (htab->elf.dynamic_sections_created)
9970     {
9971       /* Set the contents of the .interp section to the interpreter.  */
9972       if (bfd_link_executable (info) && !info->nointerp)
9973         {
9974           s = bfd_get_linker_section (dynobj, ".interp");
9975           if (s == NULL)
9976             abort ();
9977           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
9978           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
9979         }
9980     }
9981
9982   /* Set up .got offsets for local syms, and space for local dynamic
9983      relocs.  */
9984   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9985     {
9986       struct got_entry **lgot_ents;
9987       struct got_entry **end_lgot_ents;
9988       struct plt_entry **local_plt;
9989       struct plt_entry **end_local_plt;
9990       unsigned char *lgot_masks;
9991       bfd_size_type locsymcount;
9992       Elf_Internal_Shdr *symtab_hdr;
9993
9994       if (!is_ppc64_elf (ibfd))
9995         continue;
9996
9997       for (s = ibfd->sections; s != NULL; s = s->next)
9998         {
9999           struct ppc_dyn_relocs *p;
10000
10001           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
10002             {
10003               if (!bfd_is_abs_section (p->sec)
10004                   && bfd_is_abs_section (p->sec->output_section))
10005                 {
10006                   /* Input section has been discarded, either because
10007                      it is a copy of a linkonce section or due to
10008                      linker script /DISCARD/, so we'll be discarding
10009                      the relocs too.  */
10010                 }
10011               else if (p->count != 0)
10012                 {
10013                   asection *srel = elf_section_data (p->sec)->sreloc;
10014                   if (p->ifunc)
10015                     srel = htab->elf.irelplt;
10016                   srel->size += p->count * sizeof (Elf64_External_Rela);
10017                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
10018                     info->flags |= DF_TEXTREL;
10019                 }
10020             }
10021         }
10022
10023       lgot_ents = elf_local_got_ents (ibfd);
10024       if (!lgot_ents)
10025         continue;
10026
10027       symtab_hdr = &elf_symtab_hdr (ibfd);
10028       locsymcount = symtab_hdr->sh_info;
10029       end_lgot_ents = lgot_ents + locsymcount;
10030       local_plt = (struct plt_entry **) end_lgot_ents;
10031       end_local_plt = local_plt + locsymcount;
10032       lgot_masks = (unsigned char *) end_local_plt;
10033       s = ppc64_elf_tdata (ibfd)->got;
10034       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
10035         {
10036           struct got_entry **pent, *ent;
10037
10038           pent = lgot_ents;
10039           while ((ent = *pent) != NULL)
10040             if (ent->got.refcount > 0)
10041               {
10042                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
10043                   {
10044                     ppc64_tlsld_got (ibfd)->got.refcount += 1;
10045                     *pent = ent->next;
10046                   }
10047                 else
10048                   {
10049                     unsigned int ent_size = 8;
10050                     unsigned int rel_size = sizeof (Elf64_External_Rela);
10051
10052                     ent->got.offset = s->size;
10053                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
10054                       {
10055                         ent_size *= 2;
10056                         rel_size *= 2;
10057                       }
10058                     s->size += ent_size;
10059                     if ((*lgot_masks & PLT_IFUNC) != 0)
10060                       {
10061                         htab->elf.irelplt->size += rel_size;
10062                         htab->got_reli_size += rel_size;
10063                       }
10064                     else if (bfd_link_pic (info))
10065                       {
10066                         asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10067                         srel->size += rel_size;
10068                       }
10069                     pent = &ent->next;
10070                   }
10071               }
10072             else
10073               *pent = ent->next;
10074         }
10075
10076       /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt.  */
10077       for (; local_plt < end_local_plt; ++local_plt)
10078         {
10079           struct plt_entry *ent;
10080
10081           for (ent = *local_plt; ent != NULL; ent = ent->next)
10082             if (ent->plt.refcount > 0)
10083               {
10084                 s = htab->elf.iplt;
10085                 ent->plt.offset = s->size;
10086                 s->size += PLT_ENTRY_SIZE (htab);
10087
10088                 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
10089               }
10090             else
10091               ent->plt.offset = (bfd_vma) -1;
10092         }
10093     }
10094
10095   /* Allocate global sym .plt and .got entries, and space for global
10096      sym dynamic relocs.  */
10097   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
10098   /* Stash the end of glink branch table.  */
10099   if (htab->glink != NULL)
10100     htab->glink->rawsize = htab->glink->size;
10101
10102   if (!htab->opd_abi && !bfd_link_pic (info))
10103     elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
10104
10105   first_tlsld = NULL;
10106   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10107     {
10108       struct got_entry *ent;
10109
10110       if (!is_ppc64_elf (ibfd))
10111         continue;
10112
10113       ent = ppc64_tlsld_got (ibfd);
10114       if (ent->got.refcount > 0)
10115         {
10116           if (!htab->do_multi_toc && first_tlsld != NULL)
10117             {
10118               ent->is_indirect = TRUE;
10119               ent->got.ent = first_tlsld;
10120             }
10121           else
10122             {
10123               if (first_tlsld == NULL)
10124                 first_tlsld = ent;
10125               s = ppc64_elf_tdata (ibfd)->got;
10126               ent->got.offset = s->size;
10127               ent->owner = ibfd;
10128               s->size += 16;
10129               if (bfd_link_pic (info))
10130                 {
10131                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10132                   srel->size += sizeof (Elf64_External_Rela);
10133                 }
10134             }
10135         }
10136       else
10137         ent->got.offset = (bfd_vma) -1;
10138     }
10139
10140   /* We now have determined the sizes of the various dynamic sections.
10141      Allocate memory for them.  */
10142   relocs = FALSE;
10143   for (s = dynobj->sections; s != NULL; s = s->next)
10144     {
10145       if ((s->flags & SEC_LINKER_CREATED) == 0)
10146         continue;
10147
10148       if (s == htab->brlt || s == htab->relbrlt)
10149         /* These haven't been allocated yet;  don't strip.  */
10150         continue;
10151       else if (s == htab->elf.sgot
10152                || s == htab->elf.splt
10153                || s == htab->elf.iplt
10154                || s == htab->glink
10155                || s == htab->dynbss)
10156         {
10157           /* Strip this section if we don't need it; see the
10158              comment below.  */
10159         }
10160       else if (s == htab->glink_eh_frame)
10161         {
10162           if (!bfd_is_abs_section (s->output_section))
10163             /* Not sized yet.  */
10164             continue;
10165         }
10166       else if (CONST_STRNEQ (s->name, ".rela"))
10167         {
10168           if (s->size != 0)
10169             {
10170               if (s != htab->elf.srelplt)
10171                 relocs = TRUE;
10172
10173               /* We use the reloc_count field as a counter if we need
10174                  to copy relocs into the output file.  */
10175               s->reloc_count = 0;
10176             }
10177         }
10178       else
10179         {
10180           /* It's not one of our sections, so don't allocate space.  */
10181           continue;
10182         }
10183
10184       if (s->size == 0)
10185         {
10186           /* If we don't need this section, strip it from the
10187              output file.  This is mostly to handle .rela.bss and
10188              .rela.plt.  We must create both sections in
10189              create_dynamic_sections, because they must be created
10190              before the linker maps input sections to output
10191              sections.  The linker does that before
10192              adjust_dynamic_symbol is called, and it is that
10193              function which decides whether anything needs to go
10194              into these sections.  */
10195           s->flags |= SEC_EXCLUDE;
10196           continue;
10197         }
10198
10199       if ((s->flags & SEC_HAS_CONTENTS) == 0)
10200         continue;
10201
10202       /* Allocate memory for the section contents.  We use bfd_zalloc
10203          here in case unused entries are not reclaimed before the
10204          section's contents are written out.  This should not happen,
10205          but this way if it does we get a R_PPC64_NONE reloc in .rela
10206          sections instead of garbage.
10207          We also rely on the section contents being zero when writing
10208          the GOT.  */
10209       s->contents = bfd_zalloc (dynobj, s->size);
10210       if (s->contents == NULL)
10211         return FALSE;
10212     }
10213
10214   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10215     {
10216       if (!is_ppc64_elf (ibfd))
10217         continue;
10218
10219       s = ppc64_elf_tdata (ibfd)->got;
10220       if (s != NULL && s != htab->elf.sgot)
10221         {
10222           if (s->size == 0)
10223             s->flags |= SEC_EXCLUDE;
10224           else
10225             {
10226               s->contents = bfd_zalloc (ibfd, s->size);
10227               if (s->contents == NULL)
10228                 return FALSE;
10229             }
10230         }
10231       s = ppc64_elf_tdata (ibfd)->relgot;
10232       if (s != NULL)
10233         {
10234           if (s->size == 0)
10235             s->flags |= SEC_EXCLUDE;
10236           else
10237             {
10238               s->contents = bfd_zalloc (ibfd, s->size);
10239               if (s->contents == NULL)
10240                 return FALSE;
10241               relocs = TRUE;
10242               s->reloc_count = 0;
10243             }
10244         }
10245     }
10246
10247   if (htab->elf.dynamic_sections_created)
10248     {
10249       bfd_boolean tls_opt;
10250
10251       /* Add some entries to the .dynamic section.  We fill in the
10252          values later, in ppc64_elf_finish_dynamic_sections, but we
10253          must add the entries now so that we get the correct size for
10254          the .dynamic section.  The DT_DEBUG entry is filled in by the
10255          dynamic linker and used by the debugger.  */
10256 #define add_dynamic_entry(TAG, VAL) \
10257   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10258
10259       if (bfd_link_executable (info))
10260         {
10261           if (!add_dynamic_entry (DT_DEBUG, 0))
10262             return FALSE;
10263         }
10264
10265       if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
10266         {
10267           if (!add_dynamic_entry (DT_PLTGOT, 0)
10268               || !add_dynamic_entry (DT_PLTRELSZ, 0)
10269               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
10270               || !add_dynamic_entry (DT_JMPREL, 0)
10271               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
10272             return FALSE;
10273         }
10274
10275       if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
10276         {
10277           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
10278               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
10279             return FALSE;
10280         }
10281
10282       tls_opt = (htab->params->tls_get_addr_opt
10283                  && htab->tls_get_addr_fd != NULL
10284                  && htab->tls_get_addr_fd->elf.plt.plist != NULL);
10285       if (tls_opt || !htab->opd_abi)
10286         {
10287           if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
10288             return FALSE;
10289         }
10290
10291       if (relocs)
10292         {
10293           if (!add_dynamic_entry (DT_RELA, 0)
10294               || !add_dynamic_entry (DT_RELASZ, 0)
10295               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
10296             return FALSE;
10297
10298           /* If any dynamic relocs apply to a read-only section,
10299              then we need a DT_TEXTREL entry.  */
10300           if ((info->flags & DF_TEXTREL) == 0)
10301             elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
10302
10303           if ((info->flags & DF_TEXTREL) != 0)
10304             {
10305               if (!add_dynamic_entry (DT_TEXTREL, 0))
10306                 return FALSE;
10307             }
10308         }
10309     }
10310 #undef add_dynamic_entry
10311
10312   return TRUE;
10313 }
10314
10315 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
10316
10317 static bfd_boolean
10318 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
10319 {
10320   if (h->plt.plist != NULL
10321       && !h->def_regular
10322       && !h->pointer_equality_needed)
10323     return FALSE;
10324
10325   return _bfd_elf_hash_symbol (h);
10326 }
10327
10328 /* Determine the type of stub needed, if any, for a call.  */
10329
10330 static inline enum ppc_stub_type
10331 ppc_type_of_stub (asection *input_sec,
10332                   const Elf_Internal_Rela *rel,
10333                   struct ppc_link_hash_entry **hash,
10334                   struct plt_entry **plt_ent,
10335                   bfd_vma destination,
10336                   unsigned long local_off)
10337 {
10338   struct ppc_link_hash_entry *h = *hash;
10339   bfd_vma location;
10340   bfd_vma branch_offset;
10341   bfd_vma max_branch_offset;
10342   enum elf_ppc64_reloc_type r_type;
10343
10344   if (h != NULL)
10345     {
10346       struct plt_entry *ent;
10347       struct ppc_link_hash_entry *fdh = h;
10348       if (h->oh != NULL
10349           && h->oh->is_func_descriptor)
10350         {
10351           fdh = ppc_follow_link (h->oh);
10352           *hash = fdh;
10353         }
10354
10355       for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10356         if (ent->addend == rel->r_addend
10357             && ent->plt.offset != (bfd_vma) -1)
10358           {
10359             *plt_ent = ent;
10360             return ppc_stub_plt_call;
10361           }
10362
10363       /* Here, we know we don't have a plt entry.  If we don't have a
10364          either a defined function descriptor or a defined entry symbol
10365          in a regular object file, then it is pointless trying to make
10366          any other type of stub.  */
10367       if (!is_static_defined (&fdh->elf)
10368           && !is_static_defined (&h->elf))
10369         return ppc_stub_none;
10370     }
10371   else if (elf_local_got_ents (input_sec->owner) != NULL)
10372     {
10373       Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10374       struct plt_entry **local_plt = (struct plt_entry **)
10375         elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10376       unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10377
10378       if (local_plt[r_symndx] != NULL)
10379         {
10380           struct plt_entry *ent;
10381
10382           for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10383             if (ent->addend == rel->r_addend
10384                 && ent->plt.offset != (bfd_vma) -1)
10385               {
10386                 *plt_ent = ent;
10387                 return ppc_stub_plt_call;
10388               }
10389         }
10390     }
10391
10392   /* Determine where the call point is.  */
10393   location = (input_sec->output_offset
10394               + input_sec->output_section->vma
10395               + rel->r_offset);
10396
10397   branch_offset = destination - location;
10398   r_type = ELF64_R_TYPE (rel->r_info);
10399
10400   /* Determine if a long branch stub is needed.  */
10401   max_branch_offset = 1 << 25;
10402   if (r_type != R_PPC64_REL24)
10403     max_branch_offset = 1 << 15;
10404
10405   if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10406     /* We need a stub.  Figure out whether a long_branch or plt_branch
10407        is needed later.  */
10408     return ppc_stub_long_branch;
10409
10410   return ppc_stub_none;
10411 }
10412
10413 /* With power7 weakly ordered memory model, it is possible for ld.so
10414    to update a plt entry in one thread and have another thread see a
10415    stale zero toc entry.  To avoid this we need some sort of acquire
10416    barrier in the call stub.  One solution is to make the load of the
10417    toc word seem to appear to depend on the load of the function entry
10418    word.  Another solution is to test for r2 being zero, and branch to
10419    the appropriate glink entry if so.
10420
10421    .    fake dep barrier        compare
10422    .    ld 12,xxx(2)            ld 12,xxx(2)
10423    .    mtctr 12                mtctr 12
10424    .    xor 11,12,12            ld 2,xxx+8(2)
10425    .    add 2,2,11              cmpldi 2,0
10426    .    ld 2,xxx+8(2)           bnectr+
10427    .    bctr                    b <glink_entry>
10428
10429    The solution involving the compare turns out to be faster, so
10430    that's what we use unless the branch won't reach.  */
10431
10432 #define ALWAYS_USE_FAKE_DEP 0
10433 #define ALWAYS_EMIT_R2SAVE 0
10434
10435 #define PPC_LO(v) ((v) & 0xffff)
10436 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10437 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10438
10439 static inline unsigned int
10440 plt_stub_size (struct ppc_link_hash_table *htab,
10441                struct ppc_stub_hash_entry *stub_entry,
10442                bfd_vma off)
10443 {
10444   unsigned size = 12;
10445
10446   if (ALWAYS_EMIT_R2SAVE
10447       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10448     size += 4;
10449   if (PPC_HA (off) != 0)
10450     size += 4;
10451   if (htab->opd_abi)
10452     {
10453       size += 4;
10454       if (htab->params->plt_static_chain)
10455         size += 4;
10456       if (htab->params->plt_thread_safe
10457           && htab->elf.dynamic_sections_created
10458           && stub_entry->h != NULL
10459           && stub_entry->h->elf.dynindx != -1)
10460         size += 8;
10461       if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
10462         size += 4;
10463     }
10464   if (stub_entry->h != NULL
10465       && (stub_entry->h == htab->tls_get_addr_fd
10466           || stub_entry->h == htab->tls_get_addr)
10467       && htab->params->tls_get_addr_opt)
10468     size += 13 * 4;
10469   return size;
10470 }
10471
10472 /* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
10473    then return the padding needed to do so.  */
10474 static inline unsigned int
10475 plt_stub_pad (struct ppc_link_hash_table *htab,
10476               struct ppc_stub_hash_entry *stub_entry,
10477               bfd_vma plt_off)
10478 {
10479   int stub_align = 1 << htab->params->plt_stub_align;
10480   unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10481   bfd_vma stub_off = stub_entry->group->stub_sec->size;
10482
10483   if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10484       > ((stub_size - 1) & -stub_align))
10485     return stub_align - (stub_off & (stub_align - 1));
10486   return 0;
10487 }
10488
10489 /* Build a .plt call stub.  */
10490
10491 static inline bfd_byte *
10492 build_plt_stub (struct ppc_link_hash_table *htab,
10493                 struct ppc_stub_hash_entry *stub_entry,
10494                 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10495 {
10496   bfd *obfd = htab->params->stub_bfd;
10497   bfd_boolean plt_load_toc = htab->opd_abi;
10498   bfd_boolean plt_static_chain = htab->params->plt_static_chain;
10499   bfd_boolean plt_thread_safe = (htab->params->plt_thread_safe
10500                                  && htab->elf.dynamic_sections_created
10501                                  && stub_entry->h != NULL
10502                                  && stub_entry->h->elf.dynindx != -1);
10503   bfd_boolean use_fake_dep = plt_thread_safe;
10504   bfd_vma cmp_branch_off = 0;
10505
10506   if (!ALWAYS_USE_FAKE_DEP
10507       && plt_load_toc
10508       && plt_thread_safe
10509       && !((stub_entry->h == htab->tls_get_addr_fd
10510             || stub_entry->h == htab->tls_get_addr)
10511            && htab->params->tls_get_addr_opt))
10512     {
10513       bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10514       bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10515                           / PLT_ENTRY_SIZE (htab));
10516       bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10517       bfd_vma to, from;
10518
10519       if (pltindex > 32768)
10520         glinkoff += (pltindex - 32768) * 4;
10521       to = (glinkoff
10522             + htab->glink->output_offset
10523             + htab->glink->output_section->vma);
10524       from = (p - stub_entry->group->stub_sec->contents
10525               + 4 * (ALWAYS_EMIT_R2SAVE
10526                      || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10527               + 4 * (PPC_HA (offset) != 0)
10528               + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10529                      != PPC_HA (offset))
10530               + 4 * (plt_static_chain != 0)
10531               + 20
10532               + stub_entry->group->stub_sec->output_offset
10533               + stub_entry->group->stub_sec->output_section->vma);
10534       cmp_branch_off = to - from;
10535       use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10536     }
10537
10538   if (PPC_HA (offset) != 0)
10539     {
10540       if (r != NULL)
10541         {
10542           if (ALWAYS_EMIT_R2SAVE
10543               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10544             r[0].r_offset += 4;
10545           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10546           r[1].r_offset = r[0].r_offset + 4;
10547           r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10548           r[1].r_addend = r[0].r_addend;
10549           if (plt_load_toc)
10550             {
10551               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10552                 {
10553                   r[2].r_offset = r[1].r_offset + 4;
10554                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10555                   r[2].r_addend = r[0].r_addend;
10556                 }
10557               else
10558                 {
10559                   r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10560                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10561                   r[2].r_addend = r[0].r_addend + 8;
10562                   if (plt_static_chain)
10563                     {
10564                       r[3].r_offset = r[2].r_offset + 4;
10565                       r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10566                       r[3].r_addend = r[0].r_addend + 16;
10567                     }
10568                 }
10569             }
10570         }
10571       if (ALWAYS_EMIT_R2SAVE
10572           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10573         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10574       if (plt_load_toc)
10575         {
10576           bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10577           bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p),  p += 4;
10578         }
10579       else
10580         {
10581           bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
10582           bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p),  p += 4;
10583         }
10584       if (plt_load_toc
10585           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10586         {
10587           bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10588           offset = 0;
10589         }
10590       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10591       if (plt_load_toc)
10592         {
10593           if (use_fake_dep)
10594             {
10595               bfd_put_32 (obfd, XOR_R2_R12_R12, p),             p += 4;
10596               bfd_put_32 (obfd, ADD_R11_R11_R2, p),             p += 4;
10597             }
10598           bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10599           if (plt_static_chain)
10600             bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10601         }
10602     }
10603   else
10604     {
10605       if (r != NULL)
10606         {
10607           if (ALWAYS_EMIT_R2SAVE
10608               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10609             r[0].r_offset += 4;
10610           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10611           if (plt_load_toc)
10612             {
10613               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10614                 {
10615                   r[1].r_offset = r[0].r_offset + 4;
10616                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10617                   r[1].r_addend = r[0].r_addend;
10618                 }
10619               else
10620                 {
10621                   r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10622                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10623                   r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10624                   if (plt_static_chain)
10625                     {
10626                       r[2].r_offset = r[1].r_offset + 4;
10627                       r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10628                       r[2].r_addend = r[0].r_addend + 8;
10629                     }
10630                 }
10631             }
10632         }
10633       if (ALWAYS_EMIT_R2SAVE
10634           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10635         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10636       bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p),       p += 4;
10637       if (plt_load_toc
10638           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10639         {
10640           bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),   p += 4;
10641           offset = 0;
10642         }
10643       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10644       if (plt_load_toc)
10645         {
10646           if (use_fake_dep)
10647             {
10648               bfd_put_32 (obfd, XOR_R11_R12_R12, p),            p += 4;
10649               bfd_put_32 (obfd, ADD_R2_R2_R11, p),              p += 4;
10650             }
10651           if (plt_static_chain)
10652             bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10653           bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10654         }
10655     }
10656   if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10657     {
10658       bfd_put_32 (obfd, CMPLDI_R2_0, p),                        p += 4;
10659       bfd_put_32 (obfd, BNECTR_P4, p),                          p += 4;
10660       bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10661     }
10662   else
10663     bfd_put_32 (obfd, BCTR, p),                                 p += 4;
10664   return p;
10665 }
10666
10667 /* Build a special .plt call stub for __tls_get_addr.  */
10668
10669 #define LD_R11_0R3      0xe9630000
10670 #define LD_R12_0R3      0xe9830000
10671 #define MR_R0_R3        0x7c601b78
10672 #define CMPDI_R11_0     0x2c2b0000
10673 #define ADD_R3_R12_R13  0x7c6c6a14
10674 #define BEQLR           0x4d820020
10675 #define MR_R3_R0        0x7c030378
10676 #define STD_R11_0R1     0xf9610000
10677 #define BCTRL           0x4e800421
10678 #define LD_R11_0R1      0xe9610000
10679 #define MTLR_R11        0x7d6803a6
10680
10681 static inline bfd_byte *
10682 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10683                          struct ppc_stub_hash_entry *stub_entry,
10684                          bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10685 {
10686   bfd *obfd = htab->params->stub_bfd;
10687
10688   bfd_put_32 (obfd, LD_R11_0R3 + 0, p),         p += 4;
10689   bfd_put_32 (obfd, LD_R12_0R3 + 8, p),         p += 4;
10690   bfd_put_32 (obfd, MR_R0_R3, p),               p += 4;
10691   bfd_put_32 (obfd, CMPDI_R11_0, p),            p += 4;
10692   bfd_put_32 (obfd, ADD_R3_R12_R13, p),         p += 4;
10693   bfd_put_32 (obfd, BEQLR, p),                  p += 4;
10694   bfd_put_32 (obfd, MR_R3_R0, p),               p += 4;
10695   bfd_put_32 (obfd, MFLR_R11, p),               p += 4;
10696   bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10697
10698   if (r != NULL)
10699     r[0].r_offset += 9 * 4;
10700   p = build_plt_stub (htab, stub_entry, p, offset, r);
10701   bfd_put_32 (obfd, BCTRL, p - 4);
10702
10703   bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p),     p += 4;
10704   bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10705   bfd_put_32 (obfd, MTLR_R11, p),               p += 4;
10706   bfd_put_32 (obfd, BLR, p),                    p += 4;
10707
10708   return p;
10709 }
10710
10711 static Elf_Internal_Rela *
10712 get_relocs (asection *sec, int count)
10713 {
10714   Elf_Internal_Rela *relocs;
10715   struct bfd_elf_section_data *elfsec_data;
10716
10717   elfsec_data = elf_section_data (sec);
10718   relocs = elfsec_data->relocs;
10719   if (relocs == NULL)
10720     {
10721       bfd_size_type relsize;
10722       relsize = sec->reloc_count * sizeof (*relocs);
10723       relocs = bfd_alloc (sec->owner, relsize);
10724       if (relocs == NULL)
10725         return NULL;
10726       elfsec_data->relocs = relocs;
10727       elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10728                                           sizeof (Elf_Internal_Shdr));
10729       if (elfsec_data->rela.hdr == NULL)
10730         return NULL;
10731       elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10732                                         * sizeof (Elf64_External_Rela));
10733       elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10734       sec->reloc_count = 0;
10735     }
10736   relocs += sec->reloc_count;
10737   sec->reloc_count += count;
10738   return relocs;
10739 }
10740
10741 static bfd_vma
10742 get_r2off (struct bfd_link_info *info,
10743            struct ppc_stub_hash_entry *stub_entry)
10744 {
10745   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10746   bfd_vma r2off = htab->sec_info[stub_entry->target_section->id].toc_off;
10747
10748   if (r2off == 0)
10749     {
10750       /* Support linking -R objects.  Get the toc pointer from the
10751          opd entry.  */
10752       char buf[8];
10753       if (!htab->opd_abi)
10754         return r2off;
10755       asection *opd = stub_entry->h->elf.root.u.def.section;
10756       bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10757
10758       if (strcmp (opd->name, ".opd") != 0
10759           || opd->reloc_count != 0)
10760         {
10761           info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
10762                                   stub_entry->h->elf.root.root.string);
10763           bfd_set_error (bfd_error_bad_value);
10764           return (bfd_vma) -1;
10765         }
10766       if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10767         return (bfd_vma) -1;
10768       r2off = bfd_get_64 (opd->owner, buf);
10769       r2off -= elf_gp (info->output_bfd);
10770     }
10771   r2off -= htab->sec_info[stub_entry->group->link_sec->id].toc_off;
10772   return r2off;
10773 }
10774
10775 static bfd_boolean
10776 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10777 {
10778   struct ppc_stub_hash_entry *stub_entry;
10779   struct ppc_branch_hash_entry *br_entry;
10780   struct bfd_link_info *info;
10781   struct ppc_link_hash_table *htab;
10782   bfd_byte *loc;
10783   bfd_byte *p;
10784   bfd_vma dest, off;
10785   int size;
10786   Elf_Internal_Rela *r;
10787   asection *plt;
10788
10789   /* Massage our args to the form they really have.  */
10790   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10791   info = in_arg;
10792
10793   htab = ppc_hash_table (info);
10794   if (htab == NULL)
10795     return FALSE;
10796
10797   /* Make a note of the offset within the stubs for this entry.  */
10798   stub_entry->stub_offset = stub_entry->group->stub_sec->size;
10799   loc = stub_entry->group->stub_sec->contents + stub_entry->stub_offset;
10800
10801   htab->stub_count[stub_entry->stub_type - 1] += 1;
10802   switch (stub_entry->stub_type)
10803     {
10804     case ppc_stub_long_branch:
10805     case ppc_stub_long_branch_r2off:
10806       /* Branches are relative.  This is where we are going to.  */
10807       dest = (stub_entry->target_value
10808               + stub_entry->target_section->output_offset
10809               + stub_entry->target_section->output_section->vma);
10810       dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10811       off = dest;
10812
10813       /* And this is where we are coming from.  */
10814       off -= (stub_entry->stub_offset
10815               + stub_entry->group->stub_sec->output_offset
10816               + stub_entry->group->stub_sec->output_section->vma);
10817
10818       size = 4;
10819       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10820         {
10821           bfd_vma r2off = get_r2off (info, stub_entry);
10822
10823           if (r2off == (bfd_vma) -1)
10824             {
10825               htab->stub_error = TRUE;
10826               return FALSE;
10827             }
10828           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10829           loc += 4;
10830           size = 8;
10831           if (PPC_HA (r2off) != 0)
10832             {
10833               bfd_put_32 (htab->params->stub_bfd,
10834                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
10835               loc += 4;
10836               size += 4;
10837             }
10838           if (PPC_LO (r2off) != 0)
10839             {
10840               bfd_put_32 (htab->params->stub_bfd,
10841                           ADDI_R2_R2 | PPC_LO (r2off), loc);
10842               loc += 4;
10843               size += 4;
10844             }
10845           off -= size - 4;
10846         }
10847       bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10848
10849       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10850         {
10851           info->callbacks->einfo
10852             (_("%P: long branch stub `%s' offset overflow\n"),
10853              stub_entry->root.string);
10854           htab->stub_error = TRUE;
10855           return FALSE;
10856         }
10857
10858       if (info->emitrelocations)
10859         {
10860           r = get_relocs (stub_entry->group->stub_sec, 1);
10861           if (r == NULL)
10862             return FALSE;
10863           r->r_offset = loc - stub_entry->group->stub_sec->contents;
10864           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10865           r->r_addend = dest;
10866           if (stub_entry->h != NULL)
10867             {
10868               struct elf_link_hash_entry **hashes;
10869               unsigned long symndx;
10870               struct ppc_link_hash_entry *h;
10871
10872               hashes = elf_sym_hashes (htab->params->stub_bfd);
10873               if (hashes == NULL)
10874                 {
10875                   bfd_size_type hsize;
10876
10877                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10878                   hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
10879                   if (hashes == NULL)
10880                     return FALSE;
10881                   elf_sym_hashes (htab->params->stub_bfd) = hashes;
10882                   htab->stub_globals = 1;
10883                 }
10884               symndx = htab->stub_globals++;
10885               h = stub_entry->h;
10886               hashes[symndx] = &h->elf;
10887               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10888               if (h->oh != NULL && h->oh->is_func)
10889                 h = ppc_follow_link (h->oh);
10890               if (h->elf.root.u.def.section != stub_entry->target_section)
10891                 /* H is an opd symbol.  The addend must be zero.  */
10892                 r->r_addend = 0;
10893               else
10894                 {
10895                   off = (h->elf.root.u.def.value
10896                          + h->elf.root.u.def.section->output_offset
10897                          + h->elf.root.u.def.section->output_section->vma);
10898                   r->r_addend -= off;
10899                 }
10900             }
10901         }
10902       break;
10903
10904     case ppc_stub_plt_branch:
10905     case ppc_stub_plt_branch_r2off:
10906       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10907                                          stub_entry->root.string + 9,
10908                                          FALSE, FALSE);
10909       if (br_entry == NULL)
10910         {
10911           info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
10912                                   stub_entry->root.string);
10913           htab->stub_error = TRUE;
10914           return FALSE;
10915         }
10916
10917       dest = (stub_entry->target_value
10918               + stub_entry->target_section->output_offset
10919               + stub_entry->target_section->output_section->vma);
10920       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10921         dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10922
10923       bfd_put_64 (htab->brlt->owner, dest,
10924                   htab->brlt->contents + br_entry->offset);
10925
10926       if (br_entry->iter == htab->stub_iteration)
10927         {
10928           br_entry->iter = 0;
10929
10930           if (htab->relbrlt != NULL)
10931             {
10932               /* Create a reloc for the branch lookup table entry.  */
10933               Elf_Internal_Rela rela;
10934               bfd_byte *rl;
10935
10936               rela.r_offset = (br_entry->offset
10937                                + htab->brlt->output_offset
10938                                + htab->brlt->output_section->vma);
10939               rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10940               rela.r_addend = dest;
10941
10942               rl = htab->relbrlt->contents;
10943               rl += (htab->relbrlt->reloc_count++
10944                      * sizeof (Elf64_External_Rela));
10945               bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
10946             }
10947           else if (info->emitrelocations)
10948             {
10949               r = get_relocs (htab->brlt, 1);
10950               if (r == NULL)
10951                 return FALSE;
10952               /* brlt, being SEC_LINKER_CREATED does not go through the
10953                  normal reloc processing.  Symbols and offsets are not
10954                  translated from input file to output file form, so
10955                  set up the offset per the output file.  */
10956               r->r_offset = (br_entry->offset
10957                              + htab->brlt->output_offset
10958                              + htab->brlt->output_section->vma);
10959               r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10960               r->r_addend = dest;
10961             }
10962         }
10963
10964       dest = (br_entry->offset
10965               + htab->brlt->output_offset
10966               + htab->brlt->output_section->vma);
10967
10968       off = (dest
10969              - elf_gp (htab->brlt->output_section->owner)
10970              - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
10971
10972       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10973         {
10974           info->callbacks->einfo
10975             (_("%P: linkage table error against `%T'\n"),
10976              stub_entry->root.string);
10977           bfd_set_error (bfd_error_bad_value);
10978           htab->stub_error = TRUE;
10979           return FALSE;
10980         }
10981
10982       if (info->emitrelocations)
10983         {
10984           r = get_relocs (stub_entry->group->stub_sec, 1 + (PPC_HA (off) != 0));
10985           if (r == NULL)
10986             return FALSE;
10987           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
10988           if (bfd_big_endian (info->output_bfd))
10989             r[0].r_offset += 2;
10990           if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
10991             r[0].r_offset += 4;
10992           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10993           r[0].r_addend = dest;
10994           if (PPC_HA (off) != 0)
10995             {
10996               r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10997               r[1].r_offset = r[0].r_offset + 4;
10998               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10999               r[1].r_addend = r[0].r_addend;
11000             }
11001         }
11002
11003       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11004         {
11005           if (PPC_HA (off) != 0)
11006             {
11007               size = 16;
11008               bfd_put_32 (htab->params->stub_bfd,
11009                           ADDIS_R12_R2 | PPC_HA (off), loc);
11010               loc += 4;
11011               bfd_put_32 (htab->params->stub_bfd,
11012                           LD_R12_0R12 | PPC_LO (off), loc);
11013             }
11014           else
11015             {
11016               size = 12;
11017               bfd_put_32 (htab->params->stub_bfd,
11018                           LD_R12_0R2 | PPC_LO (off), loc);
11019             }
11020         }
11021       else
11022         {
11023           bfd_vma r2off = get_r2off (info, stub_entry);
11024
11025           if (r2off == (bfd_vma) -1)
11026             {
11027               htab->stub_error = TRUE;
11028               return FALSE;
11029             }
11030
11031           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
11032           loc += 4;
11033           size = 16;
11034           if (PPC_HA (off) != 0)
11035             {
11036               size += 4;
11037               bfd_put_32 (htab->params->stub_bfd,
11038                           ADDIS_R12_R2 | PPC_HA (off), loc);
11039               loc += 4;
11040               bfd_put_32 (htab->params->stub_bfd,
11041                           LD_R12_0R12 | PPC_LO (off), loc);
11042             }
11043           else
11044             bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
11045
11046           if (PPC_HA (r2off) != 0)
11047             {
11048               size += 4;
11049               loc += 4;
11050               bfd_put_32 (htab->params->stub_bfd,
11051                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
11052             }
11053           if (PPC_LO (r2off) != 0)
11054             {
11055               size += 4;
11056               loc += 4;
11057               bfd_put_32 (htab->params->stub_bfd,
11058                           ADDI_R2_R2 | PPC_LO (r2off), loc);
11059             }
11060         }
11061       loc += 4;
11062       bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, loc);
11063       loc += 4;
11064       bfd_put_32 (htab->params->stub_bfd, BCTR, loc);
11065       break;
11066
11067     case ppc_stub_plt_call:
11068     case ppc_stub_plt_call_r2save:
11069       if (stub_entry->h != NULL
11070           && stub_entry->h->is_func_descriptor
11071           && stub_entry->h->oh != NULL)
11072         {
11073           struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
11074
11075           /* If the old-ABI "dot-symbol" is undefined make it weak so
11076              we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.  */
11077           if (fh->elf.root.type == bfd_link_hash_undefined)
11078             fh->elf.root.type = bfd_link_hash_undefweak;
11079           /* Stop undo_symbol_twiddle changing it back to undefined.  */
11080           fh->was_undefined = 0;
11081         }
11082
11083       /* Now build the stub.  */
11084       dest = stub_entry->plt_ent->plt.offset & ~1;
11085       if (dest >= (bfd_vma) -2)
11086         abort ();
11087
11088       plt = htab->elf.splt;
11089       if (!htab->elf.dynamic_sections_created
11090           || stub_entry->h == NULL
11091           || stub_entry->h->elf.dynindx == -1)
11092         plt = htab->elf.iplt;
11093
11094       dest += plt->output_offset + plt->output_section->vma;
11095
11096       if (stub_entry->h == NULL
11097           && (stub_entry->plt_ent->plt.offset & 1) == 0)
11098         {
11099           Elf_Internal_Rela rela;
11100           bfd_byte *rl;
11101
11102           rela.r_offset = dest;
11103           if (htab->opd_abi)
11104             rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
11105           else
11106             rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
11107           rela.r_addend = (stub_entry->target_value
11108                            + stub_entry->target_section->output_offset
11109                            + stub_entry->target_section->output_section->vma);
11110
11111           rl = (htab->elf.irelplt->contents
11112                 + (htab->elf.irelplt->reloc_count++
11113                    * sizeof (Elf64_External_Rela)));
11114           bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
11115           stub_entry->plt_ent->plt.offset |= 1;
11116         }
11117
11118       off = (dest
11119              - elf_gp (plt->output_section->owner)
11120              - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11121
11122       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11123         {
11124           info->callbacks->einfo
11125             (_("%P: linkage table error against `%T'\n"),
11126              stub_entry->h != NULL
11127              ? stub_entry->h->elf.root.root.string
11128              : "<local sym>");
11129           bfd_set_error (bfd_error_bad_value);
11130           htab->stub_error = TRUE;
11131           return FALSE;
11132         }
11133
11134       if (htab->params->plt_stub_align != 0)
11135         {
11136           unsigned pad = plt_stub_pad (htab, stub_entry, off);
11137
11138           stub_entry->group->stub_sec->size += pad;
11139           stub_entry->stub_offset = stub_entry->group->stub_sec->size;
11140           loc += pad;
11141         }
11142
11143       r = NULL;
11144       if (info->emitrelocations)
11145         {
11146           r = get_relocs (stub_entry->group->stub_sec,
11147                           ((PPC_HA (off) != 0)
11148                            + (htab->opd_abi
11149                               ? 2 + (htab->params->plt_static_chain
11150                                      && PPC_HA (off + 16) == PPC_HA (off))
11151                               : 1)));
11152           if (r == NULL)
11153             return FALSE;
11154           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11155           if (bfd_big_endian (info->output_bfd))
11156             r[0].r_offset += 2;
11157           r[0].r_addend = dest;
11158         }
11159       if (stub_entry->h != NULL
11160           && (stub_entry->h == htab->tls_get_addr_fd
11161               || stub_entry->h == htab->tls_get_addr)
11162           && htab->params->tls_get_addr_opt)
11163         p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
11164       else
11165         p = build_plt_stub (htab, stub_entry, loc, off, r);
11166       size = p - loc;
11167       break;
11168
11169     case ppc_stub_save_res:
11170       return TRUE;
11171
11172     default:
11173       BFD_FAIL ();
11174       return FALSE;
11175     }
11176
11177   stub_entry->group->stub_sec->size += size;
11178
11179   if (htab->params->emit_stub_syms)
11180     {
11181       struct elf_link_hash_entry *h;
11182       size_t len1, len2;
11183       char *name;
11184       const char *const stub_str[] = { "long_branch",
11185                                        "long_branch_r2off",
11186                                        "plt_branch",
11187                                        "plt_branch_r2off",
11188                                        "plt_call",
11189                                        "plt_call" };
11190
11191       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
11192       len2 = strlen (stub_entry->root.string);
11193       name = bfd_malloc (len1 + len2 + 2);
11194       if (name == NULL)
11195         return FALSE;
11196       memcpy (name, stub_entry->root.string, 9);
11197       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
11198       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
11199       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
11200       if (h == NULL)
11201         return FALSE;
11202       if (h->root.type == bfd_link_hash_new)
11203         {
11204           h->root.type = bfd_link_hash_defined;
11205           h->root.u.def.section = stub_entry->group->stub_sec;
11206           h->root.u.def.value = stub_entry->stub_offset;
11207           h->ref_regular = 1;
11208           h->def_regular = 1;
11209           h->ref_regular_nonweak = 1;
11210           h->forced_local = 1;
11211           h->non_elf = 0;
11212           h->root.linker_def = 1;
11213         }
11214     }
11215
11216   return TRUE;
11217 }
11218
11219 /* As above, but don't actually build the stub.  Just bump offset so
11220    we know stub section sizes, and select plt_branch stubs where
11221    long_branch stubs won't do.  */
11222
11223 static bfd_boolean
11224 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11225 {
11226   struct ppc_stub_hash_entry *stub_entry;
11227   struct bfd_link_info *info;
11228   struct ppc_link_hash_table *htab;
11229   bfd_vma off;
11230   int size;
11231
11232   /* Massage our args to the form they really have.  */
11233   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11234   info = in_arg;
11235
11236   htab = ppc_hash_table (info);
11237   if (htab == NULL)
11238     return FALSE;
11239
11240   if (stub_entry->h != NULL
11241       && stub_entry->h->save_res
11242       && stub_entry->h->elf.root.type == bfd_link_hash_defined
11243       && stub_entry->h->elf.root.u.def.section == htab->sfpr)
11244     {
11245       /* Don't make stubs to out-of-line register save/restore
11246          functions.  Instead, emit copies of the functions.  */
11247       stub_entry->group->needs_save_res = 1;
11248       stub_entry->stub_type = ppc_stub_save_res;
11249       return TRUE;
11250     }
11251
11252   if (stub_entry->stub_type == ppc_stub_plt_call
11253       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11254     {
11255       asection *plt;
11256       off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
11257       if (off >= (bfd_vma) -2)
11258         abort ();
11259       plt = htab->elf.splt;
11260       if (!htab->elf.dynamic_sections_created
11261           || stub_entry->h == NULL
11262           || stub_entry->h->elf.dynindx == -1)
11263         plt = htab->elf.iplt;
11264       off += (plt->output_offset
11265               + plt->output_section->vma
11266               - elf_gp (plt->output_section->owner)
11267               - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11268
11269       size = plt_stub_size (htab, stub_entry, off);
11270       if (htab->params->plt_stub_align)
11271         size += plt_stub_pad (htab, stub_entry, off);
11272       if (info->emitrelocations)
11273         {
11274           stub_entry->group->stub_sec->reloc_count
11275             += ((PPC_HA (off) != 0)
11276                 + (htab->opd_abi
11277                    ? 2 + (htab->params->plt_static_chain
11278                           && PPC_HA (off + 16) == PPC_HA (off))
11279                    : 1));
11280           stub_entry->group->stub_sec->flags |= SEC_RELOC;
11281         }
11282     }
11283   else
11284     {
11285       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
11286          variants.  */
11287       bfd_vma r2off = 0;
11288       bfd_vma local_off = 0;
11289
11290       off = (stub_entry->target_value
11291              + stub_entry->target_section->output_offset
11292              + stub_entry->target_section->output_section->vma);
11293       off -= (stub_entry->group->stub_sec->size
11294               + stub_entry->group->stub_sec->output_offset
11295               + stub_entry->group->stub_sec->output_section->vma);
11296
11297       /* Reset the stub type from the plt variant in case we now
11298          can reach with a shorter stub.  */
11299       if (stub_entry->stub_type >= ppc_stub_plt_branch)
11300         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
11301
11302       size = 4;
11303       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11304         {
11305           r2off = get_r2off (info, stub_entry);
11306           if (r2off == (bfd_vma) -1)
11307             {
11308               htab->stub_error = TRUE;
11309               return FALSE;
11310             }
11311           size = 8;
11312           if (PPC_HA (r2off) != 0)
11313             size += 4;
11314           if (PPC_LO (r2off) != 0)
11315             size += 4;
11316           off -= size - 4;
11317         }
11318
11319       local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11320
11321       /* If the branch offset if too big, use a ppc_stub_plt_branch.
11322          Do the same for -R objects without function descriptors.  */
11323       if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
11324           || (stub_entry->stub_type == ppc_stub_long_branch_r2off
11325               && r2off == 0
11326               && htab->sec_info[stub_entry->target_section->id].toc_off == 0))
11327         {
11328           struct ppc_branch_hash_entry *br_entry;
11329
11330           br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11331                                              stub_entry->root.string + 9,
11332                                              TRUE, FALSE);
11333           if (br_entry == NULL)
11334             {
11335               info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
11336                                       stub_entry->root.string);
11337               htab->stub_error = TRUE;
11338               return FALSE;
11339             }
11340
11341           if (br_entry->iter != htab->stub_iteration)
11342             {
11343               br_entry->iter = htab->stub_iteration;
11344               br_entry->offset = htab->brlt->size;
11345               htab->brlt->size += 8;
11346
11347               if (htab->relbrlt != NULL)
11348                 htab->relbrlt->size += sizeof (Elf64_External_Rela);
11349               else if (info->emitrelocations)
11350                 {
11351                   htab->brlt->reloc_count += 1;
11352                   htab->brlt->flags |= SEC_RELOC;
11353                 }
11354             }
11355
11356           stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
11357           off = (br_entry->offset
11358                  + htab->brlt->output_offset
11359                  + htab->brlt->output_section->vma
11360                  - elf_gp (htab->brlt->output_section->owner)
11361                  - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11362
11363           if (info->emitrelocations)
11364             {
11365               stub_entry->group->stub_sec->reloc_count
11366                 += 1 + (PPC_HA (off) != 0);
11367               stub_entry->group->stub_sec->flags |= SEC_RELOC;
11368             }
11369
11370           if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11371             {
11372               size = 12;
11373               if (PPC_HA (off) != 0)
11374                 size = 16;
11375             }
11376           else
11377             {
11378               size = 16;
11379               if (PPC_HA (off) != 0)
11380                 size += 4;
11381
11382               if (PPC_HA (r2off) != 0)
11383                 size += 4;
11384               if (PPC_LO (r2off) != 0)
11385                 size += 4;
11386             }
11387         }
11388       else if (info->emitrelocations)
11389         {
11390           stub_entry->group->stub_sec->reloc_count += 1;
11391           stub_entry->group->stub_sec->flags |= SEC_RELOC;
11392         }
11393     }
11394
11395   stub_entry->group->stub_sec->size += size;
11396   return TRUE;
11397 }
11398
11399 /* Set up various things so that we can make a list of input sections
11400    for each output section included in the link.  Returns -1 on error,
11401    0 when no stubs will be needed, and 1 on success.  */
11402
11403 int
11404 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
11405 {
11406   unsigned int id;
11407   bfd_size_type amt;
11408   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11409
11410   if (htab == NULL)
11411     return -1;
11412
11413   htab->sec_info_arr_size = bfd_get_next_section_id ();
11414   amt = sizeof (*htab->sec_info) * (htab->sec_info_arr_size);
11415   htab->sec_info = bfd_zmalloc (amt);
11416   if (htab->sec_info == NULL)
11417     return -1;
11418
11419   /* Set toc_off for com, und, abs and ind sections.  */
11420   for (id = 0; id < 3; id++)
11421     htab->sec_info[id].toc_off = TOC_BASE_OFF;
11422
11423   return 1;
11424 }
11425
11426 /* Set up for first pass at multitoc partitioning.  */
11427
11428 void
11429 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11430 {
11431   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11432
11433   htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11434   htab->toc_bfd = NULL;
11435   htab->toc_first_sec = NULL;
11436 }
11437
11438 /* The linker repeatedly calls this function for each TOC input section
11439    and linker generated GOT section.  Group input bfds such that the toc
11440    within a group is less than 64k in size.  */
11441
11442 bfd_boolean
11443 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11444 {
11445   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11446   bfd_vma addr, off, limit;
11447
11448   if (htab == NULL)
11449     return FALSE;
11450
11451   if (!htab->second_toc_pass)
11452     {
11453       /* Keep track of the first .toc or .got section for this input bfd.  */
11454       bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11455
11456       if (new_bfd)
11457         {
11458           htab->toc_bfd = isec->owner;
11459           htab->toc_first_sec = isec;
11460         }
11461
11462       addr = isec->output_offset + isec->output_section->vma;
11463       off = addr - htab->toc_curr;
11464       limit = 0x80008000;
11465       if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11466         limit = 0x10000;
11467       if (off + isec->size > limit)
11468         {
11469           addr = (htab->toc_first_sec->output_offset
11470                   + htab->toc_first_sec->output_section->vma);
11471           htab->toc_curr = addr;
11472           htab->toc_curr &= -TOC_BASE_ALIGN;
11473         }
11474
11475       /* toc_curr is the base address of this toc group.  Set elf_gp
11476          for the input section to be the offset relative to the
11477          output toc base plus 0x8000.  Making the input elf_gp an
11478          offset allows us to move the toc as a whole without
11479          recalculating input elf_gp.  */
11480       off = htab->toc_curr - elf_gp (isec->output_section->owner);
11481       off += TOC_BASE_OFF;
11482
11483       /* Die if someone uses a linker script that doesn't keep input
11484          file .toc and .got together.  */
11485       if (new_bfd
11486           && elf_gp (isec->owner) != 0
11487           && elf_gp (isec->owner) != off)
11488         return FALSE;
11489
11490       elf_gp (isec->owner) = off;
11491       return TRUE;
11492     }
11493
11494   /* During the second pass toc_first_sec points to the start of
11495      a toc group, and toc_curr is used to track the old elf_gp.
11496      We use toc_bfd to ensure we only look at each bfd once.  */
11497   if (htab->toc_bfd == isec->owner)
11498     return TRUE;
11499   htab->toc_bfd = isec->owner;
11500
11501   if (htab->toc_first_sec == NULL
11502       || htab->toc_curr != elf_gp (isec->owner))
11503     {
11504       htab->toc_curr = elf_gp (isec->owner);
11505       htab->toc_first_sec = isec;
11506     }
11507   addr = (htab->toc_first_sec->output_offset
11508           + htab->toc_first_sec->output_section->vma);
11509   off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
11510   elf_gp (isec->owner) = off;
11511
11512   return TRUE;
11513 }
11514
11515 /* Called via elf_link_hash_traverse to merge GOT entries for global
11516    symbol H.  */
11517
11518 static bfd_boolean
11519 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11520 {
11521   if (h->root.type == bfd_link_hash_indirect)
11522     return TRUE;
11523
11524   merge_got_entries (&h->got.glist);
11525
11526   return TRUE;
11527 }
11528
11529 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11530    symbol H.  */
11531
11532 static bfd_boolean
11533 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11534 {
11535   struct got_entry *gent;
11536
11537   if (h->root.type == bfd_link_hash_indirect)
11538     return TRUE;
11539
11540   for (gent = h->got.glist; gent != NULL; gent = gent->next)
11541     if (!gent->is_indirect)
11542       allocate_got (h, (struct bfd_link_info *) inf, gent);
11543   return TRUE;
11544 }
11545
11546 /* Called on the first multitoc pass after the last call to
11547    ppc64_elf_next_toc_section.  This function removes duplicate GOT
11548    entries.  */
11549
11550 bfd_boolean
11551 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11552 {
11553   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11554   struct bfd *ibfd, *ibfd2;
11555   bfd_boolean done_something;
11556
11557   htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11558
11559   if (!htab->do_multi_toc)
11560     return FALSE;
11561
11562   /* Merge global sym got entries within a toc group.  */
11563   elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11564
11565   /* And tlsld_got.  */
11566   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11567     {
11568       struct got_entry *ent, *ent2;
11569
11570       if (!is_ppc64_elf (ibfd))
11571         continue;
11572
11573       ent = ppc64_tlsld_got (ibfd);
11574       if (!ent->is_indirect
11575           && ent->got.offset != (bfd_vma) -1)
11576         {
11577           for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
11578             {
11579               if (!is_ppc64_elf (ibfd2))
11580                 continue;
11581
11582               ent2 = ppc64_tlsld_got (ibfd2);
11583               if (!ent2->is_indirect
11584                   && ent2->got.offset != (bfd_vma) -1
11585                   && elf_gp (ibfd2) == elf_gp (ibfd))
11586                 {
11587                   ent2->is_indirect = TRUE;
11588                   ent2->got.ent = ent;
11589                 }
11590             }
11591         }
11592     }
11593
11594   /* Zap sizes of got sections.  */
11595   htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11596   htab->elf.irelplt->size -= htab->got_reli_size;
11597   htab->got_reli_size = 0;
11598
11599   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11600     {
11601       asection *got, *relgot;
11602
11603       if (!is_ppc64_elf (ibfd))
11604         continue;
11605
11606       got = ppc64_elf_tdata (ibfd)->got;
11607       if (got != NULL)
11608         {
11609           got->rawsize = got->size;
11610           got->size = 0;
11611           relgot = ppc64_elf_tdata (ibfd)->relgot;
11612           relgot->rawsize = relgot->size;
11613           relgot->size = 0;
11614         }
11615     }
11616
11617   /* Now reallocate the got, local syms first.  We don't need to
11618      allocate section contents again since we never increase size.  */
11619   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11620     {
11621       struct got_entry **lgot_ents;
11622       struct got_entry **end_lgot_ents;
11623       struct plt_entry **local_plt;
11624       struct plt_entry **end_local_plt;
11625       unsigned char *lgot_masks;
11626       bfd_size_type locsymcount;
11627       Elf_Internal_Shdr *symtab_hdr;
11628       asection *s;
11629
11630       if (!is_ppc64_elf (ibfd))
11631         continue;
11632
11633       lgot_ents = elf_local_got_ents (ibfd);
11634       if (!lgot_ents)
11635         continue;
11636
11637       symtab_hdr = &elf_symtab_hdr (ibfd);
11638       locsymcount = symtab_hdr->sh_info;
11639       end_lgot_ents = lgot_ents + locsymcount;
11640       local_plt = (struct plt_entry **) end_lgot_ents;
11641       end_local_plt = local_plt + locsymcount;
11642       lgot_masks = (unsigned char *) end_local_plt;
11643       s = ppc64_elf_tdata (ibfd)->got;
11644       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11645         {
11646           struct got_entry *ent;
11647
11648           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11649             {
11650               unsigned int ent_size = 8;
11651               unsigned int rel_size = sizeof (Elf64_External_Rela);
11652
11653               ent->got.offset = s->size;
11654               if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11655                 {
11656                   ent_size *= 2;
11657                   rel_size *= 2;
11658                 }
11659               s->size += ent_size;
11660               if ((*lgot_masks & PLT_IFUNC) != 0)
11661                 {
11662                   htab->elf.irelplt->size += rel_size;
11663                   htab->got_reli_size += rel_size;
11664                 }
11665               else if (bfd_link_pic (info))
11666                 {
11667                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11668                   srel->size += rel_size;
11669                 }
11670             }
11671         }
11672     }
11673
11674   elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11675
11676   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11677     {
11678       struct got_entry *ent;
11679
11680       if (!is_ppc64_elf (ibfd))
11681         continue;
11682
11683       ent = ppc64_tlsld_got (ibfd);
11684       if (!ent->is_indirect
11685           && ent->got.offset != (bfd_vma) -1)
11686         {
11687           asection *s = ppc64_elf_tdata (ibfd)->got;
11688           ent->got.offset = s->size;
11689           s->size += 16;
11690           if (bfd_link_pic (info))
11691             {
11692               asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11693               srel->size += sizeof (Elf64_External_Rela);
11694             }
11695         }
11696     }
11697
11698   done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11699   if (!done_something)
11700     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11701       {
11702         asection *got;
11703
11704         if (!is_ppc64_elf (ibfd))
11705           continue;
11706
11707         got = ppc64_elf_tdata (ibfd)->got;
11708         if (got != NULL)
11709           {
11710             done_something = got->rawsize != got->size;
11711             if (done_something)
11712               break;
11713           }
11714       }
11715
11716   if (done_something)
11717     (*htab->params->layout_sections_again) ();
11718
11719   /* Set up for second pass over toc sections to recalculate elf_gp
11720      on input sections.  */
11721   htab->toc_bfd = NULL;
11722   htab->toc_first_sec = NULL;
11723   htab->second_toc_pass = TRUE;
11724   return done_something;
11725 }
11726
11727 /* Called after second pass of multitoc partitioning.  */
11728
11729 void
11730 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11731 {
11732   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11733
11734   /* After the second pass, toc_curr tracks the TOC offset used
11735      for code sections below in ppc64_elf_next_input_section.  */
11736   htab->toc_curr = TOC_BASE_OFF;
11737 }
11738
11739 /* No toc references were found in ISEC.  If the code in ISEC makes no
11740    calls, then there's no need to use toc adjusting stubs when branching
11741    into ISEC.  Actually, indirect calls from ISEC are OK as they will
11742    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
11743    needed, and 2 if a cyclical call-graph was found but no other reason
11744    for a stub was detected.  If called from the top level, a return of
11745    2 means the same as a return of 0.  */
11746
11747 static int
11748 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11749 {
11750   int ret;
11751
11752   /* Mark this section as checked.  */
11753   isec->call_check_done = 1;
11754
11755   /* We know none of our code bearing sections will need toc stubs.  */
11756   if ((isec->flags & SEC_LINKER_CREATED) != 0)
11757     return 0;
11758
11759   if (isec->size == 0)
11760     return 0;
11761
11762   if (isec->output_section == NULL)
11763     return 0;
11764
11765   ret = 0;
11766   if (isec->reloc_count != 0)
11767     {
11768       Elf_Internal_Rela *relstart, *rel;
11769       Elf_Internal_Sym *local_syms;
11770       struct ppc_link_hash_table *htab;
11771
11772       relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11773                                             info->keep_memory);
11774       if (relstart == NULL)
11775         return -1;
11776
11777       /* Look for branches to outside of this section.  */
11778       local_syms = NULL;
11779       htab = ppc_hash_table (info);
11780       if (htab == NULL)
11781         return -1;
11782
11783       for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11784         {
11785           enum elf_ppc64_reloc_type r_type;
11786           unsigned long r_symndx;
11787           struct elf_link_hash_entry *h;
11788           struct ppc_link_hash_entry *eh;
11789           Elf_Internal_Sym *sym;
11790           asection *sym_sec;
11791           struct _opd_sec_data *opd;
11792           bfd_vma sym_value;
11793           bfd_vma dest;
11794
11795           r_type = ELF64_R_TYPE (rel->r_info);
11796           if (r_type != R_PPC64_REL24
11797               && r_type != R_PPC64_REL14
11798               && r_type != R_PPC64_REL14_BRTAKEN
11799               && r_type != R_PPC64_REL14_BRNTAKEN)
11800             continue;
11801
11802           r_symndx = ELF64_R_SYM (rel->r_info);
11803           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11804                           isec->owner))
11805             {
11806               ret = -1;
11807               break;
11808             }
11809
11810           /* Calls to dynamic lib functions go through a plt call stub
11811              that uses r2.  */
11812           eh = (struct ppc_link_hash_entry *) h;
11813           if (eh != NULL
11814               && (eh->elf.plt.plist != NULL
11815                   || (eh->oh != NULL
11816                       && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11817             {
11818               ret = 1;
11819               break;
11820             }
11821
11822           if (sym_sec == NULL)
11823             /* Ignore other undefined symbols.  */
11824             continue;
11825
11826           /* Assume branches to other sections not included in the
11827              link need stubs too, to cover -R and absolute syms.  */
11828           if (sym_sec->output_section == NULL)
11829             {
11830               ret = 1;
11831               break;
11832             }
11833
11834           if (h == NULL)
11835             sym_value = sym->st_value;
11836           else
11837             {
11838               if (h->root.type != bfd_link_hash_defined
11839                   && h->root.type != bfd_link_hash_defweak)
11840                 abort ();
11841               sym_value = h->root.u.def.value;
11842             }
11843           sym_value += rel->r_addend;
11844
11845           /* If this branch reloc uses an opd sym, find the code section.  */
11846           opd = get_opd_info (sym_sec);
11847           if (opd != NULL)
11848             {
11849               if (h == NULL && opd->adjust != NULL)
11850                 {
11851                   long adjust;
11852
11853                   adjust = opd->adjust[OPD_NDX (sym_value)];
11854                   if (adjust == -1)
11855                     /* Assume deleted functions won't ever be called.  */
11856                     continue;
11857                   sym_value += adjust;
11858                 }
11859
11860               dest = opd_entry_value (sym_sec, sym_value,
11861                                       &sym_sec, NULL, FALSE);
11862               if (dest == (bfd_vma) -1)
11863                 continue;
11864             }
11865           else
11866             dest = (sym_value
11867                     + sym_sec->output_offset
11868                     + sym_sec->output_section->vma);
11869
11870           /* Ignore branch to self.  */
11871           if (sym_sec == isec)
11872             continue;
11873
11874           /* If the called function uses the toc, we need a stub.  */
11875           if (sym_sec->has_toc_reloc
11876               || sym_sec->makes_toc_func_call)
11877             {
11878               ret = 1;
11879               break;
11880             }
11881
11882           /* Assume any branch that needs a long branch stub might in fact
11883              need a plt_branch stub.  A plt_branch stub uses r2.  */
11884           else if (dest - (isec->output_offset
11885                            + isec->output_section->vma
11886                            + rel->r_offset) + (1 << 25)
11887                    >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
11888                                                              ? h->other
11889                                                              : sym->st_other))
11890             {
11891               ret = 1;
11892               break;
11893             }
11894
11895           /* If calling back to a section in the process of being
11896              tested, we can't say for sure that no toc adjusting stubs
11897              are needed, so don't return zero.  */
11898           else if (sym_sec->call_check_in_progress)
11899             ret = 2;
11900
11901           /* Branches to another section that itself doesn't have any TOC
11902              references are OK.  Recursively call ourselves to check.  */
11903           else if (!sym_sec->call_check_done)
11904             {
11905               int recur;
11906
11907               /* Mark current section as indeterminate, so that other
11908                  sections that call back to current won't be marked as
11909                  known.  */
11910               isec->call_check_in_progress = 1;
11911               recur = toc_adjusting_stub_needed (info, sym_sec);
11912               isec->call_check_in_progress = 0;
11913
11914               if (recur != 0)
11915                 {
11916                   ret = recur;
11917                   if (recur != 2)
11918                     break;
11919                 }
11920             }
11921         }
11922
11923       if (local_syms != NULL
11924           && (elf_symtab_hdr (isec->owner).contents
11925               != (unsigned char *) local_syms))
11926         free (local_syms);
11927       if (elf_section_data (isec)->relocs != relstart)
11928         free (relstart);
11929     }
11930
11931   if ((ret & 1) == 0
11932       && isec->map_head.s != NULL
11933       && (strcmp (isec->output_section->name, ".init") == 0
11934           || strcmp (isec->output_section->name, ".fini") == 0))
11935     {
11936       if (isec->map_head.s->has_toc_reloc
11937           || isec->map_head.s->makes_toc_func_call)
11938         ret = 1;
11939       else if (!isec->map_head.s->call_check_done)
11940         {
11941           int recur;
11942           isec->call_check_in_progress = 1;
11943           recur = toc_adjusting_stub_needed (info, isec->map_head.s);
11944           isec->call_check_in_progress = 0;
11945           if (recur != 0)
11946             ret = recur;
11947         }
11948     }
11949
11950   if (ret == 1)
11951     isec->makes_toc_func_call = 1;
11952
11953   return ret;
11954 }
11955
11956 /* The linker repeatedly calls this function for each input section,
11957    in the order that input sections are linked into output sections.
11958    Build lists of input sections to determine groupings between which
11959    we may insert linker stubs.  */
11960
11961 bfd_boolean
11962 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
11963 {
11964   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11965
11966   if (htab == NULL)
11967     return FALSE;
11968
11969   if ((isec->output_section->flags & SEC_CODE) != 0
11970       && isec->output_section->id < htab->sec_info_arr_size)
11971     {
11972       /* This happens to make the list in reverse order,
11973          which is what we want.  */
11974       htab->sec_info[isec->id].u.list
11975         = htab->sec_info[isec->output_section->id].u.list;
11976       htab->sec_info[isec->output_section->id].u.list = isec;
11977     }
11978
11979   if (htab->multi_toc_needed)
11980     {
11981       /* Analyse sections that aren't already flagged as needing a
11982          valid toc pointer.  Exclude .fixup for the linux kernel.
11983          .fixup contains branches, but only back to the function that
11984          hit an exception.  */
11985       if (!(isec->has_toc_reloc
11986             || (isec->flags & SEC_CODE) == 0
11987             || strcmp (isec->name, ".fixup") == 0
11988             || isec->call_check_done))
11989         {
11990           if (toc_adjusting_stub_needed (info, isec) < 0)
11991             return FALSE;
11992         }
11993       /* Make all sections use the TOC assigned for this object file.
11994          This will be wrong for pasted sections;  We fix that in
11995          check_pasted_section().  */
11996       if (elf_gp (isec->owner) != 0)
11997         htab->toc_curr = elf_gp (isec->owner);
11998     }
11999
12000   htab->sec_info[isec->id].toc_off = htab->toc_curr;
12001   return TRUE;
12002 }
12003
12004 /* Check that all .init and .fini sections use the same toc, if they
12005    have toc relocs.  */
12006
12007 static bfd_boolean
12008 check_pasted_section (struct bfd_link_info *info, const char *name)
12009 {
12010   asection *o = bfd_get_section_by_name (info->output_bfd, name);
12011
12012   if (o != NULL)
12013     {
12014       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12015       bfd_vma toc_off = 0;
12016       asection *i;
12017
12018       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12019         if (i->has_toc_reloc)
12020           {
12021             if (toc_off == 0)
12022               toc_off = htab->sec_info[i->id].toc_off;
12023             else if (toc_off != htab->sec_info[i->id].toc_off)
12024               return FALSE;
12025           }
12026
12027       if (toc_off == 0)
12028         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12029           if (i->makes_toc_func_call)
12030             {
12031               toc_off = htab->sec_info[i->id].toc_off;
12032               break;
12033             }
12034
12035       /* Make sure the whole pasted function uses the same toc offset.  */
12036       if (toc_off != 0)
12037         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12038           htab->sec_info[i->id].toc_off = toc_off;
12039     }
12040   return TRUE;
12041 }
12042
12043 bfd_boolean
12044 ppc64_elf_check_init_fini (struct bfd_link_info *info)
12045 {
12046   return (check_pasted_section (info, ".init")
12047           & check_pasted_section (info, ".fini"));
12048 }
12049
12050 /* See whether we can group stub sections together.  Grouping stub
12051    sections may result in fewer stubs.  More importantly, we need to
12052    put all .init* and .fini* stubs at the beginning of the .init or
12053    .fini output sections respectively, because glibc splits the
12054    _init and _fini functions into multiple parts.  Putting a stub in
12055    the middle of a function is not a good idea.  */
12056
12057 static bfd_boolean
12058 group_sections (struct bfd_link_info *info,
12059                 bfd_size_type stub_group_size,
12060                 bfd_boolean stubs_always_before_branch)
12061 {
12062   struct ppc_link_hash_table *htab;
12063   asection *osec;
12064   bfd_boolean suppress_size_errors;
12065
12066   htab = ppc_hash_table (info);
12067   if (htab == NULL)
12068     return FALSE;
12069
12070   suppress_size_errors = FALSE;
12071   if (stub_group_size == 1)
12072     {
12073       /* Default values.  */
12074       if (stubs_always_before_branch)
12075         stub_group_size = 0x1e00000;
12076       else
12077         stub_group_size = 0x1c00000;
12078       suppress_size_errors = TRUE;
12079     }
12080
12081   for (osec = info->output_bfd->sections; osec != NULL; osec = osec->next)
12082     {
12083       asection *tail;
12084
12085       if (osec->id >= htab->sec_info_arr_size)
12086         continue;
12087
12088       tail = htab->sec_info[osec->id].u.list;
12089       while (tail != NULL)
12090         {
12091           asection *curr;
12092           asection *prev;
12093           bfd_size_type total;
12094           bfd_boolean big_sec;
12095           bfd_vma curr_toc;
12096           struct map_stub *group;
12097           bfd_size_type group_size;
12098
12099           curr = tail;
12100           total = tail->size;
12101           group_size = (ppc64_elf_section_data (tail) != NULL
12102                         && ppc64_elf_section_data (tail)->has_14bit_branch
12103                         ? stub_group_size >> 10 : stub_group_size);
12104
12105           big_sec = total > group_size;
12106           if (big_sec && !suppress_size_errors)
12107             _bfd_error_handler (_("%B section %A exceeds stub group size"),
12108                                 tail->owner, tail);
12109           curr_toc = htab->sec_info[tail->id].toc_off;
12110
12111           while ((prev = htab->sec_info[curr->id].u.list) != NULL
12112                  && ((total += curr->output_offset - prev->output_offset)
12113                      < (ppc64_elf_section_data (prev) != NULL
12114                         && ppc64_elf_section_data (prev)->has_14bit_branch
12115                         ? (group_size = stub_group_size >> 10) : group_size))
12116                  && htab->sec_info[prev->id].toc_off == curr_toc)
12117             curr = prev;
12118
12119           /* OK, the size from the start of CURR to the end is less
12120              than group_size and thus can be handled by one stub
12121              section.  (or the tail section is itself larger than
12122              group_size, in which case we may be toast.)  We should
12123              really be keeping track of the total size of stubs added
12124              here, as stubs contribute to the final output section
12125              size.  That's a little tricky, and this way will only
12126              break if stubs added make the total size more than 2^25,
12127              ie. for the default stub_group_size, if stubs total more
12128              than 2097152 bytes, or nearly 75000 plt call stubs.  */
12129           group = bfd_alloc (curr->owner, sizeof (*group));
12130           if (group == NULL)
12131             return FALSE;
12132           group->link_sec = curr;
12133           group->stub_sec = NULL;
12134           group->needs_save_res = 0;
12135           group->next = htab->group;
12136           htab->group = group;
12137           do
12138             {
12139               prev = htab->sec_info[tail->id].u.list;
12140               /* Set up this stub group.  */
12141               htab->sec_info[tail->id].u.group = group;
12142             }
12143           while (tail != curr && (tail = prev) != NULL);
12144
12145           /* But wait, there's more!  Input sections up to group_size
12146              bytes before the stub section can be handled by it too.
12147              Don't do this if we have a really large section after the
12148              stubs, as adding more stubs increases the chance that
12149              branches may not reach into the stub section.  */
12150           if (!stubs_always_before_branch && !big_sec)
12151             {
12152               total = 0;
12153               while (prev != NULL
12154                      && ((total += tail->output_offset - prev->output_offset)
12155                          < (ppc64_elf_section_data (prev) != NULL
12156                             && ppc64_elf_section_data (prev)->has_14bit_branch
12157                             ? (group_size = stub_group_size >> 10) : group_size))
12158                      && htab->sec_info[prev->id].toc_off == curr_toc)
12159                 {
12160                   tail = prev;
12161                   prev = htab->sec_info[tail->id].u.list;
12162                   htab->sec_info[tail->id].u.group = group;
12163                 }
12164             }
12165           tail = prev;
12166         }
12167     }
12168   return TRUE;
12169 }
12170
12171 static const unsigned char glink_eh_frame_cie[] =
12172 {
12173   0, 0, 0, 16,                          /* length.  */
12174   0, 0, 0, 0,                           /* id.  */
12175   1,                                    /* CIE version.  */
12176   'z', 'R', 0,                          /* Augmentation string.  */
12177   4,                                    /* Code alignment.  */
12178   0x78,                                 /* Data alignment.  */
12179   65,                                   /* RA reg.  */
12180   1,                                    /* Augmentation size.  */
12181   DW_EH_PE_pcrel | DW_EH_PE_sdata4,     /* FDE encoding.  */
12182   DW_CFA_def_cfa, 1, 0,                 /* def_cfa: r1 offset 0.  */
12183   0, 0, 0, 0
12184 };
12185
12186 /* Stripping output sections is normally done before dynamic section
12187    symbols have been allocated.  This function is called later, and
12188    handles cases like htab->brlt which is mapped to its own output
12189    section.  */
12190
12191 static void
12192 maybe_strip_output (struct bfd_link_info *info, asection *isec)
12193 {
12194   if (isec->size == 0
12195       && isec->output_section->size == 0
12196       && !(isec->output_section->flags & SEC_KEEP)
12197       && !bfd_section_removed_from_list (info->output_bfd,
12198                                          isec->output_section)
12199       && elf_section_data (isec->output_section)->dynindx == 0)
12200     {
12201       isec->output_section->flags |= SEC_EXCLUDE;
12202       bfd_section_list_remove (info->output_bfd, isec->output_section);
12203       info->output_bfd->section_count--;
12204     }
12205 }
12206
12207 /* Determine and set the size of the stub section for a final link.
12208
12209    The basic idea here is to examine all the relocations looking for
12210    PC-relative calls to a target that is unreachable with a "bl"
12211    instruction.  */
12212
12213 bfd_boolean
12214 ppc64_elf_size_stubs (struct bfd_link_info *info)
12215 {
12216   bfd_size_type stub_group_size;
12217   bfd_boolean stubs_always_before_branch;
12218   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12219
12220   if (htab == NULL)
12221     return FALSE;
12222
12223   if (htab->params->plt_thread_safe == -1 && !bfd_link_executable (info))
12224     htab->params->plt_thread_safe = 1;
12225   if (!htab->opd_abi)
12226     htab->params->plt_thread_safe = 0;
12227   else if (htab->params->plt_thread_safe == -1)
12228     {
12229       static const char *const thread_starter[] =
12230         {
12231           "pthread_create",
12232           /* libstdc++ */
12233           "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
12234           /* librt */
12235           "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
12236           "mq_notify", "create_timer",
12237           /* libanl */
12238           "getaddrinfo_a",
12239           /* libgomp */
12240           "GOMP_parallel",
12241           "GOMP_parallel_start",
12242           "GOMP_parallel_loop_static",
12243           "GOMP_parallel_loop_static_start",
12244           "GOMP_parallel_loop_dynamic",
12245           "GOMP_parallel_loop_dynamic_start",
12246           "GOMP_parallel_loop_guided",
12247           "GOMP_parallel_loop_guided_start",
12248           "GOMP_parallel_loop_runtime",
12249           "GOMP_parallel_loop_runtime_start",
12250           "GOMP_parallel_sections",
12251           "GOMP_parallel_sections_start",
12252           /* libgo */
12253           "__go_go",
12254         };
12255       unsigned i;
12256
12257       for (i = 0; i < ARRAY_SIZE (thread_starter); i++)
12258         {
12259           struct elf_link_hash_entry *h;
12260           h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
12261                                     FALSE, FALSE, TRUE);
12262           htab->params->plt_thread_safe = h != NULL && h->ref_regular;
12263           if (htab->params->plt_thread_safe)
12264             break;
12265         }
12266     }
12267   stubs_always_before_branch = htab->params->group_size < 0;
12268   if (htab->params->group_size < 0)
12269     stub_group_size = -htab->params->group_size;
12270   else
12271     stub_group_size = htab->params->group_size;
12272
12273   if (!group_sections (info, stub_group_size, stubs_always_before_branch))
12274     return FALSE;
12275
12276 #define STUB_SHRINK_ITER 20
12277   /* Loop until no stubs added.  After iteration 20 of this loop we may
12278      exit on a stub section shrinking.  This is to break out of a
12279      pathological case where adding stubs on one iteration decreases
12280      section gaps (perhaps due to alignment), which then requires
12281      fewer or smaller stubs on the next iteration.  */
12282
12283   while (1)
12284     {
12285       bfd *input_bfd;
12286       unsigned int bfd_indx;
12287       struct map_stub *group;
12288       asection *stub_sec;
12289
12290       htab->stub_iteration += 1;
12291
12292       for (input_bfd = info->input_bfds, bfd_indx = 0;
12293            input_bfd != NULL;
12294            input_bfd = input_bfd->link.next, bfd_indx++)
12295         {
12296           Elf_Internal_Shdr *symtab_hdr;
12297           asection *section;
12298           Elf_Internal_Sym *local_syms = NULL;
12299
12300           if (!is_ppc64_elf (input_bfd))
12301             continue;
12302
12303           /* We'll need the symbol table in a second.  */
12304           symtab_hdr = &elf_symtab_hdr (input_bfd);
12305           if (symtab_hdr->sh_info == 0)
12306             continue;
12307
12308           /* Walk over each section attached to the input bfd.  */
12309           for (section = input_bfd->sections;
12310                section != NULL;
12311                section = section->next)
12312             {
12313               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
12314
12315               /* If there aren't any relocs, then there's nothing more
12316                  to do.  */
12317               if ((section->flags & SEC_RELOC) == 0
12318                   || (section->flags & SEC_ALLOC) == 0
12319                   || (section->flags & SEC_LOAD) == 0
12320                   || (section->flags & SEC_CODE) == 0
12321                   || section->reloc_count == 0)
12322                 continue;
12323
12324               /* If this section is a link-once section that will be
12325                  discarded, then don't create any stubs.  */
12326               if (section->output_section == NULL
12327                   || section->output_section->owner != info->output_bfd)
12328                 continue;
12329
12330               /* Get the relocs.  */
12331               internal_relocs
12332                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
12333                                              info->keep_memory);
12334               if (internal_relocs == NULL)
12335                 goto error_ret_free_local;
12336
12337               /* Now examine each relocation.  */
12338               irela = internal_relocs;
12339               irelaend = irela + section->reloc_count;
12340               for (; irela < irelaend; irela++)
12341                 {
12342                   enum elf_ppc64_reloc_type r_type;
12343                   unsigned int r_indx;
12344                   enum ppc_stub_type stub_type;
12345                   struct ppc_stub_hash_entry *stub_entry;
12346                   asection *sym_sec, *code_sec;
12347                   bfd_vma sym_value, code_value;
12348                   bfd_vma destination;
12349                   unsigned long local_off;
12350                   bfd_boolean ok_dest;
12351                   struct ppc_link_hash_entry *hash;
12352                   struct ppc_link_hash_entry *fdh;
12353                   struct elf_link_hash_entry *h;
12354                   Elf_Internal_Sym *sym;
12355                   char *stub_name;
12356                   const asection *id_sec;
12357                   struct _opd_sec_data *opd;
12358                   struct plt_entry *plt_ent;
12359
12360                   r_type = ELF64_R_TYPE (irela->r_info);
12361                   r_indx = ELF64_R_SYM (irela->r_info);
12362
12363                   if (r_type >= R_PPC64_max)
12364                     {
12365                       bfd_set_error (bfd_error_bad_value);
12366                       goto error_ret_free_internal;
12367                     }
12368
12369                   /* Only look for stubs on branch instructions.  */
12370                   if (r_type != R_PPC64_REL24
12371                       && r_type != R_PPC64_REL14
12372                       && r_type != R_PPC64_REL14_BRTAKEN
12373                       && r_type != R_PPC64_REL14_BRNTAKEN)
12374                     continue;
12375
12376                   /* Now determine the call target, its name, value,
12377                      section.  */
12378                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12379                                   r_indx, input_bfd))
12380                     goto error_ret_free_internal;
12381                   hash = (struct ppc_link_hash_entry *) h;
12382
12383                   ok_dest = FALSE;
12384                   fdh = NULL;
12385                   sym_value = 0;
12386                   if (hash == NULL)
12387                     {
12388                       sym_value = sym->st_value;
12389                       if (sym_sec != NULL
12390                           && sym_sec->output_section != NULL)
12391                         ok_dest = TRUE;
12392                     }
12393                   else if (hash->elf.root.type == bfd_link_hash_defined
12394                            || hash->elf.root.type == bfd_link_hash_defweak)
12395                     {
12396                       sym_value = hash->elf.root.u.def.value;
12397                       if (sym_sec->output_section != NULL)
12398                         ok_dest = TRUE;
12399                     }
12400                   else if (hash->elf.root.type == bfd_link_hash_undefweak
12401                            || hash->elf.root.type == bfd_link_hash_undefined)
12402                     {
12403                       /* Recognise an old ABI func code entry sym, and
12404                          use the func descriptor sym instead if it is
12405                          defined.  */
12406                       if (hash->elf.root.root.string[0] == '.'
12407                           && (fdh = lookup_fdh (hash, htab)) != NULL)
12408                         {
12409                           if (fdh->elf.root.type == bfd_link_hash_defined
12410                               || fdh->elf.root.type == bfd_link_hash_defweak)
12411                             {
12412                               sym_sec = fdh->elf.root.u.def.section;
12413                               sym_value = fdh->elf.root.u.def.value;
12414                               if (sym_sec->output_section != NULL)
12415                                 ok_dest = TRUE;
12416                             }
12417                           else
12418                             fdh = NULL;
12419                         }
12420                     }
12421                   else
12422                     {
12423                       bfd_set_error (bfd_error_bad_value);
12424                       goto error_ret_free_internal;
12425                     }
12426
12427                   destination = 0;
12428                   local_off = 0;
12429                   if (ok_dest)
12430                     {
12431                       sym_value += irela->r_addend;
12432                       destination = (sym_value
12433                                      + sym_sec->output_offset
12434                                      + sym_sec->output_section->vma);
12435                       local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12436                                                             ? hash->elf.other
12437                                                             : sym->st_other);
12438                     }
12439
12440                   code_sec = sym_sec;
12441                   code_value = sym_value;
12442                   opd = get_opd_info (sym_sec);
12443                   if (opd != NULL)
12444                     {
12445                       bfd_vma dest;
12446
12447                       if (hash == NULL && opd->adjust != NULL)
12448                         {
12449                           long adjust = opd->adjust[OPD_NDX (sym_value)];
12450                           if (adjust == -1)
12451                             continue;
12452                           code_value += adjust;
12453                           sym_value += adjust;
12454                         }
12455                       dest = opd_entry_value (sym_sec, sym_value,
12456                                               &code_sec, &code_value, FALSE);
12457                       if (dest != (bfd_vma) -1)
12458                         {
12459                           destination = dest;
12460                           if (fdh != NULL)
12461                             {
12462                               /* Fixup old ABI sym to point at code
12463                                  entry.  */
12464                               hash->elf.root.type = bfd_link_hash_defweak;
12465                               hash->elf.root.u.def.section = code_sec;
12466                               hash->elf.root.u.def.value = code_value;
12467                             }
12468                         }
12469                     }
12470
12471                   /* Determine what (if any) linker stub is needed.  */
12472                   plt_ent = NULL;
12473                   stub_type = ppc_type_of_stub (section, irela, &hash,
12474                                                 &plt_ent, destination,
12475                                                 local_off);
12476
12477                   if (stub_type != ppc_stub_plt_call)
12478                     {
12479                       /* Check whether we need a TOC adjusting stub.
12480                          Since the linker pastes together pieces from
12481                          different object files when creating the
12482                          _init and _fini functions, it may be that a
12483                          call to what looks like a local sym is in
12484                          fact a call needing a TOC adjustment.  */
12485                       if (code_sec != NULL
12486                           && code_sec->output_section != NULL
12487                           && (htab->sec_info[code_sec->id].toc_off
12488                               != htab->sec_info[section->id].toc_off)
12489                           && (code_sec->has_toc_reloc
12490                               || code_sec->makes_toc_func_call))
12491                         stub_type = ppc_stub_long_branch_r2off;
12492                     }
12493
12494                   if (stub_type == ppc_stub_none)
12495                     continue;
12496
12497                   /* __tls_get_addr calls might be eliminated.  */
12498                   if (stub_type != ppc_stub_plt_call
12499                       && hash != NULL
12500                       && (hash == htab->tls_get_addr
12501                           || hash == htab->tls_get_addr_fd)
12502                       && section->has_tls_reloc
12503                       && irela != internal_relocs)
12504                     {
12505                       /* Get tls info.  */
12506                       unsigned char *tls_mask;
12507
12508                       if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12509                                          irela - 1, input_bfd))
12510                         goto error_ret_free_internal;
12511                       if (*tls_mask != 0)
12512                         continue;
12513                     }
12514
12515                   if (stub_type == ppc_stub_plt_call
12516                       && irela + 1 < irelaend
12517                       && irela[1].r_offset == irela->r_offset + 4
12518                       && ELF64_R_TYPE (irela[1].r_info) == R_PPC64_TOCSAVE)
12519                     {
12520                       if (!tocsave_find (htab, INSERT,
12521                                          &local_syms, irela + 1, input_bfd))
12522                         goto error_ret_free_internal;
12523                     }
12524                   else if (stub_type == ppc_stub_plt_call)
12525                     stub_type = ppc_stub_plt_call_r2save;
12526
12527                   /* Support for grouping stub sections.  */
12528                   id_sec = htab->sec_info[section->id].u.group->link_sec;
12529
12530                   /* Get the name of this stub.  */
12531                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12532                   if (!stub_name)
12533                     goto error_ret_free_internal;
12534
12535                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12536                                                      stub_name, FALSE, FALSE);
12537                   if (stub_entry != NULL)
12538                     {
12539                       /* The proper stub has already been created.  */
12540                       free (stub_name);
12541                       if (stub_type == ppc_stub_plt_call_r2save)
12542                         stub_entry->stub_type = stub_type;
12543                       continue;
12544                     }
12545
12546                   stub_entry = ppc_add_stub (stub_name, section, info);
12547                   if (stub_entry == NULL)
12548                     {
12549                       free (stub_name);
12550                     error_ret_free_internal:
12551                       if (elf_section_data (section)->relocs == NULL)
12552                         free (internal_relocs);
12553                     error_ret_free_local:
12554                       if (local_syms != NULL
12555                           && (symtab_hdr->contents
12556                               != (unsigned char *) local_syms))
12557                         free (local_syms);
12558                       return FALSE;
12559                     }
12560
12561                   stub_entry->stub_type = stub_type;
12562                   if (stub_type != ppc_stub_plt_call
12563                       && stub_type != ppc_stub_plt_call_r2save)
12564                     {
12565                       stub_entry->target_value = code_value;
12566                       stub_entry->target_section = code_sec;
12567                     }
12568                   else
12569                     {
12570                       stub_entry->target_value = sym_value;
12571                       stub_entry->target_section = sym_sec;
12572                     }
12573                   stub_entry->h = hash;
12574                   stub_entry->plt_ent = plt_ent;
12575                   stub_entry->other = hash ? hash->elf.other : sym->st_other;
12576
12577                   if (stub_entry->h != NULL)
12578                     htab->stub_globals += 1;
12579                 }
12580
12581               /* We're done with the internal relocs, free them.  */
12582               if (elf_section_data (section)->relocs != internal_relocs)
12583                 free (internal_relocs);
12584             }
12585
12586           if (local_syms != NULL
12587               && symtab_hdr->contents != (unsigned char *) local_syms)
12588             {
12589               if (!info->keep_memory)
12590                 free (local_syms);
12591               else
12592                 symtab_hdr->contents = (unsigned char *) local_syms;
12593             }
12594         }
12595
12596       /* We may have added some stubs.  Find out the new size of the
12597          stub sections.  */
12598       for (stub_sec = htab->params->stub_bfd->sections;
12599            stub_sec != NULL;
12600            stub_sec = stub_sec->next)
12601         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12602           {
12603             stub_sec->rawsize = stub_sec->size;
12604             stub_sec->size = 0;
12605             stub_sec->reloc_count = 0;
12606             stub_sec->flags &= ~SEC_RELOC;
12607           }
12608
12609       htab->brlt->size = 0;
12610       htab->brlt->reloc_count = 0;
12611       htab->brlt->flags &= ~SEC_RELOC;
12612       if (htab->relbrlt != NULL)
12613         htab->relbrlt->size = 0;
12614
12615       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12616
12617       for (group = htab->group; group != NULL; group = group->next)
12618         if (group->needs_save_res)
12619           group->stub_sec->size += htab->sfpr->size;
12620
12621       if (info->emitrelocations
12622           && htab->glink != NULL && htab->glink->size != 0)
12623         {
12624           htab->glink->reloc_count = 1;
12625           htab->glink->flags |= SEC_RELOC;
12626         }
12627
12628       if (htab->glink_eh_frame != NULL
12629           && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12630           && htab->glink_eh_frame->output_section->size != 0)
12631         {
12632           size_t size = 0, align;
12633
12634           for (stub_sec = htab->params->stub_bfd->sections;
12635                stub_sec != NULL;
12636                stub_sec = stub_sec->next)
12637             if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12638               size += 24;
12639           if (htab->glink != NULL && htab->glink->size != 0)
12640             size += 24;
12641           if (size != 0)
12642             size += sizeof (glink_eh_frame_cie);
12643           align = 1;
12644           align <<= htab->glink_eh_frame->output_section->alignment_power;
12645           align -= 1;
12646           size = (size + align) & ~align;
12647           htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12648           htab->glink_eh_frame->size = size;
12649         }
12650
12651       if (htab->params->plt_stub_align != 0)
12652         for (stub_sec = htab->params->stub_bfd->sections;
12653              stub_sec != NULL;
12654              stub_sec = stub_sec->next)
12655           if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12656             stub_sec->size = ((stub_sec->size
12657                                + (1 << htab->params->plt_stub_align) - 1)
12658                               & -(1 << htab->params->plt_stub_align));
12659
12660       for (stub_sec = htab->params->stub_bfd->sections;
12661            stub_sec != NULL;
12662            stub_sec = stub_sec->next)
12663         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12664             && stub_sec->rawsize != stub_sec->size
12665             && (htab->stub_iteration <= STUB_SHRINK_ITER
12666                 || stub_sec->rawsize < stub_sec->size))
12667           break;
12668
12669       if (stub_sec == NULL
12670           && (htab->glink_eh_frame == NULL
12671               || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12672         break;
12673
12674       /* Ask the linker to do its stuff.  */
12675       (*htab->params->layout_sections_again) ();
12676     }
12677
12678   if (htab->glink_eh_frame != NULL
12679       && htab->glink_eh_frame->size != 0)
12680     {
12681       bfd_vma val;
12682       bfd_byte *p, *last_fde;
12683       size_t last_fde_len, size, align, pad;
12684       asection *stub_sec;
12685
12686       p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12687       if (p == NULL)
12688         return FALSE;
12689       htab->glink_eh_frame->contents = p;
12690       last_fde = p;
12691
12692       memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12693       /* CIE length (rewrite in case little-endian).  */
12694       last_fde_len = sizeof (glink_eh_frame_cie) - 4;
12695       bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12696       p += sizeof (glink_eh_frame_cie);
12697
12698       for (stub_sec = htab->params->stub_bfd->sections;
12699            stub_sec != NULL;
12700            stub_sec = stub_sec->next)
12701         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12702           {
12703             last_fde = p;
12704             last_fde_len = 20;
12705             /* FDE length.  */
12706             bfd_put_32 (htab->elf.dynobj, 20, p);
12707             p += 4;
12708             /* CIE pointer.  */
12709             val = p - htab->glink_eh_frame->contents;
12710             bfd_put_32 (htab->elf.dynobj, val, p);
12711             p += 4;
12712             /* Offset to stub section, written later.  */
12713             p += 4;
12714             /* stub section size.  */
12715             bfd_put_32 (htab->elf.dynobj, stub_sec->size, p);
12716             p += 4;
12717             /* Augmentation.  */
12718             p += 1;
12719             /* Pad.  */
12720             p += 7;
12721           }
12722       if (htab->glink != NULL && htab->glink->size != 0)
12723         {
12724           last_fde = p;
12725           last_fde_len = 20;
12726           /* FDE length.  */
12727           bfd_put_32 (htab->elf.dynobj, 20, p);
12728           p += 4;
12729           /* CIE pointer.  */
12730           val = p - htab->glink_eh_frame->contents;
12731           bfd_put_32 (htab->elf.dynobj, val, p);
12732           p += 4;
12733           /* Offset to .glink, written later.  */
12734           p += 4;
12735           /* .glink size.  */
12736           bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12737           p += 4;
12738           /* Augmentation.  */
12739           p += 1;
12740
12741           *p++ = DW_CFA_advance_loc + 1;
12742           *p++ = DW_CFA_register;
12743           *p++ = 65;
12744           *p++ = htab->opd_abi ? 12 : 0;
12745           *p++ = DW_CFA_advance_loc + 4;
12746           *p++ = DW_CFA_restore_extended;
12747           *p++ = 65;
12748         }
12749       /* Subsume any padding into the last FDE if user .eh_frame
12750          sections are aligned more than glink_eh_frame.  Otherwise any
12751          zero padding will be seen as a terminator.  */
12752       size = p - htab->glink_eh_frame->contents;
12753       align = 1;
12754       align <<= htab->glink_eh_frame->output_section->alignment_power;
12755       align -= 1;
12756       pad = ((size + align) & ~align) - size;
12757       htab->glink_eh_frame->size = size + pad;
12758       bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12759     }
12760
12761   maybe_strip_output (info, htab->brlt);
12762   if (htab->glink_eh_frame != NULL)
12763     maybe_strip_output (info, htab->glink_eh_frame);
12764
12765   return TRUE;
12766 }
12767
12768 /* Called after we have determined section placement.  If sections
12769    move, we'll be called again.  Provide a value for TOCstart.  */
12770
12771 bfd_vma
12772 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12773 {
12774   asection *s;
12775   bfd_vma TOCstart, adjust;
12776
12777   if (info != NULL)
12778     {
12779       struct elf_link_hash_entry *h;
12780       struct elf_link_hash_table *htab = elf_hash_table (info);
12781
12782       if (is_elf_hash_table (htab)
12783           && htab->hgot != NULL)
12784         h = htab->hgot;
12785       else
12786         {
12787           h = elf_link_hash_lookup (htab, ".TOC.", FALSE, FALSE, TRUE);
12788           if (is_elf_hash_table (htab))
12789             htab->hgot = h;
12790         }
12791       if (h != NULL
12792           && h->root.type == bfd_link_hash_defined
12793           && !h->root.linker_def
12794           && (!is_elf_hash_table (htab)
12795               || h->def_regular))
12796         {
12797           TOCstart = (h->root.u.def.value - TOC_BASE_OFF
12798                       + h->root.u.def.section->output_offset
12799                       + h->root.u.def.section->output_section->vma);
12800           _bfd_set_gp_value (obfd, TOCstart);
12801           return TOCstart;
12802         }
12803     }
12804
12805   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12806      order.  The TOC starts where the first of these sections starts.  */
12807   s = bfd_get_section_by_name (obfd, ".got");
12808   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12809     s = bfd_get_section_by_name (obfd, ".toc");
12810   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12811     s = bfd_get_section_by_name (obfd, ".tocbss");
12812   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12813     s = bfd_get_section_by_name (obfd, ".plt");
12814   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12815     {
12816       /* This may happen for
12817          o  references to TOC base (SYM@toc / TOC[tc0]) without a
12818          .toc directive
12819          o  bad linker script
12820          o --gc-sections and empty TOC sections
12821
12822          FIXME: Warn user?  */
12823
12824       /* Look for a likely section.  We probably won't even be
12825          using TOCstart.  */
12826       for (s = obfd->sections; s != NULL; s = s->next)
12827         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
12828                          | SEC_EXCLUDE))
12829             == (SEC_ALLOC | SEC_SMALL_DATA))
12830           break;
12831       if (s == NULL)
12832         for (s = obfd->sections; s != NULL; s = s->next)
12833           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
12834               == (SEC_ALLOC | SEC_SMALL_DATA))
12835             break;
12836       if (s == NULL)
12837         for (s = obfd->sections; s != NULL; s = s->next)
12838           if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
12839               == SEC_ALLOC)
12840             break;
12841       if (s == NULL)
12842         for (s = obfd->sections; s != NULL; s = s->next)
12843           if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
12844             break;
12845     }
12846
12847   TOCstart = 0;
12848   if (s != NULL)
12849     TOCstart = s->output_section->vma + s->output_offset;
12850
12851   /* Force alignment.  */
12852   adjust = TOCstart & (TOC_BASE_ALIGN - 1);
12853   TOCstart -= adjust;
12854   _bfd_set_gp_value (obfd, TOCstart);
12855
12856   if (info != NULL && s != NULL)
12857     {
12858       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12859
12860       if (htab != NULL)
12861         {
12862           if (htab->elf.hgot != NULL)
12863             {
12864               htab->elf.hgot->root.u.def.value = TOC_BASE_OFF - adjust;
12865               htab->elf.hgot->root.u.def.section = s;
12866             }
12867         }
12868       else
12869         {
12870           struct bfd_link_hash_entry *bh = NULL;
12871           _bfd_generic_link_add_one_symbol (info, obfd, ".TOC.", BSF_GLOBAL,
12872                                             s, TOC_BASE_OFF - adjust,
12873                                             NULL, FALSE, FALSE, &bh);
12874         }
12875     }
12876   return TOCstart;
12877 }
12878
12879 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
12880    write out any global entry stubs.  */
12881
12882 static bfd_boolean
12883 build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
12884 {
12885   struct bfd_link_info *info;
12886   struct ppc_link_hash_table *htab;
12887   struct plt_entry *pent;
12888   asection *s;
12889
12890   if (h->root.type == bfd_link_hash_indirect)
12891     return TRUE;
12892
12893   if (!h->pointer_equality_needed)
12894     return TRUE;
12895
12896   if (h->def_regular)
12897     return TRUE;
12898
12899   info = inf;
12900   htab = ppc_hash_table (info);
12901   if (htab == NULL)
12902     return FALSE;
12903
12904   s = htab->glink;
12905   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
12906     if (pent->plt.offset != (bfd_vma) -1
12907         && pent->addend == 0)
12908       {
12909         bfd_byte *p;
12910         asection *plt;
12911         bfd_vma off;
12912
12913         p = s->contents + h->root.u.def.value;
12914         plt = htab->elf.splt;
12915         if (!htab->elf.dynamic_sections_created
12916             || h->dynindx == -1)
12917           plt = htab->elf.iplt;
12918         off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
12919         off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
12920
12921         if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
12922           {
12923             info->callbacks->einfo
12924               (_("%P: linkage table error against `%T'\n"),
12925                h->root.root.string);
12926             bfd_set_error (bfd_error_bad_value);
12927             htab->stub_error = TRUE;
12928           }
12929
12930         htab->stub_count[ppc_stub_global_entry - 1] += 1;
12931         if (htab->params->emit_stub_syms)
12932           {
12933             size_t len = strlen (h->root.root.string);
12934             char *name = bfd_malloc (sizeof "12345678.global_entry." + len);
12935
12936             if (name == NULL)
12937               return FALSE;
12938
12939             sprintf (name, "%08x.global_entry.%s", s->id, h->root.root.string);
12940             h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
12941             if (h == NULL)
12942               return FALSE;
12943             if (h->root.type == bfd_link_hash_new)
12944               {
12945                 h->root.type = bfd_link_hash_defined;
12946                 h->root.u.def.section = s;
12947                 h->root.u.def.value = p - s->contents;
12948                 h->ref_regular = 1;
12949                 h->def_regular = 1;
12950                 h->ref_regular_nonweak = 1;
12951                 h->forced_local = 1;
12952                 h->non_elf = 0;
12953                 h->root.linker_def = 1;
12954               }
12955           }
12956
12957         if (PPC_HA (off) != 0)
12958           {
12959             bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
12960             p += 4;
12961           }
12962         bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
12963         p += 4;
12964         bfd_put_32 (s->owner, MTCTR_R12, p);
12965         p += 4;
12966         bfd_put_32 (s->owner, BCTR, p);
12967         break;
12968       }
12969   return TRUE;
12970 }
12971
12972 /* Build all the stubs associated with the current output file.
12973    The stubs are kept in a hash table attached to the main linker
12974    hash table.  This function is called via gldelf64ppc_finish.  */
12975
12976 bfd_boolean
12977 ppc64_elf_build_stubs (struct bfd_link_info *info,
12978                        char **stats)
12979 {
12980   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12981   struct map_stub *group;
12982   asection *stub_sec;
12983   bfd_byte *p;
12984   int stub_sec_count = 0;
12985
12986   if (htab == NULL)
12987     return FALSE;
12988
12989   /* Allocate memory to hold the linker stubs.  */
12990   for (stub_sec = htab->params->stub_bfd->sections;
12991        stub_sec != NULL;
12992        stub_sec = stub_sec->next)
12993     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12994         && stub_sec->size != 0)
12995       {
12996         stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
12997         if (stub_sec->contents == NULL)
12998           return FALSE;
12999         stub_sec->size = 0;
13000       }
13001
13002   if (htab->glink != NULL && htab->glink->size != 0)
13003     {
13004       unsigned int indx;
13005       bfd_vma plt0;
13006
13007       /* Build the .glink plt call stub.  */
13008       if (htab->params->emit_stub_syms)
13009         {
13010           struct elf_link_hash_entry *h;
13011           h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
13012                                     TRUE, FALSE, FALSE);
13013           if (h == NULL)
13014             return FALSE;
13015           if (h->root.type == bfd_link_hash_new)
13016             {
13017               h->root.type = bfd_link_hash_defined;
13018               h->root.u.def.section = htab->glink;
13019               h->root.u.def.value = 8;
13020               h->ref_regular = 1;
13021               h->def_regular = 1;
13022               h->ref_regular_nonweak = 1;
13023               h->forced_local = 1;
13024               h->non_elf = 0;
13025               h->root.linker_def = 1;
13026             }
13027         }
13028       plt0 = (htab->elf.splt->output_section->vma
13029               + htab->elf.splt->output_offset
13030               - 16);
13031       if (info->emitrelocations)
13032         {
13033           Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
13034           if (r == NULL)
13035             return FALSE;
13036           r->r_offset = (htab->glink->output_offset
13037                          + htab->glink->output_section->vma);
13038           r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
13039           r->r_addend = plt0;
13040         }
13041       p = htab->glink->contents;
13042       plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
13043       bfd_put_64 (htab->glink->owner, plt0, p);
13044       p += 8;
13045       if (htab->opd_abi)
13046         {
13047           bfd_put_32 (htab->glink->owner, MFLR_R12, p);
13048           p += 4;
13049           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13050           p += 4;
13051           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13052           p += 4;
13053           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13054           p += 4;
13055           bfd_put_32 (htab->glink->owner, MTLR_R12, p);
13056           p += 4;
13057           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13058           p += 4;
13059           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13060           p += 4;
13061           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
13062           p += 4;
13063           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13064           p += 4;
13065           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
13066           p += 4;
13067         }
13068       else
13069         {
13070           bfd_put_32 (htab->glink->owner, MFLR_R0, p);
13071           p += 4;
13072           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13073           p += 4;
13074           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13075           p += 4;
13076           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13077           p += 4;
13078           bfd_put_32 (htab->glink->owner, MTLR_R0, p);
13079           p += 4;
13080           bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
13081           p += 4;
13082           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13083           p += 4;
13084           bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
13085           p += 4;
13086           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13087           p += 4;
13088           bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
13089           p += 4;
13090           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13091           p += 4;
13092           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
13093           p += 4;
13094         }
13095       bfd_put_32 (htab->glink->owner, BCTR, p);
13096       p += 4;
13097       while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
13098         {
13099           bfd_put_32 (htab->glink->owner, NOP, p);
13100           p += 4;
13101         }
13102
13103       /* Build the .glink lazy link call stubs.  */
13104       indx = 0;
13105       while (p < htab->glink->contents + htab->glink->rawsize)
13106         {
13107           if (htab->opd_abi)
13108             {
13109               if (indx < 0x8000)
13110                 {
13111                   bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
13112                   p += 4;
13113                 }
13114               else
13115                 {
13116                   bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
13117                   p += 4;
13118                   bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
13119                               p);
13120                   p += 4;
13121                 }
13122             }
13123           bfd_put_32 (htab->glink->owner,
13124                       B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
13125           indx++;
13126           p += 4;
13127         }
13128
13129       /* Build .glink global entry stubs.  */
13130       if (htab->glink->size > htab->glink->rawsize)
13131         elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
13132     }
13133
13134   if (htab->brlt != NULL && htab->brlt->size != 0)
13135     {
13136       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
13137                                          htab->brlt->size);
13138       if (htab->brlt->contents == NULL)
13139         return FALSE;
13140     }
13141   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
13142     {
13143       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
13144                                             htab->relbrlt->size);
13145       if (htab->relbrlt->contents == NULL)
13146         return FALSE;
13147     }
13148
13149   /* Build the stubs as directed by the stub hash table.  */
13150   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
13151
13152   for (group = htab->group; group != NULL; group = group->next)
13153     if (group->needs_save_res)
13154       {
13155         stub_sec = group->stub_sec;
13156         memcpy (stub_sec->contents + stub_sec->size, htab->sfpr->contents,
13157                 htab->sfpr->size);
13158         if (htab->params->emit_stub_syms)
13159           {
13160             unsigned int i;
13161
13162             for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
13163               if (!sfpr_define (info, &save_res_funcs[i], stub_sec))
13164                 return FALSE;
13165           }
13166         stub_sec->size += htab->sfpr->size;
13167       }
13168
13169   if (htab->relbrlt != NULL)
13170     htab->relbrlt->reloc_count = 0;
13171
13172   if (htab->params->plt_stub_align != 0)
13173     for (stub_sec = htab->params->stub_bfd->sections;
13174          stub_sec != NULL;
13175          stub_sec = stub_sec->next)
13176       if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
13177         stub_sec->size = ((stub_sec->size
13178                            + (1 << htab->params->plt_stub_align) - 1)
13179                           & -(1 << htab->params->plt_stub_align));
13180
13181   for (stub_sec = htab->params->stub_bfd->sections;
13182        stub_sec != NULL;
13183        stub_sec = stub_sec->next)
13184     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
13185       {
13186         stub_sec_count += 1;
13187         if (stub_sec->rawsize != stub_sec->size
13188             && (htab->stub_iteration <= STUB_SHRINK_ITER
13189                 || stub_sec->rawsize < stub_sec->size))
13190           break;
13191       }
13192
13193   /* Note that the glink_eh_frame check here is not only testing that
13194      the generated size matched the calculated size but also that
13195      bfd_elf_discard_info didn't make any changes to the section.  */
13196   if (stub_sec != NULL
13197       || (htab->glink_eh_frame != NULL
13198           && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
13199     {
13200       htab->stub_error = TRUE;
13201       info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
13202     }
13203
13204   if (htab->stub_error)
13205     return FALSE;
13206
13207   if (stats != NULL)
13208     {
13209       *stats = bfd_malloc (500);
13210       if (*stats == NULL)
13211         return FALSE;
13212
13213       sprintf (*stats, _("linker stubs in %u group%s\n"
13214                          "  branch       %lu\n"
13215                          "  toc adjust   %lu\n"
13216                          "  long branch  %lu\n"
13217                          "  long toc adj %lu\n"
13218                          "  plt call     %lu\n"
13219                          "  plt call toc %lu\n"
13220                          "  global entry %lu"),
13221                stub_sec_count,
13222                stub_sec_count == 1 ? "" : "s",
13223                htab->stub_count[ppc_stub_long_branch - 1],
13224                htab->stub_count[ppc_stub_long_branch_r2off - 1],
13225                htab->stub_count[ppc_stub_plt_branch - 1],
13226                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
13227                htab->stub_count[ppc_stub_plt_call - 1],
13228                htab->stub_count[ppc_stub_plt_call_r2save - 1],
13229                htab->stub_count[ppc_stub_global_entry - 1]);
13230     }
13231   return TRUE;
13232 }
13233
13234 /* This function undoes the changes made by add_symbol_adjust.  */
13235
13236 static bfd_boolean
13237 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
13238 {
13239   struct ppc_link_hash_entry *eh;
13240
13241   if (h->root.type == bfd_link_hash_indirect)
13242     return TRUE;
13243
13244   eh = (struct ppc_link_hash_entry *) h;
13245   if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
13246     return TRUE;
13247
13248   eh->elf.root.type = bfd_link_hash_undefined;
13249   return TRUE;
13250 }
13251
13252 void
13253 ppc64_elf_restore_symbols (struct bfd_link_info *info)
13254 {
13255   struct ppc_link_hash_table *htab = ppc_hash_table (info);
13256
13257   if (htab != NULL)
13258     elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
13259 }
13260
13261 /* What to do when ld finds relocations against symbols defined in
13262    discarded sections.  */
13263
13264 static unsigned int
13265 ppc64_elf_action_discarded (asection *sec)
13266 {
13267   if (strcmp (".opd", sec->name) == 0)
13268     return 0;
13269
13270   if (strcmp (".toc", sec->name) == 0)
13271     return 0;
13272
13273   if (strcmp (".toc1", sec->name) == 0)
13274     return 0;
13275
13276   return _bfd_elf_default_action_discarded (sec);
13277 }
13278
13279 /* The RELOCATE_SECTION function is called by the ELF backend linker
13280    to handle the relocations for a section.
13281
13282    The relocs are always passed as Rela structures; if the section
13283    actually uses Rel structures, the r_addend field will always be
13284    zero.
13285
13286    This function is responsible for adjust the section contents as
13287    necessary, and (if using Rela relocs and generating a
13288    relocatable output file) adjusting the reloc addend as
13289    necessary.
13290
13291    This function does not have to worry about setting the reloc
13292    address or the reloc symbol index.
13293
13294    LOCAL_SYMS is a pointer to the swapped in local symbols.
13295
13296    LOCAL_SECTIONS is an array giving the section in the input file
13297    corresponding to the st_shndx field of each local symbol.
13298
13299    The global hash table entry for the global symbols can be found
13300    via elf_sym_hashes (input_bfd).
13301
13302    When generating relocatable output, this function must handle
13303    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
13304    going to be the section symbol corresponding to the output
13305    section, which means that the addend must be adjusted
13306    accordingly.  */
13307
13308 static bfd_boolean
13309 ppc64_elf_relocate_section (bfd *output_bfd,
13310                             struct bfd_link_info *info,
13311                             bfd *input_bfd,
13312                             asection *input_section,
13313                             bfd_byte *contents,
13314                             Elf_Internal_Rela *relocs,
13315                             Elf_Internal_Sym *local_syms,
13316                             asection **local_sections)
13317 {
13318   struct ppc_link_hash_table *htab;
13319   Elf_Internal_Shdr *symtab_hdr;
13320   struct elf_link_hash_entry **sym_hashes;
13321   Elf_Internal_Rela *rel;
13322   Elf_Internal_Rela *wrel;
13323   Elf_Internal_Rela *relend;
13324   Elf_Internal_Rela outrel;
13325   bfd_byte *loc;
13326   struct got_entry **local_got_ents;
13327   bfd_vma TOCstart;
13328   bfd_boolean ret = TRUE;
13329   bfd_boolean is_opd;
13330   /* Assume 'at' branch hints.  */
13331   bfd_boolean is_isa_v2 = TRUE;
13332   bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
13333
13334   /* Initialize howto table if needed.  */
13335   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
13336     ppc_howto_init ();
13337
13338   htab = ppc_hash_table (info);
13339   if (htab == NULL)
13340     return FALSE;
13341
13342   /* Don't relocate stub sections.  */
13343   if (input_section->owner == htab->params->stub_bfd)
13344     return TRUE;
13345
13346   BFD_ASSERT (is_ppc64_elf (input_bfd));
13347
13348   local_got_ents = elf_local_got_ents (input_bfd);
13349   TOCstart = elf_gp (output_bfd);
13350   symtab_hdr = &elf_symtab_hdr (input_bfd);
13351   sym_hashes = elf_sym_hashes (input_bfd);
13352   is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
13353
13354   rel = wrel = relocs;
13355   relend = relocs + input_section->reloc_count;
13356   for (; rel < relend; wrel++, rel++)
13357     {
13358       enum elf_ppc64_reloc_type r_type;
13359       bfd_vma addend;
13360       bfd_reloc_status_type r;
13361       Elf_Internal_Sym *sym;
13362       asection *sec;
13363       struct elf_link_hash_entry *h_elf;
13364       struct ppc_link_hash_entry *h;
13365       struct ppc_link_hash_entry *fdh;
13366       const char *sym_name;
13367       unsigned long r_symndx, toc_symndx;
13368       bfd_vma toc_addend;
13369       unsigned char tls_mask, tls_gd, tls_type;
13370       unsigned char sym_type;
13371       bfd_vma relocation;
13372       bfd_boolean unresolved_reloc;
13373       bfd_boolean warned;
13374       enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
13375       unsigned int insn;
13376       unsigned int mask;
13377       struct ppc_stub_hash_entry *stub_entry;
13378       bfd_vma max_br_offset;
13379       bfd_vma from;
13380       Elf_Internal_Rela orig_rel;
13381       reloc_howto_type *howto;
13382       struct reloc_howto_struct alt_howto;
13383
13384     again:
13385       orig_rel = *rel;
13386
13387       r_type = ELF64_R_TYPE (rel->r_info);
13388       r_symndx = ELF64_R_SYM (rel->r_info);
13389
13390       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
13391          symbol of the previous ADDR64 reloc.  The symbol gives us the
13392          proper TOC base to use.  */
13393       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
13394           && wrel != relocs
13395           && ELF64_R_TYPE (wrel[-1].r_info) == R_PPC64_ADDR64
13396           && is_opd)
13397         r_symndx = ELF64_R_SYM (wrel[-1].r_info);
13398
13399       sym = NULL;
13400       sec = NULL;
13401       h_elf = NULL;
13402       sym_name = NULL;
13403       unresolved_reloc = FALSE;
13404       warned = FALSE;
13405
13406       if (r_symndx < symtab_hdr->sh_info)
13407         {
13408           /* It's a local symbol.  */
13409           struct _opd_sec_data *opd;
13410
13411           sym = local_syms + r_symndx;
13412           sec = local_sections[r_symndx];
13413           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
13414           sym_type = ELF64_ST_TYPE (sym->st_info);
13415           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
13416           opd = get_opd_info (sec);
13417           if (opd != NULL && opd->adjust != NULL)
13418             {
13419               long adjust = opd->adjust[OPD_NDX (sym->st_value
13420                                                  + rel->r_addend)];
13421               if (adjust == -1)
13422                 relocation = 0;
13423               else
13424                 {
13425                   /* If this is a relocation against the opd section sym
13426                      and we have edited .opd, adjust the reloc addend so
13427                      that ld -r and ld --emit-relocs output is correct.
13428                      If it is a reloc against some other .opd symbol,
13429                      then the symbol value will be adjusted later.  */
13430                   if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
13431                     rel->r_addend += adjust;
13432                   else
13433                     relocation += adjust;
13434                 }
13435             }
13436         }
13437       else
13438         {
13439           bfd_boolean ignored;
13440
13441           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
13442                                    r_symndx, symtab_hdr, sym_hashes,
13443                                    h_elf, sec, relocation,
13444                                    unresolved_reloc, warned, ignored);
13445           sym_name = h_elf->root.root.string;
13446           sym_type = h_elf->type;
13447           if (sec != NULL
13448               && sec->owner == output_bfd
13449               && strcmp (sec->name, ".opd") == 0)
13450             {
13451               /* This is a symbol defined in a linker script.  All
13452                  such are defined in output sections, even those
13453                  defined by simple assignment from a symbol defined in
13454                  an input section.  Transfer the symbol to an
13455                  appropriate input .opd section, so that a branch to
13456                  this symbol will be mapped to the location specified
13457                  by the opd entry.  */
13458               struct bfd_link_order *lo;
13459               for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
13460                 if (lo->type == bfd_indirect_link_order)
13461                   {
13462                     asection *isec = lo->u.indirect.section;
13463                     if (h_elf->root.u.def.value >= isec->output_offset
13464                         && h_elf->root.u.def.value < (isec->output_offset
13465                                                       + isec->size))
13466                       {
13467                         h_elf->root.u.def.value -= isec->output_offset;
13468                         h_elf->root.u.def.section = isec;
13469                         sec = isec;
13470                         break;
13471                       }
13472                   }
13473             }
13474         }
13475       h = (struct ppc_link_hash_entry *) h_elf;
13476
13477       if (sec != NULL && discarded_section (sec))
13478         {
13479           _bfd_clear_contents (ppc64_elf_howto_table[r_type],
13480                                input_bfd, input_section,
13481                                contents + rel->r_offset);
13482           wrel->r_offset = rel->r_offset;
13483           wrel->r_info = 0;
13484           wrel->r_addend = 0;
13485
13486           /* For ld -r, remove relocations in debug sections against
13487              sections defined in discarded sections.  Not done for
13488              non-debug to preserve relocs in .eh_frame which the
13489              eh_frame editing code expects to be present.  */
13490           if (bfd_link_relocatable (info)
13491               && (input_section->flags & SEC_DEBUGGING))
13492             wrel--;
13493
13494           continue;
13495         }
13496
13497       if (bfd_link_relocatable (info))
13498         goto copy_reloc;
13499
13500       if (h != NULL && &h->elf == htab->elf.hgot)
13501         {
13502           relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
13503           sec = bfd_abs_section_ptr;
13504           unresolved_reloc = FALSE;
13505         }
13506
13507       /* TLS optimizations.  Replace instruction sequences and relocs
13508          based on information we collected in tls_optimize.  We edit
13509          RELOCS so that --emit-relocs will output something sensible
13510          for the final instruction stream.  */
13511       tls_mask = 0;
13512       tls_gd = 0;
13513       toc_symndx = 0;
13514       if (h != NULL)
13515         tls_mask = h->tls_mask;
13516       else if (local_got_ents != NULL)
13517         {
13518           struct plt_entry **local_plt = (struct plt_entry **)
13519             (local_got_ents + symtab_hdr->sh_info);
13520           unsigned char *lgot_masks = (unsigned char *)
13521             (local_plt + symtab_hdr->sh_info);
13522           tls_mask = lgot_masks[r_symndx];
13523         }
13524       if (tls_mask == 0
13525           && (r_type == R_PPC64_TLS
13526               || r_type == R_PPC64_TLSGD
13527               || r_type == R_PPC64_TLSLD))
13528         {
13529           /* Check for toc tls entries.  */
13530           unsigned char *toc_tls;
13531
13532           if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13533                              &local_syms, rel, input_bfd))
13534             return FALSE;
13535
13536           if (toc_tls)
13537             tls_mask = *toc_tls;
13538         }
13539
13540       /* Check that tls relocs are used with tls syms, and non-tls
13541          relocs are used with non-tls syms.  */
13542       if (r_symndx != STN_UNDEF
13543           && r_type != R_PPC64_NONE
13544           && (h == NULL
13545               || h->elf.root.type == bfd_link_hash_defined
13546               || h->elf.root.type == bfd_link_hash_defweak)
13547           && (IS_PPC64_TLS_RELOC (r_type)
13548               != (sym_type == STT_TLS
13549                   || (sym_type == STT_SECTION
13550                       && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13551         {
13552           if (tls_mask != 0
13553               && (r_type == R_PPC64_TLS
13554                   || r_type == R_PPC64_TLSGD
13555                   || r_type == R_PPC64_TLSLD))
13556             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
13557             ;
13558           else
13559             info->callbacks->einfo
13560               (!IS_PPC64_TLS_RELOC (r_type)
13561                ? _("%P: %H: %s used with TLS symbol `%T'\n")
13562                : _("%P: %H: %s used with non-TLS symbol `%T'\n"),
13563                input_bfd, input_section, rel->r_offset,
13564                ppc64_elf_howto_table[r_type]->name,
13565                sym_name);
13566         }
13567
13568       /* Ensure reloc mapping code below stays sane.  */
13569       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13570           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13571           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
13572           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13573           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13574           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13575           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
13576           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13577           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13578           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13579         abort ();
13580
13581       switch (r_type)
13582         {
13583         default:
13584           break;
13585
13586         case R_PPC64_LO_DS_OPT:
13587           insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13588           if ((insn & (0x3f << 26)) != 58u << 26)
13589             abort ();
13590           insn += (14u << 26) - (58u << 26);
13591           bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13592           r_type = R_PPC64_TOC16_LO;
13593           rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13594           break;
13595
13596         case R_PPC64_TOC16:
13597         case R_PPC64_TOC16_LO:
13598         case R_PPC64_TOC16_DS:
13599         case R_PPC64_TOC16_LO_DS:
13600           {
13601             /* Check for toc tls entries.  */
13602             unsigned char *toc_tls;
13603             int retval;
13604
13605             retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13606                                    &local_syms, rel, input_bfd);
13607             if (retval == 0)
13608               return FALSE;
13609
13610             if (toc_tls)
13611               {
13612                 tls_mask = *toc_tls;
13613                 if (r_type == R_PPC64_TOC16_DS
13614                     || r_type == R_PPC64_TOC16_LO_DS)
13615                   {
13616                     if (tls_mask != 0
13617                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13618                       goto toctprel;
13619                   }
13620                 else
13621                   {
13622                     /* If we found a GD reloc pair, then we might be
13623                        doing a GD->IE transition.  */
13624                     if (retval == 2)
13625                       {
13626                         tls_gd = TLS_TPRELGD;
13627                         if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13628                           goto tls_ldgd_opt;
13629                       }
13630                     else if (retval == 3)
13631                       {
13632                         if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13633                           goto tls_ldgd_opt;
13634                       }
13635                   }
13636               }
13637           }
13638           break;
13639
13640         case R_PPC64_GOT_TPREL16_HI:
13641         case R_PPC64_GOT_TPREL16_HA:
13642           if (tls_mask != 0
13643               && (tls_mask & TLS_TPREL) == 0)
13644             {
13645               rel->r_offset -= d_offset;
13646               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13647               r_type = R_PPC64_NONE;
13648               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13649             }
13650           break;
13651
13652         case R_PPC64_GOT_TPREL16_DS:
13653         case R_PPC64_GOT_TPREL16_LO_DS:
13654           if (tls_mask != 0
13655               && (tls_mask & TLS_TPREL) == 0)
13656             {
13657             toctprel:
13658               insn = bfd_get_32 (output_bfd,
13659                                  contents + rel->r_offset - d_offset);
13660               insn &= 31 << 21;
13661               insn |= 0x3c0d0000;       /* addis 0,13,0 */
13662               bfd_put_32 (output_bfd, insn,
13663                           contents + rel->r_offset - d_offset);
13664               r_type = R_PPC64_TPREL16_HA;
13665               if (toc_symndx != 0)
13666                 {
13667                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13668                   rel->r_addend = toc_addend;
13669                   /* We changed the symbol.  Start over in order to
13670                      get h, sym, sec etc. right.  */
13671                   goto again;
13672                 }
13673               else
13674                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13675             }
13676           break;
13677
13678         case R_PPC64_TLS:
13679           if (tls_mask != 0
13680               && (tls_mask & TLS_TPREL) == 0)
13681             {
13682               insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
13683               insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13684               if (insn == 0)
13685                 abort ();
13686               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13687               /* Was PPC64_TLS which sits on insn boundary, now
13688                  PPC64_TPREL16_LO which is at low-order half-word.  */
13689               rel->r_offset += d_offset;
13690               r_type = R_PPC64_TPREL16_LO;
13691               if (toc_symndx != 0)
13692                 {
13693                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13694                   rel->r_addend = toc_addend;
13695                   /* We changed the symbol.  Start over in order to
13696                      get h, sym, sec etc. right.  */
13697                   goto again;
13698                 }
13699               else
13700                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13701             }
13702           break;
13703
13704         case R_PPC64_GOT_TLSGD16_HI:
13705         case R_PPC64_GOT_TLSGD16_HA:
13706           tls_gd = TLS_TPRELGD;
13707           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13708             goto tls_gdld_hi;
13709           break;
13710
13711         case R_PPC64_GOT_TLSLD16_HI:
13712         case R_PPC64_GOT_TLSLD16_HA:
13713           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13714             {
13715             tls_gdld_hi:
13716               if ((tls_mask & tls_gd) != 0)
13717                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13718                           + R_PPC64_GOT_TPREL16_DS);
13719               else
13720                 {
13721                   rel->r_offset -= d_offset;
13722                   bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13723                   r_type = R_PPC64_NONE;
13724                 }
13725               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13726             }
13727           break;
13728
13729         case R_PPC64_GOT_TLSGD16:
13730         case R_PPC64_GOT_TLSGD16_LO:
13731           tls_gd = TLS_TPRELGD;
13732           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13733             goto tls_ldgd_opt;
13734           break;
13735
13736         case R_PPC64_GOT_TLSLD16:
13737         case R_PPC64_GOT_TLSLD16_LO:
13738           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13739             {
13740               unsigned int insn1, insn2, insn3;
13741               bfd_vma offset;
13742
13743             tls_ldgd_opt:
13744               offset = (bfd_vma) -1;
13745               /* If not using the newer R_PPC64_TLSGD/LD to mark
13746                  __tls_get_addr calls, we must trust that the call
13747                  stays with its arg setup insns, ie. that the next
13748                  reloc is the __tls_get_addr call associated with
13749                  the current reloc.  Edit both insns.  */
13750               if (input_section->has_tls_get_addr_call
13751                   && rel + 1 < relend
13752                   && branch_reloc_hash_match (input_bfd, rel + 1,
13753                                               htab->tls_get_addr,
13754                                               htab->tls_get_addr_fd))
13755                 offset = rel[1].r_offset;
13756               /* We read the low GOT_TLS (or TOC16) insn because we
13757                  need to keep the destination reg.  It may be
13758                  something other than the usual r3, and moved to r3
13759                  before the call by intervening code.  */
13760               insn1 = bfd_get_32 (output_bfd,
13761                                   contents + rel->r_offset - d_offset);
13762               if ((tls_mask & tls_gd) != 0)
13763                 {
13764                   /* IE */
13765                   insn1 &= (0x1f << 21) | (0x1f << 16);
13766                   insn1 |= 58 << 26;    /* ld */
13767                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13768                   if (offset != (bfd_vma) -1)
13769                     rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13770                   if ((tls_mask & TLS_EXPLICIT) == 0)
13771                     r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13772                               + R_PPC64_GOT_TPREL16_DS);
13773                   else
13774                     r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13775                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13776                 }
13777               else
13778                 {
13779                   /* LE */
13780                   insn1 &= 0x1f << 21;
13781                   insn1 |= 0x3c0d0000;  /* addis r,13,0 */
13782                   insn2 = 0x38630000;   /* addi 3,3,0 */
13783                   if (tls_gd == 0)
13784                     {
13785                       /* Was an LD reloc.  */
13786                       if (toc_symndx)
13787                         sec = local_sections[toc_symndx];
13788                       for (r_symndx = 0;
13789                            r_symndx < symtab_hdr->sh_info;
13790                            r_symndx++)
13791                         if (local_sections[r_symndx] == sec)
13792                           break;
13793                       if (r_symndx >= symtab_hdr->sh_info)
13794                         r_symndx = STN_UNDEF;
13795                       rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13796                       if (r_symndx != STN_UNDEF)
13797                         rel->r_addend -= (local_syms[r_symndx].st_value
13798                                           + sec->output_offset
13799                                           + sec->output_section->vma);
13800                     }
13801                   else if (toc_symndx != 0)
13802                     {
13803                       r_symndx = toc_symndx;
13804                       rel->r_addend = toc_addend;
13805                     }
13806                   r_type = R_PPC64_TPREL16_HA;
13807                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13808                   if (offset != (bfd_vma) -1)
13809                     {
13810                       rel[1].r_info = ELF64_R_INFO (r_symndx,
13811                                                     R_PPC64_TPREL16_LO);
13812                       rel[1].r_offset = offset + d_offset;
13813                       rel[1].r_addend = rel->r_addend;
13814                     }
13815                 }
13816               bfd_put_32 (output_bfd, insn1,
13817                           contents + rel->r_offset - d_offset);
13818               if (offset != (bfd_vma) -1)
13819                 {
13820                   insn3 = bfd_get_32 (output_bfd,
13821                                       contents + offset + 4);
13822                   if (insn3 == NOP
13823                       || insn3 == CROR_151515 || insn3 == CROR_313131)
13824                     {
13825                       rel[1].r_offset += 4;
13826                       bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13827                       insn2 = NOP;
13828                     }
13829                   bfd_put_32 (output_bfd, insn2, contents + offset);
13830                 }
13831               if ((tls_mask & tls_gd) == 0
13832                   && (tls_gd == 0 || toc_symndx != 0))
13833                 {
13834                   /* We changed the symbol.  Start over in order
13835                      to get h, sym, sec etc. right.  */
13836                   goto again;
13837                 }
13838             }
13839           break;
13840
13841         case R_PPC64_TLSGD:
13842           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13843             {
13844               unsigned int insn2, insn3;
13845               bfd_vma offset = rel->r_offset;
13846
13847               if ((tls_mask & TLS_TPRELGD) != 0)
13848                 {
13849                   /* IE */
13850                   r_type = R_PPC64_NONE;
13851                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13852                 }
13853               else
13854                 {
13855                   /* LE */
13856                   if (toc_symndx != 0)
13857                     {
13858                       r_symndx = toc_symndx;
13859                       rel->r_addend = toc_addend;
13860                     }
13861                   r_type = R_PPC64_TPREL16_LO;
13862                   rel->r_offset = offset + d_offset;
13863                   insn2 = 0x38630000;   /* addi 3,3,0 */
13864                 }
13865               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13866               /* Zap the reloc on the _tls_get_addr call too.  */
13867               BFD_ASSERT (offset == rel[1].r_offset);
13868               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13869               insn3 = bfd_get_32 (output_bfd,
13870                                   contents + offset + 4);
13871               if (insn3 == NOP
13872                   || insn3 == CROR_151515 || insn3 == CROR_313131)
13873                 {
13874                   rel->r_offset += 4;
13875                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13876                   insn2 = NOP;
13877                 }
13878               bfd_put_32 (output_bfd, insn2, contents + offset);
13879               if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
13880                 goto again;
13881             }
13882           break;
13883
13884         case R_PPC64_TLSLD:
13885           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13886             {
13887               unsigned int insn2, insn3;
13888               bfd_vma offset = rel->r_offset;
13889
13890               if (toc_symndx)
13891                 sec = local_sections[toc_symndx];
13892               for (r_symndx = 0;
13893                    r_symndx < symtab_hdr->sh_info;
13894                    r_symndx++)
13895                 if (local_sections[r_symndx] == sec)
13896                   break;
13897               if (r_symndx >= symtab_hdr->sh_info)
13898                 r_symndx = STN_UNDEF;
13899               rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13900               if (r_symndx != STN_UNDEF)
13901                 rel->r_addend -= (local_syms[r_symndx].st_value
13902                                   + sec->output_offset
13903                                   + sec->output_section->vma);
13904
13905               r_type = R_PPC64_TPREL16_LO;
13906               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13907               rel->r_offset = offset + d_offset;
13908               /* Zap the reloc on the _tls_get_addr call too.  */
13909               BFD_ASSERT (offset == rel[1].r_offset);
13910               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13911               insn2 = 0x38630000;       /* addi 3,3,0 */
13912               insn3 = bfd_get_32 (output_bfd,
13913                                   contents + offset + 4);
13914               if (insn3 == NOP
13915                   || insn3 == CROR_151515 || insn3 == CROR_313131)
13916                 {
13917                   rel->r_offset += 4;
13918                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13919                   insn2 = NOP;
13920                 }
13921               bfd_put_32 (output_bfd, insn2, contents + offset);
13922               goto again;
13923             }
13924           break;
13925
13926         case R_PPC64_DTPMOD64:
13927           if (rel + 1 < relend
13928               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
13929               && rel[1].r_offset == rel->r_offset + 8)
13930             {
13931               if ((tls_mask & TLS_GD) == 0)
13932                 {
13933                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
13934                   if ((tls_mask & TLS_TPRELGD) != 0)
13935                     r_type = R_PPC64_TPREL64;
13936                   else
13937                     {
13938                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13939                       r_type = R_PPC64_NONE;
13940                     }
13941                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13942                 }
13943             }
13944           else
13945             {
13946               if ((tls_mask & TLS_LD) == 0)
13947                 {
13948                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13949                   r_type = R_PPC64_NONE;
13950                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13951                 }
13952             }
13953           break;
13954
13955         case R_PPC64_TPREL64:
13956           if ((tls_mask & TLS_TPREL) == 0)
13957             {
13958               r_type = R_PPC64_NONE;
13959               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13960             }
13961           break;
13962
13963         case R_PPC64_ENTRY:
13964           relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
13965           if (!bfd_link_pic (info)
13966               && !info->traditional_format
13967               && relocation + 0x80008000 <= 0xffffffff)
13968             {
13969               unsigned int insn1, insn2;
13970
13971               insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
13972               insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
13973               if ((insn1 & ~0xfffc) == LD_R2_0R12
13974                   && insn2 == ADD_R2_R2_R12)
13975                 {
13976                   bfd_put_32 (output_bfd,
13977                               LIS_R2 + PPC_HA (relocation),
13978                               contents + rel->r_offset);
13979                   bfd_put_32 (output_bfd,
13980                               ADDI_R2_R2 + PPC_LO (relocation),
13981                               contents + rel->r_offset + 4);
13982                 }
13983             }
13984           else
13985             {
13986               relocation -= (rel->r_offset
13987                              + input_section->output_offset
13988                              + input_section->output_section->vma);
13989               if (relocation + 0x80008000 <= 0xffffffff)
13990                 {
13991                   unsigned int insn1, insn2;
13992
13993                   insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
13994                   insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
13995                   if ((insn1 & ~0xfffc) == LD_R2_0R12
13996                       && insn2 == ADD_R2_R2_R12)
13997                     {
13998                       bfd_put_32 (output_bfd,
13999                                   ADDIS_R2_R12 + PPC_HA (relocation),
14000                                   contents + rel->r_offset);
14001                       bfd_put_32 (output_bfd,
14002                                   ADDI_R2_R2 + PPC_LO (relocation),
14003                                   contents + rel->r_offset + 4);
14004                     }
14005                 }
14006             }
14007           break;
14008
14009         case R_PPC64_REL16_HA:
14010           /* If we are generating a non-PIC executable, edit
14011              .  0:      addis 2,12,.TOC.-0b@ha
14012              .          addi 2,2,.TOC.-0b@l
14013              used by ELFv2 global entry points to set up r2, to
14014              .          lis 2,.TOC.@ha
14015              .          addi 2,2,.TOC.@l
14016              if .TOC. is in range.  */
14017           if (!bfd_link_pic (info)
14018               && !info->traditional_format
14019               && !htab->opd_abi
14020               && rel->r_addend == d_offset
14021               && h != NULL && &h->elf == htab->elf.hgot
14022               && rel + 1 < relend
14023               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
14024               && rel[1].r_offset == rel->r_offset + 4
14025               && rel[1].r_addend == rel->r_addend + 4
14026               && relocation + 0x80008000 <= 0xffffffff)
14027             {
14028               unsigned int insn1, insn2;
14029               bfd_vma offset = rel->r_offset - d_offset;
14030               insn1 = bfd_get_32 (output_bfd, contents + offset);
14031               insn2 = bfd_get_32 (output_bfd, contents + offset + 4);
14032               if ((insn1 & 0xffff0000) == ADDIS_R2_R12
14033                   && (insn2 & 0xffff0000) == ADDI_R2_R2)
14034                 {
14035                   r_type = R_PPC64_ADDR16_HA;
14036                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14037                   rel->r_addend -= d_offset;
14038                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
14039                   rel[1].r_addend -= d_offset + 4;
14040                   bfd_put_32 (output_bfd, LIS_R2, contents + offset);
14041                 }
14042             }
14043           break;
14044         }
14045
14046       /* Handle other relocations that tweak non-addend part of insn.  */
14047       insn = 0;
14048       max_br_offset = 1 << 25;
14049       addend = rel->r_addend;
14050       reloc_dest = DEST_NORMAL;
14051       switch (r_type)
14052         {
14053         default:
14054           break;
14055
14056         case R_PPC64_TOCSAVE:
14057           if (relocation + addend == (rel->r_offset
14058                                       + input_section->output_offset
14059                                       + input_section->output_section->vma)
14060               && tocsave_find (htab, NO_INSERT,
14061                                &local_syms, rel, input_bfd))
14062             {
14063               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
14064               if (insn == NOP
14065                   || insn == CROR_151515 || insn == CROR_313131)
14066                 bfd_put_32 (input_bfd,
14067                             STD_R2_0R1 + STK_TOC (htab),
14068                             contents + rel->r_offset);
14069             }
14070           break;
14071
14072           /* Branch taken prediction relocations.  */
14073         case R_PPC64_ADDR14_BRTAKEN:
14074         case R_PPC64_REL14_BRTAKEN:
14075           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
14076           /* Fall thru.  */
14077
14078           /* Branch not taken prediction relocations.  */
14079         case R_PPC64_ADDR14_BRNTAKEN:
14080         case R_PPC64_REL14_BRNTAKEN:
14081           insn |= bfd_get_32 (output_bfd,
14082                               contents + rel->r_offset) & ~(0x01 << 21);
14083           /* Fall thru.  */
14084
14085         case R_PPC64_REL14:
14086           max_br_offset = 1 << 15;
14087           /* Fall thru.  */
14088
14089         case R_PPC64_REL24:
14090           /* Calls to functions with a different TOC, such as calls to
14091              shared objects, need to alter the TOC pointer.  This is
14092              done using a linkage stub.  A REL24 branching to these
14093              linkage stubs needs to be followed by a nop, as the nop
14094              will be replaced with an instruction to restore the TOC
14095              base pointer.  */
14096           fdh = h;
14097           if (h != NULL
14098               && h->oh != NULL
14099               && h->oh->is_func_descriptor)
14100             fdh = ppc_follow_link (h->oh);
14101           stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
14102                                            htab);
14103           if (stub_entry != NULL
14104               && (stub_entry->stub_type == ppc_stub_plt_call
14105                   || stub_entry->stub_type == ppc_stub_plt_call_r2save
14106                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
14107                   || stub_entry->stub_type == ppc_stub_long_branch_r2off))
14108             {
14109               bfd_boolean can_plt_call = FALSE;
14110
14111               /* All of these stubs will modify r2, so there must be a
14112                  branch and link followed by a nop.  The nop is
14113                  replaced by an insn to restore r2.  */
14114               if (rel->r_offset + 8 <= input_section->size)
14115                 {
14116                   unsigned long br;
14117
14118                   br = bfd_get_32 (input_bfd,
14119                                    contents + rel->r_offset);
14120                   if ((br & 1) != 0)
14121                     {
14122                       unsigned long nop;
14123
14124                       nop = bfd_get_32 (input_bfd,
14125                                         contents + rel->r_offset + 4);
14126                       if (nop == NOP
14127                           || nop == CROR_151515 || nop == CROR_313131)
14128                         {
14129                           if (h != NULL
14130                               && (h == htab->tls_get_addr_fd
14131                                   || h == htab->tls_get_addr)
14132                               && htab->params->tls_get_addr_opt)
14133                             {
14134                               /* Special stub used, leave nop alone.  */
14135                             }
14136                           else
14137                             bfd_put_32 (input_bfd,
14138                                         LD_R2_0R1 + STK_TOC (htab),
14139                                         contents + rel->r_offset + 4);
14140                           can_plt_call = TRUE;
14141                         }
14142                     }
14143                 }
14144
14145               if (!can_plt_call && h != NULL)
14146                 {
14147                   const char *name = h->elf.root.root.string;
14148
14149                   if (*name == '.')
14150                     ++name;
14151
14152                   if (strncmp (name, "__libc_start_main", 17) == 0
14153                       && (name[17] == 0 || name[17] == '@'))
14154                     {
14155                       /* Allow crt1 branch to go via a toc adjusting
14156                          stub.  Other calls that never return could do
14157                          the same, if we could detect such.  */
14158                       can_plt_call = TRUE;
14159                     }
14160                 }
14161
14162               if (!can_plt_call)
14163                 {
14164                   /* g++ as of 20130507 emits self-calls without a
14165                      following nop.  This is arguably wrong since we
14166                      have conflicting information.  On the one hand a
14167                      global symbol and on the other a local call
14168                      sequence, but don't error for this special case.
14169                      It isn't possible to cheaply verify we have
14170                      exactly such a call.  Allow all calls to the same
14171                      section.  */
14172                   asection *code_sec = sec;
14173
14174                   if (get_opd_info (sec) != NULL)
14175                     {
14176                       bfd_vma off = (relocation + addend
14177                                      - sec->output_section->vma
14178                                      - sec->output_offset);
14179
14180                       opd_entry_value (sec, off, &code_sec, NULL, FALSE);
14181                     }
14182                   if (code_sec == input_section)
14183                     can_plt_call = TRUE;
14184                 }
14185
14186               if (!can_plt_call)
14187                 {
14188                   if (stub_entry->stub_type == ppc_stub_plt_call
14189                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14190                     info->callbacks->einfo
14191                       (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
14192                          "recompile with -fPIC\n"),
14193                        input_bfd, input_section, rel->r_offset, sym_name);
14194                   else
14195                     info->callbacks->einfo
14196                       (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
14197                          "(-mcmodel=small toc adjust stub)\n"),
14198                        input_bfd, input_section, rel->r_offset, sym_name);
14199
14200                   bfd_set_error (bfd_error_bad_value);
14201                   ret = FALSE;
14202                 }
14203
14204               if (can_plt_call
14205                   && (stub_entry->stub_type == ppc_stub_plt_call
14206                       || stub_entry->stub_type == ppc_stub_plt_call_r2save))
14207                 unresolved_reloc = FALSE;
14208             }
14209
14210           if ((stub_entry == NULL
14211                || stub_entry->stub_type == ppc_stub_long_branch
14212                || stub_entry->stub_type == ppc_stub_plt_branch)
14213               && get_opd_info (sec) != NULL)
14214             {
14215               /* The branch destination is the value of the opd entry. */
14216               bfd_vma off = (relocation + addend
14217                              - sec->output_section->vma
14218                              - sec->output_offset);
14219               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
14220               if (dest != (bfd_vma) -1)
14221                 {
14222                   relocation = dest;
14223                   addend = 0;
14224                   reloc_dest = DEST_OPD;
14225                 }
14226             }
14227
14228           /* If the branch is out of reach we ought to have a long
14229              branch stub.  */
14230           from = (rel->r_offset
14231                   + input_section->output_offset
14232                   + input_section->output_section->vma);
14233
14234           relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
14235                                                   ? fdh->elf.other
14236                                                   : sym->st_other);
14237
14238           if (stub_entry != NULL
14239               && (stub_entry->stub_type == ppc_stub_long_branch
14240                   || stub_entry->stub_type == ppc_stub_plt_branch)
14241               && (r_type == R_PPC64_ADDR14_BRTAKEN
14242                   || r_type == R_PPC64_ADDR14_BRNTAKEN
14243                   || (relocation + addend - from + max_br_offset
14244                       < 2 * max_br_offset)))
14245             /* Don't use the stub if this branch is in range.  */
14246             stub_entry = NULL;
14247
14248           if (stub_entry != NULL)
14249             {
14250               /* Munge up the value and addend so that we call the stub
14251                  rather than the procedure directly.  */
14252               asection *stub_sec = stub_entry->group->stub_sec;
14253
14254               if (stub_entry->stub_type == ppc_stub_save_res)
14255                 relocation += (stub_sec->output_offset
14256                                + stub_sec->output_section->vma
14257                                + stub_sec->size - htab->sfpr->size
14258                                - htab->sfpr->output_offset
14259                                - htab->sfpr->output_section->vma);
14260               else
14261                 relocation = (stub_entry->stub_offset
14262                               + stub_sec->output_offset
14263                               + stub_sec->output_section->vma);
14264               addend = 0;
14265               reloc_dest = DEST_STUB;
14266
14267               if ((stub_entry->stub_type == ppc_stub_plt_call
14268                    || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14269                   && (ALWAYS_EMIT_R2SAVE
14270                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14271                   && rel + 1 < relend
14272                   && rel[1].r_offset == rel->r_offset + 4
14273                   && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
14274                 relocation += 4;
14275             }
14276
14277           if (insn != 0)
14278             {
14279               if (is_isa_v2)
14280                 {
14281                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
14282                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
14283                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
14284                   if ((insn & (0x14 << 21)) == (0x04 << 21))
14285                     insn |= 0x02 << 21;
14286                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
14287                     insn |= 0x08 << 21;
14288                   else
14289                     break;
14290                 }
14291               else
14292                 {
14293                   /* Invert 'y' bit if not the default.  */
14294                   if ((bfd_signed_vma) (relocation + addend - from) < 0)
14295                     insn ^= 0x01 << 21;
14296                 }
14297
14298               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
14299             }
14300
14301           /* NOP out calls to undefined weak functions.
14302              We can thus call a weak function without first
14303              checking whether the function is defined.  */
14304           else if (h != NULL
14305                    && h->elf.root.type == bfd_link_hash_undefweak
14306                    && h->elf.dynindx == -1
14307                    && r_type == R_PPC64_REL24
14308                    && relocation == 0
14309                    && addend == 0)
14310             {
14311               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
14312               goto copy_reloc;
14313             }
14314           break;
14315         }
14316
14317       /* Set `addend'.  */
14318       tls_type = 0;
14319       switch (r_type)
14320         {
14321         default:
14322           info->callbacks->einfo
14323             (_("%P: %B: unknown relocation type %d for `%T'\n"),
14324              input_bfd, (int) r_type, sym_name);
14325
14326           bfd_set_error (bfd_error_bad_value);
14327           ret = FALSE;
14328           goto copy_reloc;
14329
14330         case R_PPC64_NONE:
14331         case R_PPC64_TLS:
14332         case R_PPC64_TLSGD:
14333         case R_PPC64_TLSLD:
14334         case R_PPC64_TOCSAVE:
14335         case R_PPC64_GNU_VTINHERIT:
14336         case R_PPC64_GNU_VTENTRY:
14337         case R_PPC64_ENTRY:
14338           goto copy_reloc;
14339
14340           /* GOT16 relocations.  Like an ADDR16 using the symbol's
14341              address in the GOT as relocation value instead of the
14342              symbol's value itself.  Also, create a GOT entry for the
14343              symbol and put the symbol value there.  */
14344         case R_PPC64_GOT_TLSGD16:
14345         case R_PPC64_GOT_TLSGD16_LO:
14346         case R_PPC64_GOT_TLSGD16_HI:
14347         case R_PPC64_GOT_TLSGD16_HA:
14348           tls_type = TLS_TLS | TLS_GD;
14349           goto dogot;
14350
14351         case R_PPC64_GOT_TLSLD16:
14352         case R_PPC64_GOT_TLSLD16_LO:
14353         case R_PPC64_GOT_TLSLD16_HI:
14354         case R_PPC64_GOT_TLSLD16_HA:
14355           tls_type = TLS_TLS | TLS_LD;
14356           goto dogot;
14357
14358         case R_PPC64_GOT_TPREL16_DS:
14359         case R_PPC64_GOT_TPREL16_LO_DS:
14360         case R_PPC64_GOT_TPREL16_HI:
14361         case R_PPC64_GOT_TPREL16_HA:
14362           tls_type = TLS_TLS | TLS_TPREL;
14363           goto dogot;
14364
14365         case R_PPC64_GOT_DTPREL16_DS:
14366         case R_PPC64_GOT_DTPREL16_LO_DS:
14367         case R_PPC64_GOT_DTPREL16_HI:
14368         case R_PPC64_GOT_DTPREL16_HA:
14369           tls_type = TLS_TLS | TLS_DTPREL;
14370           goto dogot;
14371
14372         case R_PPC64_GOT16:
14373         case R_PPC64_GOT16_LO:
14374         case R_PPC64_GOT16_HI:
14375         case R_PPC64_GOT16_HA:
14376         case R_PPC64_GOT16_DS:
14377         case R_PPC64_GOT16_LO_DS:
14378         dogot:
14379           {
14380             /* Relocation is to the entry for this symbol in the global
14381                offset table.  */
14382             asection *got;
14383             bfd_vma *offp;
14384             bfd_vma off;
14385             unsigned long indx = 0;
14386             struct got_entry *ent;
14387
14388             if (tls_type == (TLS_TLS | TLS_LD)
14389                 && (h == NULL
14390                     || !h->elf.def_dynamic))
14391               ent = ppc64_tlsld_got (input_bfd);
14392             else
14393               {
14394
14395                 if (h != NULL)
14396                   {
14397                     bfd_boolean dyn = htab->elf.dynamic_sections_created;
14398                     if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info),
14399                                                           &h->elf)
14400                         || (bfd_link_pic (info)
14401                             && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
14402                       /* This is actually a static link, or it is a
14403                          -Bsymbolic link and the symbol is defined
14404                          locally, or the symbol was forced to be local
14405                          because of a version file.  */
14406                       ;
14407                     else
14408                       {
14409                         BFD_ASSERT (h->elf.dynindx != -1);
14410                         indx = h->elf.dynindx;
14411                         unresolved_reloc = FALSE;
14412                       }
14413                     ent = h->elf.got.glist;
14414                   }
14415                 else
14416                   {
14417                     if (local_got_ents == NULL)
14418                       abort ();
14419                     ent = local_got_ents[r_symndx];
14420                   }
14421
14422                 for (; ent != NULL; ent = ent->next)
14423                   if (ent->addend == orig_rel.r_addend
14424                       && ent->owner == input_bfd
14425                       && ent->tls_type == tls_type)
14426                     break;
14427               }
14428
14429             if (ent == NULL)
14430               abort ();
14431             if (ent->is_indirect)
14432               ent = ent->got.ent;
14433             offp = &ent->got.offset;
14434             got = ppc64_elf_tdata (ent->owner)->got;
14435             if (got == NULL)
14436               abort ();
14437
14438             /* The offset must always be a multiple of 8.  We use the
14439                least significant bit to record whether we have already
14440                processed this entry.  */
14441             off = *offp;
14442             if ((off & 1) != 0)
14443               off &= ~1;
14444             else
14445               {
14446                 /* Generate relocs for the dynamic linker, except in
14447                    the case of TLSLD where we'll use one entry per
14448                    module.  */
14449                 asection *relgot;
14450                 bfd_boolean ifunc;
14451
14452                 *offp = off | 1;
14453                 relgot = NULL;
14454                 ifunc = (h != NULL
14455                          ? h->elf.type == STT_GNU_IFUNC
14456                          : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
14457                 if (ifunc)
14458                   relgot = htab->elf.irelplt;
14459                 else if ((bfd_link_pic (info) || indx != 0)
14460                          && (h == NULL
14461                              || (tls_type == (TLS_TLS | TLS_LD)
14462                                  && !h->elf.def_dynamic)
14463                              || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14464                              || h->elf.root.type != bfd_link_hash_undefweak))
14465                   relgot = ppc64_elf_tdata (ent->owner)->relgot;
14466                 if (relgot != NULL)
14467                   {
14468                     outrel.r_offset = (got->output_section->vma
14469                                        + got->output_offset
14470                                        + off);
14471                     outrel.r_addend = addend;
14472                     if (tls_type & (TLS_LD | TLS_GD))
14473                       {
14474                         outrel.r_addend = 0;
14475                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
14476                         if (tls_type == (TLS_TLS | TLS_GD))
14477                           {
14478                             loc = relgot->contents;
14479                             loc += (relgot->reloc_count++
14480                                     * sizeof (Elf64_External_Rela));
14481                             bfd_elf64_swap_reloca_out (output_bfd,
14482                                                        &outrel, loc);
14483                             outrel.r_offset += 8;
14484                             outrel.r_addend = addend;
14485                             outrel.r_info
14486                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14487                           }
14488                       }
14489                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
14490                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14491                     else if (tls_type == (TLS_TLS | TLS_TPREL))
14492                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
14493                     else if (indx != 0)
14494                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
14495                     else
14496                       {
14497                         if (ifunc)
14498                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14499                         else
14500                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14501
14502                         /* Write the .got section contents for the sake
14503                            of prelink.  */
14504                         loc = got->contents + off;
14505                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
14506                                     loc);
14507                       }
14508
14509                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
14510                       {
14511                         outrel.r_addend += relocation;
14512                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
14513                           {
14514                             if (htab->elf.tls_sec == NULL)
14515                               outrel.r_addend = 0;
14516                             else
14517                               outrel.r_addend -= htab->elf.tls_sec->vma;
14518                           }
14519                       }
14520                     loc = relgot->contents;
14521                     loc += (relgot->reloc_count++
14522                             * sizeof (Elf64_External_Rela));
14523                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14524                   }
14525
14526                 /* Init the .got section contents here if we're not
14527                    emitting a reloc.  */
14528                 else
14529                   {
14530                     relocation += addend;
14531                     if (tls_type == (TLS_TLS | TLS_LD))
14532                       relocation = 1;
14533                     else if (tls_type != 0)
14534                       {
14535                         if (htab->elf.tls_sec == NULL)
14536                           relocation = 0;
14537                         else
14538                           {
14539                             relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
14540                             if (tls_type == (TLS_TLS | TLS_TPREL))
14541                               relocation += DTP_OFFSET - TP_OFFSET;
14542                           }
14543
14544                         if (tls_type == (TLS_TLS | TLS_GD))
14545                           {
14546                             bfd_put_64 (output_bfd, relocation,
14547                                         got->contents + off + 8);
14548                             relocation = 1;
14549                           }
14550                       }
14551
14552                     bfd_put_64 (output_bfd, relocation,
14553                                 got->contents + off);
14554                   }
14555               }
14556
14557             if (off >= (bfd_vma) -2)
14558               abort ();
14559
14560             relocation = got->output_section->vma + got->output_offset + off;
14561             addend = -(TOCstart + htab->sec_info[input_section->id].toc_off);
14562           }
14563           break;
14564
14565         case R_PPC64_PLT16_HA:
14566         case R_PPC64_PLT16_HI:
14567         case R_PPC64_PLT16_LO:
14568         case R_PPC64_PLT32:
14569         case R_PPC64_PLT64:
14570           /* Relocation is to the entry for this symbol in the
14571              procedure linkage table.  */
14572           {
14573             struct plt_entry **plt_list = NULL;
14574             if (h != NULL)
14575               plt_list = &h->elf.plt.plist;
14576             else if (local_got_ents != NULL)
14577               {
14578                 struct plt_entry **local_plt = (struct plt_entry **)
14579                   (local_got_ents + symtab_hdr->sh_info);
14580                 unsigned char *local_got_tls_masks = (unsigned char *)
14581                   (local_plt + symtab_hdr->sh_info);
14582                 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
14583                   plt_list = local_plt + r_symndx;
14584               }
14585             if (plt_list)
14586               {
14587                 struct plt_entry *ent;
14588
14589                 for (ent = *plt_list; ent != NULL; ent = ent->next)
14590                   if (ent->plt.offset != (bfd_vma) -1
14591                       && ent->addend == orig_rel.r_addend)
14592                     {
14593                       asection *plt;
14594
14595                       plt = htab->elf.splt;
14596                       if (!htab->elf.dynamic_sections_created
14597                           || h == NULL
14598                           || h->elf.dynindx == -1)
14599                         plt = htab->elf.iplt;
14600                       relocation = (plt->output_section->vma
14601                                     + plt->output_offset
14602                                     + ent->plt.offset);
14603                       addend = 0;
14604                       unresolved_reloc = FALSE;
14605                       break;
14606                     }
14607               }
14608           }
14609           break;
14610
14611         case R_PPC64_TOC:
14612           /* Relocation value is TOC base.  */
14613           relocation = TOCstart;
14614           if (r_symndx == STN_UNDEF)
14615             relocation += htab->sec_info[input_section->id].toc_off;
14616           else if (unresolved_reloc)
14617             ;
14618           else if (sec != NULL && sec->id < htab->sec_info_arr_size)
14619             relocation += htab->sec_info[sec->id].toc_off;
14620           else
14621             unresolved_reloc = TRUE;
14622           goto dodyn;
14623
14624           /* TOC16 relocs.  We want the offset relative to the TOC base,
14625              which is the address of the start of the TOC plus 0x8000.
14626              The TOC consists of sections .got, .toc, .tocbss, and .plt,
14627              in this order.  */
14628         case R_PPC64_TOC16:
14629         case R_PPC64_TOC16_LO:
14630         case R_PPC64_TOC16_HI:
14631         case R_PPC64_TOC16_DS:
14632         case R_PPC64_TOC16_LO_DS:
14633         case R_PPC64_TOC16_HA:
14634           addend -= TOCstart + htab->sec_info[input_section->id].toc_off;
14635           break;
14636
14637           /* Relocate against the beginning of the section.  */
14638         case R_PPC64_SECTOFF:
14639         case R_PPC64_SECTOFF_LO:
14640         case R_PPC64_SECTOFF_HI:
14641         case R_PPC64_SECTOFF_DS:
14642         case R_PPC64_SECTOFF_LO_DS:
14643         case R_PPC64_SECTOFF_HA:
14644           if (sec != NULL)
14645             addend -= sec->output_section->vma;
14646           break;
14647
14648         case R_PPC64_REL16:
14649         case R_PPC64_REL16_LO:
14650         case R_PPC64_REL16_HI:
14651         case R_PPC64_REL16_HA:
14652         case R_PPC64_REL16DX_HA:
14653           break;
14654
14655         case R_PPC64_REL14:
14656         case R_PPC64_REL14_BRNTAKEN:
14657         case R_PPC64_REL14_BRTAKEN:
14658         case R_PPC64_REL24:
14659           break;
14660
14661         case R_PPC64_TPREL16:
14662         case R_PPC64_TPREL16_LO:
14663         case R_PPC64_TPREL16_HI:
14664         case R_PPC64_TPREL16_HA:
14665         case R_PPC64_TPREL16_DS:
14666         case R_PPC64_TPREL16_LO_DS:
14667         case R_PPC64_TPREL16_HIGH:
14668         case R_PPC64_TPREL16_HIGHA:
14669         case R_PPC64_TPREL16_HIGHER:
14670         case R_PPC64_TPREL16_HIGHERA:
14671         case R_PPC64_TPREL16_HIGHEST:
14672         case R_PPC64_TPREL16_HIGHESTA:
14673           if (h != NULL
14674               && h->elf.root.type == bfd_link_hash_undefweak
14675               && h->elf.dynindx == -1)
14676             {
14677               /* Make this relocation against an undefined weak symbol
14678                  resolve to zero.  This is really just a tweak, since
14679                  code using weak externs ought to check that they are
14680                  defined before using them.  */
14681               bfd_byte *p = contents + rel->r_offset - d_offset;
14682
14683               insn = bfd_get_32 (output_bfd, p);
14684               insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14685               if (insn != 0)
14686                 bfd_put_32 (output_bfd, insn, p);
14687               break;
14688             }
14689           if (htab->elf.tls_sec != NULL)
14690             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14691           if (bfd_link_pic (info))
14692             /* The TPREL16 relocs shouldn't really be used in shared
14693                libs as they will result in DT_TEXTREL being set, but
14694                support them anyway.  */
14695             goto dodyn;
14696           break;
14697
14698         case R_PPC64_DTPREL16:
14699         case R_PPC64_DTPREL16_LO:
14700         case R_PPC64_DTPREL16_HI:
14701         case R_PPC64_DTPREL16_HA:
14702         case R_PPC64_DTPREL16_DS:
14703         case R_PPC64_DTPREL16_LO_DS:
14704         case R_PPC64_DTPREL16_HIGH:
14705         case R_PPC64_DTPREL16_HIGHA:
14706         case R_PPC64_DTPREL16_HIGHER:
14707         case R_PPC64_DTPREL16_HIGHERA:
14708         case R_PPC64_DTPREL16_HIGHEST:
14709         case R_PPC64_DTPREL16_HIGHESTA:
14710           if (htab->elf.tls_sec != NULL)
14711             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14712           break;
14713
14714         case R_PPC64_ADDR64_LOCAL:
14715           addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
14716                                               ? h->elf.other
14717                                               : sym->st_other);
14718           break;
14719
14720         case R_PPC64_DTPMOD64:
14721           relocation = 1;
14722           addend = 0;
14723           goto dodyn;
14724
14725         case R_PPC64_TPREL64:
14726           if (htab->elf.tls_sec != NULL)
14727             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14728           goto dodyn;
14729
14730         case R_PPC64_DTPREL64:
14731           if (htab->elf.tls_sec != NULL)
14732             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14733           /* Fall thru */
14734
14735           /* Relocations that may need to be propagated if this is a
14736              dynamic object.  */
14737         case R_PPC64_REL30:
14738         case R_PPC64_REL32:
14739         case R_PPC64_REL64:
14740         case R_PPC64_ADDR14:
14741         case R_PPC64_ADDR14_BRNTAKEN:
14742         case R_PPC64_ADDR14_BRTAKEN:
14743         case R_PPC64_ADDR16:
14744         case R_PPC64_ADDR16_DS:
14745         case R_PPC64_ADDR16_HA:
14746         case R_PPC64_ADDR16_HI:
14747         case R_PPC64_ADDR16_HIGH:
14748         case R_PPC64_ADDR16_HIGHA:
14749         case R_PPC64_ADDR16_HIGHER:
14750         case R_PPC64_ADDR16_HIGHERA:
14751         case R_PPC64_ADDR16_HIGHEST:
14752         case R_PPC64_ADDR16_HIGHESTA:
14753         case R_PPC64_ADDR16_LO:
14754         case R_PPC64_ADDR16_LO_DS:
14755         case R_PPC64_ADDR24:
14756         case R_PPC64_ADDR32:
14757         case R_PPC64_ADDR64:
14758         case R_PPC64_UADDR16:
14759         case R_PPC64_UADDR32:
14760         case R_PPC64_UADDR64:
14761         dodyn:
14762           if ((input_section->flags & SEC_ALLOC) == 0)
14763             break;
14764
14765           if (NO_OPD_RELOCS && is_opd)
14766             break;
14767
14768           if (bfd_link_pic (info)
14769               ? ((h != NULL && pc_dynrelocs (h))
14770                  || must_be_dyn_reloc (info, r_type))
14771               : (h != NULL
14772                  ? h->dyn_relocs != NULL
14773                  : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14774             {
14775               bfd_boolean skip, relocate;
14776               asection *sreloc;
14777               bfd_vma out_off;
14778
14779               /* When generating a dynamic object, these relocations
14780                  are copied into the output file to be resolved at run
14781                  time.  */
14782
14783               skip = FALSE;
14784               relocate = FALSE;
14785
14786               out_off = _bfd_elf_section_offset (output_bfd, info,
14787                                                  input_section, rel->r_offset);
14788               if (out_off == (bfd_vma) -1)
14789                 skip = TRUE;
14790               else if (out_off == (bfd_vma) -2)
14791                 skip = TRUE, relocate = TRUE;
14792               out_off += (input_section->output_section->vma
14793                           + input_section->output_offset);
14794               outrel.r_offset = out_off;
14795               outrel.r_addend = rel->r_addend;
14796
14797               /* Optimize unaligned reloc use.  */
14798               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14799                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14800                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14801               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14802                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
14803                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
14804               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
14805                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
14806                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
14807
14808               if (skip)
14809                 memset (&outrel, 0, sizeof outrel);
14810               else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14811                        && !is_opd
14812                        && r_type != R_PPC64_TOC)
14813                 {
14814                   BFD_ASSERT (h->elf.dynindx != -1);
14815                   outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
14816                 }
14817               else
14818                 {
14819                   /* This symbol is local, or marked to become local,
14820                      or this is an opd section reloc which must point
14821                      at a local function.  */
14822                   outrel.r_addend += relocation;
14823                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
14824                     {
14825                       if (is_opd && h != NULL)
14826                         {
14827                           /* Lie about opd entries.  This case occurs
14828                              when building shared libraries and we
14829                              reference a function in another shared
14830                              lib.  The same thing happens for a weak
14831                              definition in an application that's
14832                              overridden by a strong definition in a
14833                              shared lib.  (I believe this is a generic
14834                              bug in binutils handling of weak syms.)
14835                              In these cases we won't use the opd
14836                              entry in this lib.  */
14837                           unresolved_reloc = FALSE;
14838                         }
14839                       if (!is_opd
14840                           && r_type == R_PPC64_ADDR64
14841                           && (h != NULL
14842                               ? h->elf.type == STT_GNU_IFUNC
14843                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14844                         outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14845                       else
14846                         {
14847                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14848
14849                           /* We need to relocate .opd contents for ld.so.
14850                              Prelink also wants simple and consistent rules
14851                              for relocs.  This make all RELATIVE relocs have
14852                              *r_offset equal to r_addend.  */
14853                           relocate = TRUE;
14854                         }
14855                     }
14856                   else
14857                     {
14858                       long indx = 0;
14859
14860                       if (h != NULL
14861                           ? h->elf.type == STT_GNU_IFUNC
14862                           : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14863                         {
14864                           info->callbacks->einfo
14865                             (_("%P: %H: %s for indirect "
14866                                "function `%T' unsupported\n"),
14867                              input_bfd, input_section, rel->r_offset,
14868                              ppc64_elf_howto_table[r_type]->name,
14869                              sym_name);
14870                           ret = FALSE;
14871                         }
14872                       else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
14873                         ;
14874                       else if (sec == NULL || sec->owner == NULL)
14875                         {
14876                           bfd_set_error (bfd_error_bad_value);
14877                           return FALSE;
14878                         }
14879                       else
14880                         {
14881                           asection *osec;
14882
14883                           osec = sec->output_section;
14884                           indx = elf_section_data (osec)->dynindx;
14885
14886                           if (indx == 0)
14887                             {
14888                               if ((osec->flags & SEC_READONLY) == 0
14889                                   && htab->elf.data_index_section != NULL)
14890                                 osec = htab->elf.data_index_section;
14891                               else
14892                                 osec = htab->elf.text_index_section;
14893                               indx = elf_section_data (osec)->dynindx;
14894                             }
14895                           BFD_ASSERT (indx != 0);
14896
14897                           /* We are turning this relocation into one
14898                              against a section symbol, so subtract out
14899                              the output section's address but not the
14900                              offset of the input section in the output
14901                              section.  */
14902                           outrel.r_addend -= osec->vma;
14903                         }
14904
14905                       outrel.r_info = ELF64_R_INFO (indx, r_type);
14906                     }
14907                 }
14908
14909               sreloc = elf_section_data (input_section)->sreloc;
14910               if (h != NULL
14911                   ? h->elf.type == STT_GNU_IFUNC
14912                   : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14913                 sreloc = htab->elf.irelplt;
14914               if (sreloc == NULL)
14915                 abort ();
14916
14917               if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
14918                   >= sreloc->size)
14919                 abort ();
14920               loc = sreloc->contents;
14921               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
14922               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14923
14924               /* If this reloc is against an external symbol, it will
14925                  be computed at runtime, so there's no need to do
14926                  anything now.  However, for the sake of prelink ensure
14927                  that the section contents are a known value.  */
14928               if (! relocate)
14929                 {
14930                   unresolved_reloc = FALSE;
14931                   /* The value chosen here is quite arbitrary as ld.so
14932                      ignores section contents except for the special
14933                      case of .opd where the contents might be accessed
14934                      before relocation.  Choose zero, as that won't
14935                      cause reloc overflow.  */
14936                   relocation = 0;
14937                   addend = 0;
14938                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
14939                      to improve backward compatibility with older
14940                      versions of ld.  */
14941                   if (r_type == R_PPC64_ADDR64)
14942                     addend = outrel.r_addend;
14943                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
14944                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
14945                     addend = (input_section->output_section->vma
14946                               + input_section->output_offset
14947                               + rel->r_offset);
14948                 }
14949             }
14950           break;
14951
14952         case R_PPC64_COPY:
14953         case R_PPC64_GLOB_DAT:
14954         case R_PPC64_JMP_SLOT:
14955         case R_PPC64_JMP_IREL:
14956         case R_PPC64_RELATIVE:
14957           /* We shouldn't ever see these dynamic relocs in relocatable
14958              files.  */
14959           /* Fall through.  */
14960
14961         case R_PPC64_PLTGOT16:
14962         case R_PPC64_PLTGOT16_DS:
14963         case R_PPC64_PLTGOT16_HA:
14964         case R_PPC64_PLTGOT16_HI:
14965         case R_PPC64_PLTGOT16_LO:
14966         case R_PPC64_PLTGOT16_LO_DS:
14967         case R_PPC64_PLTREL32:
14968         case R_PPC64_PLTREL64:
14969           /* These ones haven't been implemented yet.  */
14970
14971           info->callbacks->einfo
14972             (_("%P: %B: %s is not supported for `%T'\n"),
14973              input_bfd,
14974              ppc64_elf_howto_table[r_type]->name, sym_name);
14975
14976           bfd_set_error (bfd_error_invalid_operation);
14977           ret = FALSE;
14978           goto copy_reloc;
14979         }
14980
14981       /* Multi-instruction sequences that access the TOC can be
14982          optimized, eg. addis ra,r2,0; addi rb,ra,x;
14983          to             nop;           addi rb,r2,x;  */
14984       switch (r_type)
14985         {
14986         default:
14987           break;
14988
14989         case R_PPC64_GOT_TLSLD16_HI:
14990         case R_PPC64_GOT_TLSGD16_HI:
14991         case R_PPC64_GOT_TPREL16_HI:
14992         case R_PPC64_GOT_DTPREL16_HI:
14993         case R_PPC64_GOT16_HI:
14994         case R_PPC64_TOC16_HI:
14995           /* These relocs would only be useful if building up an
14996              offset to later add to r2, perhaps in an indexed
14997              addressing mode instruction.  Don't try to optimize.
14998              Unfortunately, the possibility of someone building up an
14999              offset like this or even with the HA relocs, means that
15000              we need to check the high insn when optimizing the low
15001              insn.  */
15002           break;
15003
15004         case R_PPC64_GOT_TLSLD16_HA:
15005         case R_PPC64_GOT_TLSGD16_HA:
15006         case R_PPC64_GOT_TPREL16_HA:
15007         case R_PPC64_GOT_DTPREL16_HA:
15008         case R_PPC64_GOT16_HA:
15009         case R_PPC64_TOC16_HA:
15010           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
15011               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
15012             {
15013               bfd_byte *p = contents + (rel->r_offset & ~3);
15014               bfd_put_32 (input_bfd, NOP, p);
15015             }
15016           break;
15017
15018         case R_PPC64_GOT_TLSLD16_LO:
15019         case R_PPC64_GOT_TLSGD16_LO:
15020         case R_PPC64_GOT_TPREL16_LO_DS:
15021         case R_PPC64_GOT_DTPREL16_LO_DS:
15022         case R_PPC64_GOT16_LO:
15023         case R_PPC64_GOT16_LO_DS:
15024         case R_PPC64_TOC16_LO:
15025         case R_PPC64_TOC16_LO_DS:
15026           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
15027               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
15028             {
15029               bfd_byte *p = contents + (rel->r_offset & ~3);
15030               insn = bfd_get_32 (input_bfd, p);
15031               if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
15032                 {
15033                   /* Transform addic to addi when we change reg.  */
15034                   insn &= ~((0x3f << 26) | (0x1f << 16));
15035                   insn |= (14u << 26) | (2 << 16);
15036                 }
15037               else
15038                 {
15039                   insn &= ~(0x1f << 16);
15040                   insn |= 2 << 16;
15041                 }
15042               bfd_put_32 (input_bfd, insn, p);
15043             }
15044           break;
15045         }
15046
15047       /* Do any further special processing.  */
15048       howto = ppc64_elf_howto_table[(int) r_type];
15049       switch (r_type)
15050         {
15051         default:
15052           break;
15053
15054         case R_PPC64_REL16_HA:
15055         case R_PPC64_REL16DX_HA:
15056         case R_PPC64_ADDR16_HA:
15057         case R_PPC64_ADDR16_HIGHA:
15058         case R_PPC64_ADDR16_HIGHERA:
15059         case R_PPC64_ADDR16_HIGHESTA:
15060         case R_PPC64_TOC16_HA:
15061         case R_PPC64_SECTOFF_HA:
15062         case R_PPC64_TPREL16_HA:
15063         case R_PPC64_TPREL16_HIGHA:
15064         case R_PPC64_TPREL16_HIGHERA:
15065         case R_PPC64_TPREL16_HIGHESTA:
15066         case R_PPC64_DTPREL16_HA:
15067         case R_PPC64_DTPREL16_HIGHA:
15068         case R_PPC64_DTPREL16_HIGHERA:
15069         case R_PPC64_DTPREL16_HIGHESTA:
15070           /* It's just possible that this symbol is a weak symbol
15071              that's not actually defined anywhere. In that case,
15072              'sec' would be NULL, and we should leave the symbol
15073              alone (it will be set to zero elsewhere in the link).  */
15074           if (sec == NULL)
15075             break;
15076           /* Fall thru */
15077
15078         case R_PPC64_GOT16_HA:
15079         case R_PPC64_PLTGOT16_HA:
15080         case R_PPC64_PLT16_HA:
15081         case R_PPC64_GOT_TLSGD16_HA:
15082         case R_PPC64_GOT_TLSLD16_HA:
15083         case R_PPC64_GOT_TPREL16_HA:
15084         case R_PPC64_GOT_DTPREL16_HA:
15085           /* Add 0x10000 if sign bit in 0:15 is set.
15086              Bits 0:15 are not used.  */
15087           addend += 0x8000;
15088           break;
15089
15090         case R_PPC64_ADDR16_DS:
15091         case R_PPC64_ADDR16_LO_DS:
15092         case R_PPC64_GOT16_DS:
15093         case R_PPC64_GOT16_LO_DS:
15094         case R_PPC64_PLT16_LO_DS:
15095         case R_PPC64_SECTOFF_DS:
15096         case R_PPC64_SECTOFF_LO_DS:
15097         case R_PPC64_TOC16_DS:
15098         case R_PPC64_TOC16_LO_DS:
15099         case R_PPC64_PLTGOT16_DS:
15100         case R_PPC64_PLTGOT16_LO_DS:
15101         case R_PPC64_GOT_TPREL16_DS:
15102         case R_PPC64_GOT_TPREL16_LO_DS:
15103         case R_PPC64_GOT_DTPREL16_DS:
15104         case R_PPC64_GOT_DTPREL16_LO_DS:
15105         case R_PPC64_TPREL16_DS:
15106         case R_PPC64_TPREL16_LO_DS:
15107         case R_PPC64_DTPREL16_DS:
15108         case R_PPC64_DTPREL16_LO_DS:
15109           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15110           mask = 3;
15111           /* If this reloc is against an lq, lxv, or stxv insn, then
15112              the value must be a multiple of 16.  This is somewhat of
15113              a hack, but the "correct" way to do this by defining _DQ
15114              forms of all the _DS relocs bloats all reloc switches in
15115              this file.  It doesn't make much sense to use these
15116              relocs in data, so testing the insn should be safe.  */
15117           if ((insn & (0x3f << 26)) == (56u << 26)
15118               || ((insn & (0x3f << 26)) == (61u << 26) && (insn & 3) == 1))
15119             mask = 15;
15120           relocation += addend;
15121           addend = insn & (mask ^ 3);
15122           if ((relocation & mask) != 0)
15123             {
15124               relocation ^= relocation & mask;
15125               info->callbacks->einfo
15126                 (_("%P: %H: error: %s not a multiple of %u\n"),
15127                  input_bfd, input_section, rel->r_offset,
15128                  howto->name,
15129                  mask + 1);
15130               bfd_set_error (bfd_error_bad_value);
15131               ret = FALSE;
15132               goto copy_reloc;
15133             }
15134           break;
15135         }
15136
15137       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
15138          because such sections are not SEC_ALLOC and thus ld.so will
15139          not process them.  */
15140       if (unresolved_reloc
15141           && !((input_section->flags & SEC_DEBUGGING) != 0
15142                && h->elf.def_dynamic)
15143           && _bfd_elf_section_offset (output_bfd, info, input_section,
15144                                       rel->r_offset) != (bfd_vma) -1)
15145         {
15146           info->callbacks->einfo
15147             (_("%P: %H: unresolvable %s against `%T'\n"),
15148              input_bfd, input_section, rel->r_offset,
15149              howto->name,
15150              h->elf.root.root.string);
15151           ret = FALSE;
15152         }
15153
15154       /* 16-bit fields in insns mostly have signed values, but a
15155          few insns have 16-bit unsigned values.  Really, we should
15156          have different reloc types.  */
15157       if (howto->complain_on_overflow != complain_overflow_dont
15158           && howto->dst_mask == 0xffff
15159           && (input_section->flags & SEC_CODE) != 0)
15160         {
15161           enum complain_overflow complain = complain_overflow_signed;
15162
15163           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15164           if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
15165             complain = complain_overflow_bitfield;
15166           else if (howto->rightshift == 0
15167                    ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
15168                       || (insn & (0x3f << 26)) == 24u << 26 /* ori */
15169                       || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
15170                    : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
15171                       || (insn & (0x3f << 26)) == 25u << 26 /* oris */
15172                       || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
15173             complain = complain_overflow_unsigned;
15174           if (howto->complain_on_overflow != complain)
15175             {
15176               alt_howto = *howto;
15177               alt_howto.complain_on_overflow = complain;
15178               howto = &alt_howto;
15179             }
15180         }
15181
15182       if (r_type == R_PPC64_REL16DX_HA)
15183         {
15184           /* Split field reloc isn't handled by _bfd_final_link_relocate.  */
15185           if (rel->r_offset + 4 > input_section->size)
15186             r = bfd_reloc_outofrange;
15187           else
15188             {
15189               relocation += addend;
15190               relocation -= (rel->r_offset
15191                              + input_section->output_offset
15192                              + input_section->output_section->vma);
15193               relocation = (bfd_signed_vma) relocation >> 16;
15194               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
15195               insn &= ~0x1fffc1;
15196               insn |= (relocation & 0xffc1) | ((relocation & 0x3e) << 15);
15197               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
15198               r = bfd_reloc_ok;
15199               if (relocation + 0x8000 > 0xffff)
15200                 r = bfd_reloc_overflow;
15201             }
15202         }
15203       else
15204         r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
15205                                       rel->r_offset, relocation, addend);
15206
15207       if (r != bfd_reloc_ok)
15208         {
15209           char *more_info = NULL;
15210           const char *reloc_name = howto->name;
15211
15212           if (reloc_dest != DEST_NORMAL)
15213             {
15214               more_info = bfd_malloc (strlen (reloc_name) + 8);
15215               if (more_info != NULL)
15216                 {
15217                   strcpy (more_info, reloc_name);
15218                   strcat (more_info, (reloc_dest == DEST_OPD
15219                                       ? " (OPD)" : " (stub)"));
15220                   reloc_name = more_info;
15221                 }
15222             }
15223
15224           if (r == bfd_reloc_overflow)
15225             {
15226               /* On code like "if (foo) foo();" don't report overflow
15227                  on a branch to zero when foo is undefined.  */
15228               if (!warned
15229                   && (reloc_dest == DEST_STUB
15230                       || !(h != NULL
15231                            && (h->elf.root.type == bfd_link_hash_undefweak
15232                                || h->elf.root.type == bfd_link_hash_undefined)
15233                            && is_branch_reloc (r_type))))
15234                 info->callbacks->reloc_overflow (info, &h->elf.root,
15235                                                  sym_name, reloc_name,
15236                                                  orig_rel.r_addend,
15237                                                  input_bfd, input_section,
15238                                                  rel->r_offset);
15239             }
15240           else
15241             {
15242               info->callbacks->einfo
15243                 (_("%P: %H: %s against `%T': error %d\n"),
15244                  input_bfd, input_section, rel->r_offset,
15245                  reloc_name, sym_name, (int) r);
15246               ret = FALSE;
15247             }
15248           if (more_info != NULL)
15249             free (more_info);
15250         }
15251     copy_reloc:
15252       if (wrel != rel)
15253         *wrel = *rel;
15254     }
15255
15256   if (wrel != rel)
15257     {
15258       Elf_Internal_Shdr *rel_hdr;
15259       size_t deleted = rel - wrel;
15260
15261       rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
15262       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15263       if (rel_hdr->sh_size == 0)
15264         {
15265           /* It is too late to remove an empty reloc section.  Leave
15266              one NONE reloc.
15267              ??? What is wrong with an empty section???  */
15268           rel_hdr->sh_size = rel_hdr->sh_entsize;
15269           deleted -= 1;
15270         }
15271       rel_hdr = _bfd_elf_single_rel_hdr (input_section);
15272       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15273       input_section->reloc_count -= deleted;
15274     }
15275
15276   /* If we're emitting relocations, then shortly after this function
15277      returns, reloc offsets and addends for this section will be
15278      adjusted.  Worse, reloc symbol indices will be for the output
15279      file rather than the input.  Save a copy of the relocs for
15280      opd_entry_value.  */
15281   if (is_opd && (info->emitrelocations || bfd_link_relocatable (info)))
15282     {
15283       bfd_size_type amt;
15284       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
15285       rel = bfd_alloc (input_bfd, amt);
15286       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
15287       ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
15288       if (rel == NULL)
15289         return FALSE;
15290       memcpy (rel, relocs, amt);
15291     }
15292   return ret;
15293 }
15294
15295 /* Adjust the value of any local symbols in opd sections.  */
15296
15297 static int
15298 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
15299                               const char *name ATTRIBUTE_UNUSED,
15300                               Elf_Internal_Sym *elfsym,
15301                               asection *input_sec,
15302                               struct elf_link_hash_entry *h)
15303 {
15304   struct _opd_sec_data *opd;
15305   long adjust;
15306   bfd_vma value;
15307
15308   if (h != NULL)
15309     return 1;
15310
15311   opd = get_opd_info (input_sec);
15312   if (opd == NULL || opd->adjust == NULL)
15313     return 1;
15314
15315   value = elfsym->st_value - input_sec->output_offset;
15316   if (!bfd_link_relocatable (info))
15317     value -= input_sec->output_section->vma;
15318
15319   adjust = opd->adjust[OPD_NDX (value)];
15320   if (adjust == -1)
15321     return 2;
15322
15323   elfsym->st_value += adjust;
15324   return 1;
15325 }
15326
15327 /* Finish up dynamic symbol handling.  We set the contents of various
15328    dynamic sections here.  */
15329
15330 static bfd_boolean
15331 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
15332                                  struct bfd_link_info *info,
15333                                  struct elf_link_hash_entry *h,
15334                                  Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
15335 {
15336   struct ppc_link_hash_table *htab;
15337   struct plt_entry *ent;
15338   Elf_Internal_Rela rela;
15339   bfd_byte *loc;
15340
15341   htab = ppc_hash_table (info);
15342   if (htab == NULL)
15343     return FALSE;
15344
15345   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
15346     if (ent->plt.offset != (bfd_vma) -1)
15347       {
15348         /* This symbol has an entry in the procedure linkage
15349            table.  Set it up.  */
15350         if (!htab->elf.dynamic_sections_created
15351             || h->dynindx == -1)
15352           {
15353             BFD_ASSERT (h->type == STT_GNU_IFUNC
15354                         && h->def_regular
15355                         && (h->root.type == bfd_link_hash_defined
15356                             || h->root.type == bfd_link_hash_defweak));
15357             rela.r_offset = (htab->elf.iplt->output_section->vma
15358                              + htab->elf.iplt->output_offset
15359                              + ent->plt.offset);
15360             if (htab->opd_abi)
15361               rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
15362             else
15363               rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15364             rela.r_addend = (h->root.u.def.value
15365                              + h->root.u.def.section->output_offset
15366                              + h->root.u.def.section->output_section->vma
15367                              + ent->addend);
15368             loc = (htab->elf.irelplt->contents
15369                    + (htab->elf.irelplt->reloc_count++
15370                       * sizeof (Elf64_External_Rela)));
15371           }
15372         else
15373           {
15374             rela.r_offset = (htab->elf.splt->output_section->vma
15375                              + htab->elf.splt->output_offset
15376                              + ent->plt.offset);
15377             rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
15378             rela.r_addend = ent->addend;
15379             loc = (htab->elf.srelplt->contents
15380                    + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
15381                       / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
15382           }
15383         bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15384
15385         if (!htab->opd_abi)
15386           {
15387             if (!h->def_regular)
15388               {
15389                 /* Mark the symbol as undefined, rather than as
15390                    defined in glink.  Leave the value if there were
15391                    any relocations where pointer equality matters
15392                    (this is a clue for the dynamic linker, to make
15393                    function pointer comparisons work between an
15394                    application and shared library), otherwise set it
15395                    to zero.  */
15396                 sym->st_shndx = SHN_UNDEF;
15397                 if (!h->pointer_equality_needed)
15398                   sym->st_value = 0;
15399                 else if (!h->ref_regular_nonweak)
15400                   {
15401                     /* This breaks function pointer comparisons, but
15402                        that is better than breaking tests for a NULL
15403                        function pointer.  */
15404                     sym->st_value = 0;
15405                   }
15406               }
15407           }
15408       }
15409
15410   if (h->needs_copy)
15411     {
15412       /* This symbol needs a copy reloc.  Set it up.  */
15413
15414       if (h->dynindx == -1
15415           || (h->root.type != bfd_link_hash_defined
15416               && h->root.type != bfd_link_hash_defweak)
15417           || htab->relbss == NULL)
15418         abort ();
15419
15420       rela.r_offset = (h->root.u.def.value
15421                        + h->root.u.def.section->output_section->vma
15422                        + h->root.u.def.section->output_offset);
15423       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
15424       rela.r_addend = 0;
15425       loc = htab->relbss->contents;
15426       loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
15427       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15428     }
15429
15430   return TRUE;
15431 }
15432
15433 /* Used to decide how to sort relocs in an optimal manner for the
15434    dynamic linker, before writing them out.  */
15435
15436 static enum elf_reloc_type_class
15437 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
15438                             const asection *rel_sec,
15439                             const Elf_Internal_Rela *rela)
15440 {
15441   enum elf_ppc64_reloc_type r_type;
15442   struct ppc_link_hash_table *htab = ppc_hash_table (info);
15443
15444   if (rel_sec == htab->elf.irelplt)
15445     return reloc_class_ifunc;
15446
15447   r_type = ELF64_R_TYPE (rela->r_info);
15448   switch (r_type)
15449     {
15450     case R_PPC64_RELATIVE:
15451       return reloc_class_relative;
15452     case R_PPC64_JMP_SLOT:
15453       return reloc_class_plt;
15454     case R_PPC64_COPY:
15455       return reloc_class_copy;
15456     default:
15457       return reloc_class_normal;
15458     }
15459 }
15460
15461 /* Finish up the dynamic sections.  */
15462
15463 static bfd_boolean
15464 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
15465                                    struct bfd_link_info *info)
15466 {
15467   struct ppc_link_hash_table *htab;
15468   bfd *dynobj;
15469   asection *sdyn;
15470
15471   htab = ppc_hash_table (info);
15472   if (htab == NULL)
15473     return FALSE;
15474
15475   dynobj = htab->elf.dynobj;
15476   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
15477
15478   if (htab->elf.dynamic_sections_created)
15479     {
15480       Elf64_External_Dyn *dyncon, *dynconend;
15481
15482       if (sdyn == NULL || htab->elf.sgot == NULL)
15483         abort ();
15484
15485       dyncon = (Elf64_External_Dyn *) sdyn->contents;
15486       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
15487       for (; dyncon < dynconend; dyncon++)
15488         {
15489           Elf_Internal_Dyn dyn;
15490           asection *s;
15491
15492           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
15493
15494           switch (dyn.d_tag)
15495             {
15496             default:
15497               continue;
15498
15499             case DT_PPC64_GLINK:
15500               s = htab->glink;
15501               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15502               /* We stupidly defined DT_PPC64_GLINK to be the start
15503                  of glink rather than the first entry point, which is
15504                  what ld.so needs, and now have a bigger stub to
15505                  support automatic multiple TOCs.  */
15506               dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
15507               break;
15508
15509             case DT_PPC64_OPD:
15510               s = bfd_get_section_by_name (output_bfd, ".opd");
15511               if (s == NULL)
15512                 continue;
15513               dyn.d_un.d_ptr = s->vma;
15514               break;
15515
15516             case DT_PPC64_OPT:
15517               if (htab->do_multi_toc && htab->multi_toc_needed)
15518                 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
15519               break;
15520
15521             case DT_PPC64_OPDSZ:
15522               s = bfd_get_section_by_name (output_bfd, ".opd");
15523               if (s == NULL)
15524                 continue;
15525               dyn.d_un.d_val = s->size;
15526               break;
15527
15528             case DT_PLTGOT:
15529               s = htab->elf.splt;
15530               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15531               break;
15532
15533             case DT_JMPREL:
15534               s = htab->elf.srelplt;
15535               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15536               break;
15537
15538             case DT_PLTRELSZ:
15539               dyn.d_un.d_val = htab->elf.srelplt->size;
15540               break;
15541
15542             case DT_RELASZ:
15543               /* Don't count procedure linkage table relocs in the
15544                  overall reloc count.  */
15545               s = htab->elf.srelplt;
15546               if (s == NULL)
15547                 continue;
15548               dyn.d_un.d_val -= s->size;
15549               break;
15550
15551             case DT_RELA:
15552               /* We may not be using the standard ELF linker script.
15553                  If .rela.plt is the first .rela section, we adjust
15554                  DT_RELA to not include it.  */
15555               s = htab->elf.srelplt;
15556               if (s == NULL)
15557                 continue;
15558               if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
15559                 continue;
15560               dyn.d_un.d_ptr += s->size;
15561               break;
15562             }
15563
15564           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
15565         }
15566     }
15567
15568   if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0)
15569     {
15570       /* Fill in the first entry in the global offset table.
15571          We use it to hold the link-time TOCbase.  */
15572       bfd_put_64 (output_bfd,
15573                   elf_gp (output_bfd) + TOC_BASE_OFF,
15574                   htab->elf.sgot->contents);
15575
15576       /* Set .got entry size.  */
15577       elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
15578     }
15579
15580   if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
15581     {
15582       /* Set .plt entry size.  */
15583       elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
15584         = PLT_ENTRY_SIZE (htab);
15585     }
15586
15587   /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
15588      brlt ourselves if emitrelocations.  */
15589   if (htab->brlt != NULL
15590       && htab->brlt->reloc_count != 0
15591       && !_bfd_elf_link_output_relocs (output_bfd,
15592                                        htab->brlt,
15593                                        elf_section_data (htab->brlt)->rela.hdr,
15594                                        elf_section_data (htab->brlt)->relocs,
15595                                        NULL))
15596     return FALSE;
15597
15598   if (htab->glink != NULL
15599       && htab->glink->reloc_count != 0
15600       && !_bfd_elf_link_output_relocs (output_bfd,
15601                                        htab->glink,
15602                                        elf_section_data (htab->glink)->rela.hdr,
15603                                        elf_section_data (htab->glink)->relocs,
15604                                        NULL))
15605     return FALSE;
15606
15607   if (htab->glink_eh_frame != NULL
15608       && htab->glink_eh_frame->size != 0)
15609     {
15610       bfd_vma val;
15611       bfd_byte *p;
15612       asection *stub_sec;
15613
15614       p = htab->glink_eh_frame->contents + sizeof (glink_eh_frame_cie);
15615       for (stub_sec = htab->params->stub_bfd->sections;
15616            stub_sec != NULL;
15617            stub_sec = stub_sec->next)
15618         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
15619           {
15620             /* FDE length.  */
15621             p += 4;
15622             /* CIE pointer.  */
15623             p += 4;
15624             /* Offset to stub section.  */
15625             val = (stub_sec->output_section->vma
15626                    + stub_sec->output_offset);
15627             val -= (htab->glink_eh_frame->output_section->vma
15628                     + htab->glink_eh_frame->output_offset
15629                     + (p - htab->glink_eh_frame->contents));
15630             if (val + 0x80000000 > 0xffffffff)
15631               {
15632                 info->callbacks->einfo
15633                   (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15634                    stub_sec->name);
15635                 return FALSE;
15636               }
15637             bfd_put_32 (dynobj, val, p);
15638             p += 4;
15639             /* stub section size.  */
15640             p += 4;
15641             /* Augmentation.  */
15642             p += 1;
15643             /* Pad.  */
15644             p += 7;
15645           }
15646       if (htab->glink != NULL && htab->glink->size != 0)
15647         {
15648           /* FDE length.  */
15649           p += 4;
15650           /* CIE pointer.  */
15651           p += 4;
15652           /* Offset to .glink.  */
15653           val = (htab->glink->output_section->vma
15654                  + htab->glink->output_offset
15655                  + 8);
15656           val -= (htab->glink_eh_frame->output_section->vma
15657                   + htab->glink_eh_frame->output_offset
15658                   + (p - htab->glink_eh_frame->contents));
15659           if (val + 0x80000000 > 0xffffffff)
15660             {
15661               info->callbacks->einfo
15662                 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15663                  htab->glink->name);
15664               return FALSE;
15665             }
15666           bfd_put_32 (dynobj, val, p);
15667           p += 4;
15668           /* .glink size.  */
15669           p += 4;
15670           /* Augmentation.  */
15671           p += 1;
15672           /* Ops.  */
15673           p += 7;
15674         }
15675
15676       if (htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
15677           && !_bfd_elf_write_section_eh_frame (output_bfd, info,
15678                                                htab->glink_eh_frame,
15679                                                htab->glink_eh_frame->contents))
15680         return FALSE;
15681     }
15682
15683   /* We need to handle writing out multiple GOT sections ourselves,
15684      since we didn't add them to DYNOBJ.  We know dynobj is the first
15685      bfd.  */
15686   while ((dynobj = dynobj->link.next) != NULL)
15687     {
15688       asection *s;
15689
15690       if (!is_ppc64_elf (dynobj))
15691         continue;
15692
15693       s = ppc64_elf_tdata (dynobj)->got;
15694       if (s != NULL
15695           && s->size != 0
15696           && s->output_section != bfd_abs_section_ptr
15697           && !bfd_set_section_contents (output_bfd, s->output_section,
15698                                         s->contents, s->output_offset,
15699                                         s->size))
15700         return FALSE;
15701       s = ppc64_elf_tdata (dynobj)->relgot;
15702       if (s != NULL
15703           && s->size != 0
15704           && s->output_section != bfd_abs_section_ptr
15705           && !bfd_set_section_contents (output_bfd, s->output_section,
15706                                         s->contents, s->output_offset,
15707                                         s->size))
15708         return FALSE;
15709     }
15710
15711   return TRUE;
15712 }
15713
15714 #include "elf64-target.h"
15715
15716 /* FreeBSD support */
15717
15718 #undef  TARGET_LITTLE_SYM
15719 #undef  TARGET_LITTLE_NAME
15720
15721 #undef  TARGET_BIG_SYM
15722 #define TARGET_BIG_SYM  powerpc_elf64_fbsd_vec
15723 #undef  TARGET_BIG_NAME
15724 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15725
15726 #undef  ELF_OSABI
15727 #define ELF_OSABI       ELFOSABI_FREEBSD
15728
15729 #undef  elf64_bed
15730 #define elf64_bed       elf64_powerpc_fbsd_bed
15731
15732 #include "elf64-target.h"
15733