bfd/elf64-ppc.c

   1 /* PowerPC64-specific support for 64-bit ELF.
   2    Copyright (C) 1999-2016 Free Software Foundation, Inc.
   3    Written by Linus Nordberg, Swox AB <info@swox.com>,
   4    based on elf32-ppc.c by Ian Lance Taylor.
   5    Largely rewritten by Alan Modra.
   6
   7    This file is part of BFD, the Binary File Descriptor library.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License along
  20    with this program; if not, write to the Free Software Foundation, Inc.,
  21    51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
  22
  23
  24 /* The 64-bit PowerPC ELF ABI may be found at
  25    http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and
  26    http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html  */
  27
  28 #include "sysdep.h"
  29 #include <stdarg.h>
  30 #include "bfd.h"
  31 #include "bfdlink.h"
  32 #include "libbfd.h"
  33 #include "elf-bfd.h"
  34 #include "elf/ppc64.h"
  35 #include "elf64-ppc.h"
  36 #include "dwarf2.h"
  37
  38 static bfd_reloc_status_type ppc64_elf_ha_reloc
  39   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  40 static bfd_reloc_status_type ppc64_elf_branch_reloc
  41   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  42 static bfd_reloc_status_type ppc64_elf_brtaken_reloc
  43   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  44 static bfd_reloc_status_type ppc64_elf_sectoff_reloc
  45   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  46 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
  47   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  48 static bfd_reloc_status_type ppc64_elf_toc_reloc
  49   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  50 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
  51   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  52 static bfd_reloc_status_type ppc64_elf_toc64_reloc
  53   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  54 static bfd_reloc_status_type ppc64_elf_unhandled_reloc
  55   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  56 static bfd_vma opd_entry_value
  57   (asection *, bfd_vma, asection **, bfd_vma *, bfd_boolean);
  58
  59 #define TARGET_LITTLE_SYM       powerpc_elf64_le_vec
  60 #define TARGET_LITTLE_NAME      "elf64-powerpcle"
  61 #define TARGET_BIG_SYM          powerpc_elf64_vec
  62 #define TARGET_BIG_NAME         "elf64-powerpc"
  63 #define ELF_ARCH                bfd_arch_powerpc
  64 #define ELF_TARGET_ID           PPC64_ELF_DATA
  65 #define ELF_MACHINE_CODE        EM_PPC64
  66 #define ELF_MAXPAGESIZE         0x10000
  67 #define ELF_COMMONPAGESIZE      0x10000
  68 #define elf_info_to_howto       ppc64_elf_info_to_howto
  69
  70 #define elf_backend_want_got_sym 0
  71 #define elf_backend_want_plt_sym 0
  72 #define elf_backend_plt_alignment 3
  73 #define elf_backend_plt_not_loaded 1
  74 #define elf_backend_got_header_size 8
  75 #define elf_backend_can_gc_sections 1
  76 #define elf_backend_can_refcount 1
  77 #define elf_backend_rela_normal 1
  78 #define elf_backend_default_execstack 0
  79
  80 #define bfd_elf64_mkobject                    ppc64_elf_mkobject
  81 #define bfd_elf64_bfd_reloc_type_lookup       ppc64_elf_reloc_type_lookup
  82 #define bfd_elf64_bfd_reloc_name_lookup       ppc64_elf_reloc_name_lookup
  83 #define bfd_elf64_bfd_merge_private_bfd_data  ppc64_elf_merge_private_bfd_data
  84 #define bfd_elf64_bfd_print_private_bfd_data  ppc64_elf_print_private_bfd_data
  85 #define bfd_elf64_new_section_hook            ppc64_elf_new_section_hook
  86 #define bfd_elf64_bfd_link_hash_table_create  ppc64_elf_link_hash_table_create
  87 #define bfd_elf64_get_synthetic_symtab        ppc64_elf_get_synthetic_symtab
  88 #define bfd_elf64_bfd_link_just_syms          ppc64_elf_link_just_syms
  89
  90 #define elf_backend_object_p                  ppc64_elf_object_p
  91 #define elf_backend_grok_prstatus             ppc64_elf_grok_prstatus
  92 #define elf_backend_grok_psinfo               ppc64_elf_grok_psinfo
  93 #define elf_backend_write_core_note           ppc64_elf_write_core_note
  94 #define elf_backend_create_dynamic_sections   ppc64_elf_create_dynamic_sections
  95 #define elf_backend_copy_indirect_symbol      ppc64_elf_copy_indirect_symbol
  96 #define elf_backend_add_symbol_hook           ppc64_elf_add_symbol_hook
  97 #define elf_backend_check_directives          ppc64_elf_before_check_relocs
  98 #define elf_backend_notice_as_needed          ppc64_elf_notice_as_needed
  99 #define elf_backend_archive_symbol_lookup     ppc64_elf_archive_symbol_lookup
 100 #define elf_backend_check_relocs              ppc64_elf_check_relocs
 101 #define elf_backend_gc_keep                   ppc64_elf_gc_keep
 102 #define elf_backend_gc_mark_dynamic_ref       ppc64_elf_gc_mark_dynamic_ref
 103 #define elf_backend_gc_mark_hook              ppc64_elf_gc_mark_hook
 104 #define elf_backend_gc_sweep_hook             ppc64_elf_gc_sweep_hook
 105 #define elf_backend_adjust_dynamic_symbol     ppc64_elf_adjust_dynamic_symbol
 106 #define elf_backend_hide_symbol               ppc64_elf_hide_symbol
 107 #define elf_backend_maybe_function_sym        ppc64_elf_maybe_function_sym
 108 #define elf_backend_always_size_sections      ppc64_elf_func_desc_adjust
 109 #define elf_backend_size_dynamic_sections     ppc64_elf_size_dynamic_sections
 110 #define elf_backend_hash_symbol               ppc64_elf_hash_symbol
 111 #define elf_backend_init_index_section        _bfd_elf_init_2_index_sections
 112 #define elf_backend_action_discarded          ppc64_elf_action_discarded
 113 #define elf_backend_relocate_section          ppc64_elf_relocate_section
 114 #define elf_backend_finish_dynamic_symbol     ppc64_elf_finish_dynamic_symbol
 115 #define elf_backend_reloc_type_class          ppc64_elf_reloc_type_class
 116 #define elf_backend_finish_dynamic_sections   ppc64_elf_finish_dynamic_sections
 117 #define elf_backend_link_output_symbol_hook   ppc64_elf_output_symbol_hook
 118 #define elf_backend_special_sections          ppc64_elf_special_sections
 119 #define elf_backend_merge_symbol_attribute    ppc64_elf_merge_symbol_attribute
 120
 121 /* The name of the dynamic interpreter.  This is put in the .interp
 122    section.  */
 123 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
 124
 125 /* The size in bytes of an entry in the procedure linkage table.  */
 126 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
 127
 128 /* The initial size of the plt reserved for the dynamic linker.  */
 129 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
 130
 131 /* Offsets to some stack save slots.  */
 132 #define STK_LR 16
 133 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
 134 /* This one is dodgy.  ELFv2 does not have a linker word, so use the
 135    CR save slot.  Used only by optimised __tls_get_addr call stub,
 136    relying on __tls_get_addr_opt not saving CR..  */
 137 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
 138
 139 /* TOC base pointers offset from start of TOC.  */
 140 #define TOC_BASE_OFF    0x8000
 141 /* TOC base alignment.  */
 142 #define TOC_BASE_ALIGN  256
 143
 144 /* Offset of tp and dtp pointers from start of TLS block.  */
 145 #define TP_OFFSET       0x7000
 146 #define DTP_OFFSET      0x8000
 147
 148 /* .plt call stub instructions.  The normal stub is like this, but
 149    sometimes the .plt entry crosses a 64k boundary and we need to
 150    insert an addi to adjust r11.  */
 151 #define STD_R2_0R1      0xf8410000      /* std   %r2,0+40(%r1)       */
 152 #define ADDIS_R11_R2    0x3d620000      /* addis %r11,%r2,xxx@ha     */
 153 #define LD_R12_0R11     0xe98b0000      /* ld    %r12,xxx+0@l(%r11)  */
 154 #define MTCTR_R12       0x7d8903a6      /* mtctr %r12                */
 155 #define LD_R2_0R11      0xe84b0000      /* ld    %r2,xxx+8@l(%r11)   */
 156 #define LD_R11_0R11     0xe96b0000      /* ld    %r11,xxx+16@l(%r11) */
 157 #define BCTR            0x4e800420      /* bctr                      */
 158
 159 #define ADDI_R11_R11    0x396b0000      /* addi %r11,%r11,off@l  */
 160 #define ADDIS_R2_R2     0x3c420000      /* addis %r2,%r2,off@ha  */
 161 #define ADDI_R2_R2      0x38420000      /* addi  %r2,%r2,off@l   */
 162
 163 #define XOR_R2_R12_R12  0x7d826278      /* xor   %r2,%r12,%r12   */
 164 #define ADD_R11_R11_R2  0x7d6b1214      /* add   %r11,%r11,%r2   */
 165 #define XOR_R11_R12_R12 0x7d8b6278      /* xor   %r11,%r12,%r12  */
 166 #define ADD_R2_R2_R11   0x7c425a14      /* add   %r2,%r2,%r11    */
 167 #define CMPLDI_R2_0     0x28220000      /* cmpldi %r2,0          */
 168 #define BNECTR          0x4ca20420      /* bnectr+               */
 169 #define BNECTR_P4       0x4ce20420      /* bnectr+               */
 170
 171 #define LD_R12_0R2      0xe9820000      /* ld    %r12,xxx+0(%r2) */
 172 #define LD_R11_0R2      0xe9620000      /* ld    %r11,xxx+0(%r2) */
 173 #define LD_R2_0R2       0xe8420000      /* ld    %r2,xxx+0(%r2)  */
 174
 175 #define LD_R2_0R1       0xe8410000      /* ld    %r2,0(%r1)      */
 176 #define LD_R2_0R12      0xe84c0000      /* ld    %r2,0(%r12)     */
 177 #define ADD_R2_R2_R12   0x7c426214      /* add   %r2,%r2,%r12    */
 178
 179 #define LIS_R2          0x3c400000      /* lis %r2,xxx@ha         */
 180 #define ADDIS_R2_R12    0x3c4c0000      /* addis %r2,%r12,xxx@ha  */
 181 #define ADDIS_R12_R2    0x3d820000      /* addis %r12,%r2,xxx@ha  */
 182 #define ADDIS_R12_R12   0x3d8c0000      /* addis %r12,%r12,xxx@ha */
 183 #define LD_R12_0R12     0xe98c0000      /* ld    %r12,xxx@l(%r12) */
 184
 185 /* glink call stub instructions.  We enter with the index in R0.  */
 186 #define GLINK_CALL_STUB_SIZE (16*4)
 187                                         /* 0:                           */
 188                                         /*  .quad plt0-1f               */
 189                                         /* __glink:                     */
 190 #define MFLR_R12        0x7d8802a6      /*  mflr %12                    */
 191 #define BCL_20_31       0x429f0005      /*  bcl 20,31,1f                */
 192                                         /* 1:                           */
 193 #define MFLR_R11        0x7d6802a6      /*  mflr %11                    */
 194                                         /*  ld %2,(0b-1b)(%11)          */
 195 #define MTLR_R12        0x7d8803a6      /*  mtlr %12                    */
 196 #define ADD_R11_R2_R11  0x7d625a14      /*  add %11,%2,%11              */
 197                                         /*  ld %12,0(%11)               */
 198                                         /*  ld %2,8(%11)                */
 199                                         /*  mtctr %12                   */
 200                                         /*  ld %11,16(%11)              */
 201                                         /*  bctr                        */
 202 #define MFLR_R0         0x7c0802a6      /*  mflr %r0                    */
 203 #define MTLR_R0         0x7c0803a6      /*  mtlr %r0                    */
 204 #define SUB_R12_R12_R11 0x7d8b6050      /*  subf %r12,%r11,%r12         */
 205 #define ADDI_R0_R12     0x380c0000      /*  addi %r0,%r12,0             */
 206 #define SRDI_R0_R0_2    0x7800f082      /*  rldicl %r0,%r0,62,2         */
 207
 208 /* Pad with this.  */
 209 #define NOP             0x60000000
 210
 211 /* Some other nops.  */
 212 #define CROR_151515     0x4def7b82
 213 #define CROR_313131     0x4ffffb82
 214
 215 /* .glink entries for the first 32k functions are two instructions.  */
 216 #define LI_R0_0         0x38000000      /* li    %r0,0          */
 217 #define B_DOT           0x48000000      /* b     .              */
 218
 219 /* After that, we need two instructions to load the index, followed by
 220    a branch.  */
 221 #define LIS_R0_0        0x3c000000      /* lis   %r0,0          */
 222 #define ORI_R0_R0_0     0x60000000      /* ori   %r0,%r0,0      */
 223
 224 /* Instructions used by the save and restore reg functions.  */
 225 #define STD_R0_0R1      0xf8010000      /* std   %r0,0(%r1)     */
 226 #define STD_R0_0R12     0xf80c0000      /* std   %r0,0(%r12)    */
 227 #define LD_R0_0R1       0xe8010000      /* ld    %r0,0(%r1)     */
 228 #define LD_R0_0R12      0xe80c0000      /* ld    %r0,0(%r12)    */
 229 #define STFD_FR0_0R1    0xd8010000      /* stfd  %fr0,0(%r1)    */
 230 #define LFD_FR0_0R1     0xc8010000      /* lfd   %fr0,0(%r1)    */
 231 #define LI_R12_0        0x39800000      /* li    %r12,0         */
 232 #define STVX_VR0_R12_R0 0x7c0c01ce      /* stvx  %v0,%r12,%r0   */
 233 #define LVX_VR0_R12_R0  0x7c0c00ce      /* lvx   %v0,%r12,%r0   */
 234 #define MTLR_R0         0x7c0803a6      /* mtlr  %r0            */
 235 #define BLR             0x4e800020      /* blr                  */
 236
 237 /* Since .opd is an array of descriptors and each entry will end up
 238    with identical R_PPC64_RELATIVE relocs, there is really no need to
 239    propagate .opd relocs;  The dynamic linker should be taught to
 240    relocate .opd without reloc entries.  */
 241 #ifndef NO_OPD_RELOCS
 242 #define NO_OPD_RELOCS 0
 243 #endif
 244
 245 #ifndef ARRAY_SIZE
 246 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
 247 #endif
 248
 249 static inline int
 250 abiversion (bfd *abfd)
 251 {
 252   return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
 253 }
 254
 255 static inline void
 256 set_abiversion (bfd *abfd, int ver)
 257 {
 258   elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
 259   elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
 260 }
 261 \f
 262 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
 263
 264 /* Relocation HOWTO's.  */
 265 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
 266
 267 static reloc_howto_type ppc64_elf_howto_raw[] = {
 268   /* This reloc does nothing.  */
 269   HOWTO (R_PPC64_NONE,          /* type */
 270          0,                     /* rightshift */
 271          3,                     /* size (0 = byte, 1 = short, 2 = long) */
 272          0,                     /* bitsize */
 273          FALSE,                 /* pc_relative */
 274          0,                     /* bitpos */
 275          complain_overflow_dont, /* complain_on_overflow */
 276          bfd_elf_generic_reloc, /* special_function */
 277          "R_PPC64_NONE",        /* name */
 278          FALSE,                 /* partial_inplace */
 279          0,                     /* src_mask */
 280          0,                     /* dst_mask */
 281          FALSE),                /* pcrel_offset */
 282
 283   /* A standard 32 bit relocation.  */
 284   HOWTO (R_PPC64_ADDR32,        /* type */
 285          0,                     /* rightshift */
 286          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 287          32,                    /* bitsize */
 288          FALSE,                 /* pc_relative */
 289          0,                     /* bitpos */
 290          complain_overflow_bitfield, /* complain_on_overflow */
 291          bfd_elf_generic_reloc, /* special_function */
 292          "R_PPC64_ADDR32",      /* name */
 293          FALSE,                 /* partial_inplace */
 294          0,                     /* src_mask */
 295          0xffffffff,            /* dst_mask */
 296          FALSE),                /* pcrel_offset */
 297
 298   /* An absolute 26 bit branch; the lower two bits must be zero.
 299      FIXME: we don't check that, we just clear them.  */
 300   HOWTO (R_PPC64_ADDR24,        /* type */
 301          0,                     /* rightshift */
 302          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 303          26,                    /* bitsize */
 304          FALSE,                 /* pc_relative */
 305          0,                     /* bitpos */
 306          complain_overflow_bitfield, /* complain_on_overflow */
 307          bfd_elf_generic_reloc, /* special_function */
 308          "R_PPC64_ADDR24",      /* name */
 309          FALSE,                 /* partial_inplace */
 310          0,                     /* src_mask */
 311          0x03fffffc,            /* dst_mask */
 312          FALSE),                /* pcrel_offset */
 313
 314   /* A standard 16 bit relocation.  */
 315   HOWTO (R_PPC64_ADDR16,        /* type */
 316          0,                     /* rightshift */
 317          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 318          16,                    /* bitsize */
 319          FALSE,                 /* pc_relative */
 320          0,                     /* bitpos */
 321          complain_overflow_bitfield, /* complain_on_overflow */
 322          bfd_elf_generic_reloc, /* special_function */
 323          "R_PPC64_ADDR16",      /* name */
 324          FALSE,                 /* partial_inplace */
 325          0,                     /* src_mask */
 326          0xffff,                /* dst_mask */
 327          FALSE),                /* pcrel_offset */
 328
 329   /* A 16 bit relocation without overflow.  */
 330   HOWTO (R_PPC64_ADDR16_LO,     /* type */
 331          0,                     /* rightshift */
 332          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 333          16,                    /* bitsize */
 334          FALSE,                 /* pc_relative */
 335          0,                     /* bitpos */
 336          complain_overflow_dont,/* complain_on_overflow */
 337          bfd_elf_generic_reloc, /* special_function */
 338          "R_PPC64_ADDR16_LO",   /* name */
 339          FALSE,                 /* partial_inplace */
 340          0,                     /* src_mask */
 341          0xffff,                /* dst_mask */
 342          FALSE),                /* pcrel_offset */
 343
 344   /* Bits 16-31 of an address.  */
 345   HOWTO (R_PPC64_ADDR16_HI,     /* type */
 346          16,                    /* rightshift */
 347          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 348          16,                    /* bitsize */
 349          FALSE,                 /* pc_relative */
 350          0,                     /* bitpos */
 351          complain_overflow_signed, /* complain_on_overflow */
 352          bfd_elf_generic_reloc, /* special_function */
 353          "R_PPC64_ADDR16_HI",   /* name */
 354          FALSE,                 /* partial_inplace */
 355          0,                     /* src_mask */
 356          0xffff,                /* dst_mask */
 357          FALSE),                /* pcrel_offset */
 358
 359   /* Bits 16-31 of an address, plus 1 if the contents of the low 16
 360      bits, treated as a signed number, is negative.  */
 361   HOWTO (R_PPC64_ADDR16_HA,     /* type */
 362          16,                    /* rightshift */
 363          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 364          16,                    /* bitsize */
 365          FALSE,                 /* pc_relative */
 366          0,                     /* bitpos */
 367          complain_overflow_signed, /* complain_on_overflow */
 368          ppc64_elf_ha_reloc,    /* special_function */
 369          "R_PPC64_ADDR16_HA",   /* name */
 370          FALSE,                 /* partial_inplace */
 371          0,                     /* src_mask */
 372          0xffff,                /* dst_mask */
 373          FALSE),                /* pcrel_offset */
 374
 375   /* An absolute 16 bit branch; the lower two bits must be zero.
 376      FIXME: we don't check that, we just clear them.  */
 377   HOWTO (R_PPC64_ADDR14,        /* type */
 378          0,                     /* rightshift */
 379          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 380          16,                    /* bitsize */
 381          FALSE,                 /* pc_relative */
 382          0,                     /* bitpos */
 383          complain_overflow_signed, /* complain_on_overflow */
 384          ppc64_elf_branch_reloc, /* special_function */
 385          "R_PPC64_ADDR14",      /* name */
 386          FALSE,                 /* partial_inplace */
 387          0,                     /* src_mask */
 388          0x0000fffc,            /* dst_mask */
 389          FALSE),                /* pcrel_offset */
 390
 391   /* An absolute 16 bit branch, for which bit 10 should be set to
 392      indicate that the branch is expected to be taken.  The lower two
 393      bits must be zero.  */
 394   HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
 395          0,                     /* rightshift */
 396          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 397          16,                    /* bitsize */
 398          FALSE,                 /* pc_relative */
 399          0,                     /* bitpos */
 400          complain_overflow_signed, /* complain_on_overflow */
 401          ppc64_elf_brtaken_reloc, /* special_function */
 402          "R_PPC64_ADDR14_BRTAKEN",/* name */
 403          FALSE,                 /* partial_inplace */
 404          0,                     /* src_mask */
 405          0x0000fffc,            /* dst_mask */
 406          FALSE),                /* pcrel_offset */
 407
 408   /* An absolute 16 bit branch, for which bit 10 should be set to
 409      indicate that the branch is not expected to be taken.  The lower
 410      two bits must be zero.  */
 411   HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
 412          0,                     /* rightshift */
 413          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 414          16,                    /* bitsize */
 415          FALSE,                 /* pc_relative */
 416          0,                     /* bitpos */
 417          complain_overflow_signed, /* complain_on_overflow */
 418          ppc64_elf_brtaken_reloc, /* special_function */
 419          "R_PPC64_ADDR14_BRNTAKEN",/* name */
 420          FALSE,                 /* partial_inplace */
 421          0,                     /* src_mask */
 422          0x0000fffc,            /* dst_mask */
 423          FALSE),                /* pcrel_offset */
 424
 425   /* A relative 26 bit branch; the lower two bits must be zero.  */
 426   HOWTO (R_PPC64_REL24,         /* type */
 427          0,                     /* rightshift */
 428          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 429          26,                    /* bitsize */
 430          TRUE,                  /* pc_relative */
 431          0,                     /* bitpos */
 432          complain_overflow_signed, /* complain_on_overflow */
 433          ppc64_elf_branch_reloc, /* special_function */
 434          "R_PPC64_REL24",       /* name */
 435          FALSE,                 /* partial_inplace */
 436          0,                     /* src_mask */
 437          0x03fffffc,            /* dst_mask */
 438          TRUE),                 /* pcrel_offset */
 439
 440   /* A relative 16 bit branch; the lower two bits must be zero.  */
 441   HOWTO (R_PPC64_REL14,         /* type */
 442          0,                     /* rightshift */
 443          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 444          16,                    /* bitsize */
 445          TRUE,                  /* pc_relative */
 446          0,                     /* bitpos */
 447          complain_overflow_signed, /* complain_on_overflow */
 448          ppc64_elf_branch_reloc, /* special_function */
 449          "R_PPC64_REL14",       /* name */
 450          FALSE,                 /* partial_inplace */
 451          0,                     /* src_mask */
 452          0x0000fffc,            /* dst_mask */
 453          TRUE),                 /* pcrel_offset */
 454
 455   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 456      the branch is expected to be taken.  The lower two bits must be
 457      zero.  */
 458   HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
 459          0,                     /* rightshift */
 460          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 461          16,                    /* bitsize */
 462          TRUE,                  /* pc_relative */
 463          0,                     /* bitpos */
 464          complain_overflow_signed, /* complain_on_overflow */
 465          ppc64_elf_brtaken_reloc, /* special_function */
 466          "R_PPC64_REL14_BRTAKEN", /* name */
 467          FALSE,                 /* partial_inplace */
 468          0,                     /* src_mask */
 469          0x0000fffc,            /* dst_mask */
 470          TRUE),                 /* pcrel_offset */
 471
 472   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 473      the branch is not expected to be taken.  The lower two bits must
 474      be zero.  */
 475   HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
 476          0,                     /* rightshift */
 477          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 478          16,                    /* bitsize */
 479          TRUE,                  /* pc_relative */
 480          0,                     /* bitpos */
 481          complain_overflow_signed, /* complain_on_overflow */
 482          ppc64_elf_brtaken_reloc, /* special_function */
 483          "R_PPC64_REL14_BRNTAKEN",/* name */
 484          FALSE,                 /* partial_inplace */
 485          0,                     /* src_mask */
 486          0x0000fffc,            /* dst_mask */
 487          TRUE),                 /* pcrel_offset */
 488
 489   /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
 490      symbol.  */
 491   HOWTO (R_PPC64_GOT16,         /* type */
 492          0,                     /* rightshift */
 493          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 494          16,                    /* bitsize */
 495          FALSE,                 /* pc_relative */
 496          0,                     /* bitpos */
 497          complain_overflow_signed, /* complain_on_overflow */
 498          ppc64_elf_unhandled_reloc, /* special_function */
 499          "R_PPC64_GOT16",       /* name */
 500          FALSE,                 /* partial_inplace */
 501          0,                     /* src_mask */
 502          0xffff,                /* dst_mask */
 503          FALSE),                /* pcrel_offset */
 504
 505   /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
 506      the symbol.  */
 507   HOWTO (R_PPC64_GOT16_LO,      /* type */
 508          0,                     /* rightshift */
 509          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 510          16,                    /* bitsize */
 511          FALSE,                 /* pc_relative */
 512          0,                     /* bitpos */
 513          complain_overflow_dont, /* complain_on_overflow */
 514          ppc64_elf_unhandled_reloc, /* special_function */
 515          "R_PPC64_GOT16_LO",    /* name */
 516          FALSE,                 /* partial_inplace */
 517          0,                     /* src_mask */
 518          0xffff,                /* dst_mask */
 519          FALSE),                /* pcrel_offset */
 520
 521   /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
 522      the symbol.  */
 523   HOWTO (R_PPC64_GOT16_HI,      /* type */
 524          16,                    /* rightshift */
 525          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 526          16,                    /* bitsize */
 527          FALSE,                 /* pc_relative */
 528          0,                     /* bitpos */
 529          complain_overflow_signed,/* complain_on_overflow */
 530          ppc64_elf_unhandled_reloc, /* special_function */
 531          "R_PPC64_GOT16_HI",    /* name */
 532          FALSE,                 /* partial_inplace */
 533          0,                     /* src_mask */
 534          0xffff,                /* dst_mask */
 535          FALSE),                /* pcrel_offset */
 536
 537   /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
 538      the symbol.  */
 539   HOWTO (R_PPC64_GOT16_HA,      /* type */
 540          16,                    /* rightshift */
 541          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 542          16,                    /* bitsize */
 543          FALSE,                 /* pc_relative */
 544          0,                     /* bitpos */
 545          complain_overflow_signed,/* complain_on_overflow */
 546          ppc64_elf_unhandled_reloc, /* special_function */
 547          "R_PPC64_GOT16_HA",    /* name */
 548          FALSE,                 /* partial_inplace */
 549          0,                     /* src_mask */
 550          0xffff,                /* dst_mask */
 551          FALSE),                /* pcrel_offset */
 552
 553   /* This is used only by the dynamic linker.  The symbol should exist
 554      both in the object being run and in some shared library.  The
 555      dynamic linker copies the data addressed by the symbol from the
 556      shared library into the object, because the object being
 557      run has to have the data at some particular address.  */
 558   HOWTO (R_PPC64_COPY,          /* type */
 559          0,                     /* rightshift */
 560          0,                     /* this one is variable size */
 561          0,                     /* bitsize */
 562          FALSE,                 /* pc_relative */
 563          0,                     /* bitpos */
 564          complain_overflow_dont, /* complain_on_overflow */
 565          ppc64_elf_unhandled_reloc, /* special_function */
 566          "R_PPC64_COPY",        /* name */
 567          FALSE,                 /* partial_inplace */
 568          0,                     /* src_mask */
 569          0,                     /* dst_mask */
 570          FALSE),                /* pcrel_offset */
 571
 572   /* Like R_PPC64_ADDR64, but used when setting global offset table
 573      entries.  */
 574   HOWTO (R_PPC64_GLOB_DAT,      /* type */
 575          0,                     /* rightshift */
 576          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 577          64,                    /* bitsize */
 578          FALSE,                 /* pc_relative */
 579          0,                     /* bitpos */
 580          complain_overflow_dont, /* complain_on_overflow */
 581          ppc64_elf_unhandled_reloc,  /* special_function */
 582          "R_PPC64_GLOB_DAT",    /* name */
 583          FALSE,                 /* partial_inplace */
 584          0,                     /* src_mask */
 585          ONES (64),             /* dst_mask */
 586          FALSE),                /* pcrel_offset */
 587
 588   /* Created by the link editor.  Marks a procedure linkage table
 589      entry for a symbol.  */
 590   HOWTO (R_PPC64_JMP_SLOT,      /* type */
 591          0,                     /* rightshift */
 592          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 593          0,                     /* bitsize */
 594          FALSE,                 /* pc_relative */
 595          0,                     /* bitpos */
 596          complain_overflow_dont, /* complain_on_overflow */
 597          ppc64_elf_unhandled_reloc, /* special_function */
 598          "R_PPC64_JMP_SLOT",    /* name */
 599          FALSE,                 /* partial_inplace */
 600          0,                     /* src_mask */
 601          0,                     /* dst_mask */
 602          FALSE),                /* pcrel_offset */
 603
 604   /* Used only by the dynamic linker.  When the object is run, this
 605      doubleword64 is set to the load address of the object, plus the
 606      addend.  */
 607   HOWTO (R_PPC64_RELATIVE,      /* type */
 608          0,                     /* rightshift */
 609          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 610          64,                    /* bitsize */
 611          FALSE,                 /* pc_relative */
 612          0,                     /* bitpos */
 613          complain_overflow_dont, /* complain_on_overflow */
 614          bfd_elf_generic_reloc, /* special_function */
 615          "R_PPC64_RELATIVE",    /* name */
 616          FALSE,                 /* partial_inplace */
 617          0,                     /* src_mask */
 618          ONES (64),             /* dst_mask */
 619          FALSE),                /* pcrel_offset */
 620
 621   /* Like R_PPC64_ADDR32, but may be unaligned.  */
 622   HOWTO (R_PPC64_UADDR32,       /* type */
 623          0,                     /* rightshift */
 624          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 625          32,                    /* bitsize */
 626          FALSE,                 /* pc_relative */
 627          0,                     /* bitpos */
 628          complain_overflow_bitfield, /* complain_on_overflow */
 629          bfd_elf_generic_reloc, /* special_function */
 630          "R_PPC64_UADDR32",     /* name */
 631          FALSE,                 /* partial_inplace */
 632          0,                     /* src_mask */
 633          0xffffffff,            /* dst_mask */
 634          FALSE),                /* pcrel_offset */
 635
 636   /* Like R_PPC64_ADDR16, but may be unaligned.  */
 637   HOWTO (R_PPC64_UADDR16,       /* type */
 638          0,                     /* rightshift */
 639          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 640          16,                    /* bitsize */
 641          FALSE,                 /* pc_relative */
 642          0,                     /* bitpos */
 643          complain_overflow_bitfield, /* complain_on_overflow */
 644          bfd_elf_generic_reloc, /* special_function */
 645          "R_PPC64_UADDR16",     /* name */
 646          FALSE,                 /* partial_inplace */
 647          0,                     /* src_mask */
 648          0xffff,                /* dst_mask */
 649          FALSE),                /* pcrel_offset */
 650
 651   /* 32-bit PC relative.  */
 652   HOWTO (R_PPC64_REL32,         /* type */
 653          0,                     /* rightshift */
 654          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 655          32,                    /* bitsize */
 656          TRUE,                  /* pc_relative */
 657          0,                     /* bitpos */
 658          complain_overflow_signed, /* complain_on_overflow */
 659          bfd_elf_generic_reloc, /* special_function */
 660          "R_PPC64_REL32",       /* name */
 661          FALSE,                 /* partial_inplace */
 662          0,                     /* src_mask */
 663          0xffffffff,            /* dst_mask */
 664          TRUE),                 /* pcrel_offset */
 665
 666   /* 32-bit relocation to the symbol's procedure linkage table.  */
 667   HOWTO (R_PPC64_PLT32,         /* type */
 668          0,                     /* rightshift */
 669          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 670          32,                    /* bitsize */
 671          FALSE,                 /* pc_relative */
 672          0,                     /* bitpos */
 673          complain_overflow_bitfield, /* complain_on_overflow */
 674          ppc64_elf_unhandled_reloc, /* special_function */
 675          "R_PPC64_PLT32",       /* name */
 676          FALSE,                 /* partial_inplace */
 677          0,                     /* src_mask */
 678          0xffffffff,            /* dst_mask */
 679          FALSE),                /* pcrel_offset */
 680
 681   /* 32-bit PC relative relocation to the symbol's procedure linkage table.
 682      FIXME: R_PPC64_PLTREL32 not supported.  */
 683   HOWTO (R_PPC64_PLTREL32,      /* type */
 684          0,                     /* rightshift */
 685          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 686          32,                    /* bitsize */
 687          TRUE,                  /* pc_relative */
 688          0,                     /* bitpos */
 689          complain_overflow_signed, /* complain_on_overflow */
 690          ppc64_elf_unhandled_reloc, /* special_function */
 691          "R_PPC64_PLTREL32",    /* name */
 692          FALSE,                 /* partial_inplace */
 693          0,                     /* src_mask */
 694          0xffffffff,            /* dst_mask */
 695          TRUE),                 /* pcrel_offset */
 696
 697   /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
 698      the symbol.  */
 699   HOWTO (R_PPC64_PLT16_LO,      /* type */
 700          0,                     /* rightshift */
 701          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 702          16,                    /* bitsize */
 703          FALSE,                 /* pc_relative */
 704          0,                     /* bitpos */
 705          complain_overflow_dont, /* complain_on_overflow */
 706          ppc64_elf_unhandled_reloc, /* special_function */
 707          "R_PPC64_PLT16_LO",    /* name */
 708          FALSE,                 /* partial_inplace */
 709          0,                     /* src_mask */
 710          0xffff,                /* dst_mask */
 711          FALSE),                /* pcrel_offset */
 712
 713   /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
 714      the symbol.  */
 715   HOWTO (R_PPC64_PLT16_HI,      /* type */
 716          16,                    /* rightshift */
 717          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 718          16,                    /* bitsize */
 719          FALSE,                 /* pc_relative */
 720          0,                     /* bitpos */
 721          complain_overflow_signed, /* complain_on_overflow */
 722          ppc64_elf_unhandled_reloc, /* special_function */
 723          "R_PPC64_PLT16_HI",    /* name */
 724          FALSE,                 /* partial_inplace */
 725          0,                     /* src_mask */
 726          0xffff,                /* dst_mask */
 727          FALSE),                /* pcrel_offset */
 728
 729   /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
 730      the symbol.  */
 731   HOWTO (R_PPC64_PLT16_HA,      /* type */
 732          16,                    /* rightshift */
 733          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 734          16,                    /* bitsize */
 735          FALSE,                 /* pc_relative */
 736          0,                     /* bitpos */
 737          complain_overflow_signed, /* complain_on_overflow */
 738          ppc64_elf_unhandled_reloc, /* special_function */
 739          "R_PPC64_PLT16_HA",    /* name */
 740          FALSE,                 /* partial_inplace */
 741          0,                     /* src_mask */
 742          0xffff,                /* dst_mask */
 743          FALSE),                /* pcrel_offset */
 744
 745   /* 16-bit section relative relocation.  */
 746   HOWTO (R_PPC64_SECTOFF,       /* type */
 747          0,                     /* rightshift */
 748          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 749          16,                    /* bitsize */
 750          FALSE,                 /* pc_relative */
 751          0,                     /* bitpos */
 752          complain_overflow_signed, /* complain_on_overflow */
 753          ppc64_elf_sectoff_reloc, /* special_function */
 754          "R_PPC64_SECTOFF",     /* name */
 755          FALSE,                 /* partial_inplace */
 756          0,                     /* src_mask */
 757          0xffff,                /* dst_mask */
 758          FALSE),                /* pcrel_offset */
 759
 760   /* Like R_PPC64_SECTOFF, but no overflow warning.  */
 761   HOWTO (R_PPC64_SECTOFF_LO,    /* type */
 762          0,                     /* rightshift */
 763          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 764          16,                    /* bitsize */
 765          FALSE,                 /* pc_relative */
 766          0,                     /* bitpos */
 767          complain_overflow_dont, /* complain_on_overflow */
 768          ppc64_elf_sectoff_reloc, /* special_function */
 769          "R_PPC64_SECTOFF_LO",  /* name */
 770          FALSE,                 /* partial_inplace */
 771          0,                     /* src_mask */
 772          0xffff,                /* dst_mask */
 773          FALSE),                /* pcrel_offset */
 774
 775   /* 16-bit upper half section relative relocation.  */
 776   HOWTO (R_PPC64_SECTOFF_HI,    /* type */
 777          16,                    /* rightshift */
 778          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 779          16,                    /* bitsize */
 780          FALSE,                 /* pc_relative */
 781          0,                     /* bitpos */
 782          complain_overflow_signed, /* complain_on_overflow */
 783          ppc64_elf_sectoff_reloc, /* special_function */
 784          "R_PPC64_SECTOFF_HI",  /* name */
 785          FALSE,                 /* partial_inplace */
 786          0,                     /* src_mask */
 787          0xffff,                /* dst_mask */
 788          FALSE),                /* pcrel_offset */
 789
 790   /* 16-bit upper half adjusted section relative relocation.  */
 791   HOWTO (R_PPC64_SECTOFF_HA,    /* type */
 792          16,                    /* rightshift */
 793          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 794          16,                    /* bitsize */
 795          FALSE,                 /* pc_relative */
 796          0,                     /* bitpos */
 797          complain_overflow_signed, /* complain_on_overflow */
 798          ppc64_elf_sectoff_ha_reloc, /* special_function */
 799          "R_PPC64_SECTOFF_HA",  /* name */
 800          FALSE,                 /* partial_inplace */
 801          0,                     /* src_mask */
 802          0xffff,                /* dst_mask */
 803          FALSE),                /* pcrel_offset */
 804
 805   /* Like R_PPC64_REL24 without touching the two least significant bits.  */
 806   HOWTO (R_PPC64_REL30,         /* type */
 807          2,                     /* rightshift */
 808          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 809          30,                    /* bitsize */
 810          TRUE,                  /* pc_relative */
 811          0,                     /* bitpos */
 812          complain_overflow_dont, /* complain_on_overflow */
 813          bfd_elf_generic_reloc, /* special_function */
 814          "R_PPC64_REL30",       /* name */
 815          FALSE,                 /* partial_inplace */
 816          0,                     /* src_mask */
 817          0xfffffffc,            /* dst_mask */
 818          TRUE),                 /* pcrel_offset */
 819
 820   /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI.  */
 821
 822   /* A standard 64-bit relocation.  */
 823   HOWTO (R_PPC64_ADDR64,        /* type */
 824          0,                     /* rightshift */
 825          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 826          64,                    /* bitsize */
 827          FALSE,                 /* pc_relative */
 828          0,                     /* bitpos */
 829          complain_overflow_dont, /* complain_on_overflow */
 830          bfd_elf_generic_reloc, /* special_function */
 831          "R_PPC64_ADDR64",      /* name */
 832          FALSE,                 /* partial_inplace */
 833          0,                     /* src_mask */
 834          ONES (64),             /* dst_mask */
 835          FALSE),                /* pcrel_offset */
 836
 837   /* The bits 32-47 of an address.  */
 838   HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
 839          32,                    /* rightshift */
 840          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 841          16,                    /* bitsize */
 842          FALSE,                 /* pc_relative */
 843          0,                     /* bitpos */
 844          complain_overflow_dont, /* complain_on_overflow */
 845          bfd_elf_generic_reloc, /* special_function */
 846          "R_PPC64_ADDR16_HIGHER", /* name */
 847          FALSE,                 /* partial_inplace */
 848          0,                     /* src_mask */
 849          0xffff,                /* dst_mask */
 850          FALSE),                /* pcrel_offset */
 851
 852   /* The bits 32-47 of an address, plus 1 if the contents of the low
 853      16 bits, treated as a signed number, is negative.  */
 854   HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
 855          32,                    /* rightshift */
 856          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 857          16,                    /* bitsize */
 858          FALSE,                 /* pc_relative */
 859          0,                     /* bitpos */
 860          complain_overflow_dont, /* complain_on_overflow */
 861          ppc64_elf_ha_reloc,    /* special_function */
 862          "R_PPC64_ADDR16_HIGHERA", /* name */
 863          FALSE,                 /* partial_inplace */
 864          0,                     /* src_mask */
 865          0xffff,                /* dst_mask */
 866          FALSE),                /* pcrel_offset */
 867
 868   /* The bits 48-63 of an address.  */
 869   HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
 870          48,                    /* rightshift */
 871          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 872          16,                    /* bitsize */
 873          FALSE,                 /* pc_relative */
 874          0,                     /* bitpos */
 875          complain_overflow_dont, /* complain_on_overflow */
 876          bfd_elf_generic_reloc, /* special_function */
 877          "R_PPC64_ADDR16_HIGHEST", /* name */
 878          FALSE,                 /* partial_inplace */
 879          0,                     /* src_mask */
 880          0xffff,                /* dst_mask */
 881          FALSE),                /* pcrel_offset */
 882
 883   /* The bits 48-63 of an address, plus 1 if the contents of the low
 884      16 bits, treated as a signed number, is negative.  */
 885   HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
 886          48,                    /* rightshift */
 887          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 888          16,                    /* bitsize */
 889          FALSE,                 /* pc_relative */
 890          0,                     /* bitpos */
 891          complain_overflow_dont, /* complain_on_overflow */
 892          ppc64_elf_ha_reloc,    /* special_function */
 893          "R_PPC64_ADDR16_HIGHESTA", /* name */
 894          FALSE,                 /* partial_inplace */
 895          0,                     /* src_mask */
 896          0xffff,                /* dst_mask */
 897          FALSE),                /* pcrel_offset */
 898
 899   /* Like ADDR64, but may be unaligned.  */
 900   HOWTO (R_PPC64_UADDR64,       /* type */
 901          0,                     /* rightshift */
 902          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 903          64,                    /* bitsize */
 904          FALSE,                 /* pc_relative */
 905          0,                     /* bitpos */
 906          complain_overflow_dont, /* complain_on_overflow */
 907          bfd_elf_generic_reloc, /* special_function */
 908          "R_PPC64_UADDR64",     /* name */
 909          FALSE,                 /* partial_inplace */
 910          0,                     /* src_mask */
 911          ONES (64),             /* dst_mask */
 912          FALSE),                /* pcrel_offset */
 913
 914   /* 64-bit relative relocation.  */
 915   HOWTO (R_PPC64_REL64,         /* type */
 916          0,                     /* rightshift */
 917          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 918          64,                    /* bitsize */
 919          TRUE,                  /* pc_relative */
 920          0,                     /* bitpos */
 921          complain_overflow_dont, /* complain_on_overflow */
 922          bfd_elf_generic_reloc, /* special_function */
 923          "R_PPC64_REL64",       /* name */
 924          FALSE,                 /* partial_inplace */
 925          0,                     /* src_mask */
 926          ONES (64),             /* dst_mask */
 927          TRUE),                 /* pcrel_offset */
 928
 929   /* 64-bit relocation to the symbol's procedure linkage table.  */
 930   HOWTO (R_PPC64_PLT64,         /* type */
 931          0,                     /* rightshift */
 932          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 933          64,                    /* bitsize */
 934          FALSE,                 /* pc_relative */
 935          0,                     /* bitpos */
 936          complain_overflow_dont, /* complain_on_overflow */
 937          ppc64_elf_unhandled_reloc, /* special_function */
 938          "R_PPC64_PLT64",       /* name */
 939          FALSE,                 /* partial_inplace */
 940          0,                     /* src_mask */
 941          ONES (64),             /* dst_mask */
 942          FALSE),                /* pcrel_offset */
 943
 944   /* 64-bit PC relative relocation to the symbol's procedure linkage
 945      table.  */
 946   /* FIXME: R_PPC64_PLTREL64 not supported.  */
 947   HOWTO (R_PPC64_PLTREL64,      /* type */
 948          0,                     /* rightshift */
 949          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 950          64,                    /* bitsize */
 951          TRUE,                  /* pc_relative */
 952          0,                     /* bitpos */
 953          complain_overflow_dont, /* complain_on_overflow */
 954          ppc64_elf_unhandled_reloc, /* special_function */
 955          "R_PPC64_PLTREL64",    /* name */
 956          FALSE,                 /* partial_inplace */
 957          0,                     /* src_mask */
 958          ONES (64),             /* dst_mask */
 959          TRUE),                 /* pcrel_offset */
 960
 961   /* 16 bit TOC-relative relocation.  */
 962
 963   /* R_PPC64_TOC16        47       half16*      S + A - .TOC.  */
 964   HOWTO (R_PPC64_TOC16,         /* type */
 965          0,                     /* rightshift */
 966          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 967          16,                    /* bitsize */
 968          FALSE,                 /* pc_relative */
 969          0,                     /* bitpos */
 970          complain_overflow_signed, /* complain_on_overflow */
 971          ppc64_elf_toc_reloc,   /* special_function */
 972          "R_PPC64_TOC16",       /* name */
 973          FALSE,                 /* partial_inplace */
 974          0,                     /* src_mask */
 975          0xffff,                /* dst_mask */
 976          FALSE),                /* pcrel_offset */
 977
 978   /* 16 bit TOC-relative relocation without overflow.  */
 979
 980   /* R_PPC64_TOC16_LO     48       half16        #lo (S + A - .TOC.)  */
 981   HOWTO (R_PPC64_TOC16_LO,      /* type */
 982          0,                     /* rightshift */
 983          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 984          16,                    /* bitsize */
 985          FALSE,                 /* pc_relative */
 986          0,                     /* bitpos */
 987          complain_overflow_dont, /* complain_on_overflow */
 988          ppc64_elf_toc_reloc,   /* special_function */
 989          "R_PPC64_TOC16_LO",    /* name */
 990          FALSE,                 /* partial_inplace */
 991          0,                     /* src_mask */
 992          0xffff,                /* dst_mask */
 993          FALSE),                /* pcrel_offset */
 994
 995   /* 16 bit TOC-relative relocation, high 16 bits.  */
 996
 997   /* R_PPC64_TOC16_HI     49       half16        #hi (S + A - .TOC.)  */
 998   HOWTO (R_PPC64_TOC16_HI,      /* type */
 999          16,                    /* rightshift */
1000          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1001          16,                    /* bitsize */
1002          FALSE,                 /* pc_relative */
1003          0,                     /* bitpos */
1004          complain_overflow_signed, /* complain_on_overflow */
1005          ppc64_elf_toc_reloc,   /* special_function */
1006          "R_PPC64_TOC16_HI",    /* name */
1007          FALSE,                 /* partial_inplace */
1008          0,                     /* src_mask */
1009          0xffff,                /* dst_mask */
1010          FALSE),                /* pcrel_offset */
1011
1012   /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
1013      contents of the low 16 bits, treated as a signed number, is
1014      negative.  */
1015
1016   /* R_PPC64_TOC16_HA     50       half16        #ha (S + A - .TOC.)  */
1017   HOWTO (R_PPC64_TOC16_HA,      /* type */
1018          16,                    /* rightshift */
1019          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1020          16,                    /* bitsize */
1021          FALSE,                 /* pc_relative */
1022          0,                     /* bitpos */
1023          complain_overflow_signed, /* complain_on_overflow */
1024          ppc64_elf_toc_ha_reloc, /* special_function */
1025          "R_PPC64_TOC16_HA",    /* name */
1026          FALSE,                 /* partial_inplace */
1027          0,                     /* src_mask */
1028          0xffff,                /* dst_mask */
1029          FALSE),                /* pcrel_offset */
1030
1031   /* 64-bit relocation; insert value of TOC base (.TOC.).  */
1032
1033   /* R_PPC64_TOC                  51       doubleword64  .TOC.  */
1034   HOWTO (R_PPC64_TOC,           /* type */
1035          0,                     /* rightshift */
1036          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1037          64,                    /* bitsize */
1038          FALSE,                 /* pc_relative */
1039          0,                     /* bitpos */
1040          complain_overflow_dont, /* complain_on_overflow */
1041          ppc64_elf_toc64_reloc, /* special_function */
1042          "R_PPC64_TOC",         /* name */
1043          FALSE,                 /* partial_inplace */
1044          0,                     /* src_mask */
1045          ONES (64),             /* dst_mask */
1046          FALSE),                /* pcrel_offset */
1047
1048   /* Like R_PPC64_GOT16, but also informs the link editor that the
1049      value to relocate may (!) refer to a PLT entry which the link
1050      editor (a) may replace with the symbol value.  If the link editor
1051      is unable to fully resolve the symbol, it may (b) create a PLT
1052      entry and store the address to the new PLT entry in the GOT.
1053      This permits lazy resolution of function symbols at run time.
1054      The link editor may also skip all of this and just (c) emit a
1055      R_PPC64_GLOB_DAT to tie the symbol to the GOT entry.  */
1056   /* FIXME: R_PPC64_PLTGOT16 not implemented.  */
1057     HOWTO (R_PPC64_PLTGOT16,    /* type */
1058          0,                     /* rightshift */
1059          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1060          16,                    /* bitsize */
1061          FALSE,                 /* pc_relative */
1062          0,                     /* bitpos */
1063          complain_overflow_signed, /* complain_on_overflow */
1064          ppc64_elf_unhandled_reloc, /* special_function */
1065          "R_PPC64_PLTGOT16",    /* name */
1066          FALSE,                 /* partial_inplace */
1067          0,                     /* src_mask */
1068          0xffff,                /* dst_mask */
1069          FALSE),                /* pcrel_offset */
1070
1071   /* Like R_PPC64_PLTGOT16, but without overflow.  */
1072   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1073   HOWTO (R_PPC64_PLTGOT16_LO,   /* type */
1074          0,                     /* rightshift */
1075          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1076          16,                    /* bitsize */
1077          FALSE,                 /* pc_relative */
1078          0,                     /* bitpos */
1079          complain_overflow_dont, /* complain_on_overflow */
1080          ppc64_elf_unhandled_reloc, /* special_function */
1081          "R_PPC64_PLTGOT16_LO", /* name */
1082          FALSE,                 /* partial_inplace */
1083          0,                     /* src_mask */
1084          0xffff,                /* dst_mask */
1085          FALSE),                /* pcrel_offset */
1086
1087   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address.  */
1088   /* FIXME: R_PPC64_PLTGOT16_HI not implemented.  */
1089   HOWTO (R_PPC64_PLTGOT16_HI,   /* type */
1090          16,                    /* rightshift */
1091          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1092          16,                    /* bitsize */
1093          FALSE,                 /* pc_relative */
1094          0,                     /* bitpos */
1095          complain_overflow_signed, /* complain_on_overflow */
1096          ppc64_elf_unhandled_reloc, /* special_function */
1097          "R_PPC64_PLTGOT16_HI", /* name */
1098          FALSE,                 /* partial_inplace */
1099          0,                     /* src_mask */
1100          0xffff,                /* dst_mask */
1101          FALSE),                /* pcrel_offset */
1102
1103   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1104      1 if the contents of the low 16 bits, treated as a signed number,
1105      is negative.  */
1106   /* FIXME: R_PPC64_PLTGOT16_HA not implemented.  */
1107   HOWTO (R_PPC64_PLTGOT16_HA,   /* type */
1108          16,                    /* rightshift */
1109          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1110          16,                    /* bitsize */
1111          FALSE,                 /* pc_relative */
1112          0,                     /* bitpos */
1113          complain_overflow_signed, /* complain_on_overflow */
1114          ppc64_elf_unhandled_reloc, /* special_function */
1115          "R_PPC64_PLTGOT16_HA", /* name */
1116          FALSE,                 /* partial_inplace */
1117          0,                     /* src_mask */
1118          0xffff,                /* dst_mask */
1119          FALSE),                /* pcrel_offset */
1120
1121   /* Like R_PPC64_ADDR16, but for instructions with a DS field.  */
1122   HOWTO (R_PPC64_ADDR16_DS,     /* type */
1123          0,                     /* rightshift */
1124          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1125          16,                    /* bitsize */
1126          FALSE,                 /* pc_relative */
1127          0,                     /* bitpos */
1128          complain_overflow_signed, /* complain_on_overflow */
1129          bfd_elf_generic_reloc, /* special_function */
1130          "R_PPC64_ADDR16_DS",   /* name */
1131          FALSE,                 /* partial_inplace */
1132          0,                     /* src_mask */
1133          0xfffc,                /* dst_mask */
1134          FALSE),                /* pcrel_offset */
1135
1136   /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field.  */
1137   HOWTO (R_PPC64_ADDR16_LO_DS,  /* type */
1138          0,                     /* rightshift */
1139          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1140          16,                    /* bitsize */
1141          FALSE,                 /* pc_relative */
1142          0,                     /* bitpos */
1143          complain_overflow_dont,/* complain_on_overflow */
1144          bfd_elf_generic_reloc, /* special_function */
1145          "R_PPC64_ADDR16_LO_DS",/* name */
1146          FALSE,                 /* partial_inplace */
1147          0,                     /* src_mask */
1148          0xfffc,                /* dst_mask */
1149          FALSE),                /* pcrel_offset */
1150
1151   /* Like R_PPC64_GOT16, but for instructions with a DS field.  */
1152   HOWTO (R_PPC64_GOT16_DS,      /* type */
1153          0,                     /* rightshift */
1154          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1155          16,                    /* bitsize */
1156          FALSE,                 /* pc_relative */
1157          0,                     /* bitpos */
1158          complain_overflow_signed, /* complain_on_overflow */
1159          ppc64_elf_unhandled_reloc, /* special_function */
1160          "R_PPC64_GOT16_DS",    /* name */
1161          FALSE,                 /* partial_inplace */
1162          0,                     /* src_mask */
1163          0xfffc,                /* dst_mask */
1164          FALSE),                /* pcrel_offset */
1165
1166   /* Like R_PPC64_GOT16_LO, but for instructions with a DS field.  */
1167   HOWTO (R_PPC64_GOT16_LO_DS,   /* type */
1168          0,                     /* rightshift */
1169          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1170          16,                    /* bitsize */
1171          FALSE,                 /* pc_relative */
1172          0,                     /* bitpos */
1173          complain_overflow_dont, /* complain_on_overflow */
1174          ppc64_elf_unhandled_reloc, /* special_function */
1175          "R_PPC64_GOT16_LO_DS", /* name */
1176          FALSE,                 /* partial_inplace */
1177          0,                     /* src_mask */
1178          0xfffc,                /* dst_mask */
1179          FALSE),                /* pcrel_offset */
1180
1181   /* Like R_PPC64_PLT16_LO, but for instructions with a DS field.  */
1182   HOWTO (R_PPC64_PLT16_LO_DS,   /* type */
1183          0,                     /* rightshift */
1184          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1185          16,                    /* bitsize */
1186          FALSE,                 /* pc_relative */
1187          0,                     /* bitpos */
1188          complain_overflow_dont, /* complain_on_overflow */
1189          ppc64_elf_unhandled_reloc, /* special_function */
1190          "R_PPC64_PLT16_LO_DS", /* name */
1191          FALSE,                 /* partial_inplace */
1192          0,                     /* src_mask */
1193          0xfffc,                /* dst_mask */
1194          FALSE),                /* pcrel_offset */
1195
1196   /* Like R_PPC64_SECTOFF, but for instructions with a DS field.  */
1197   HOWTO (R_PPC64_SECTOFF_DS,    /* type */
1198          0,                     /* rightshift */
1199          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1200          16,                    /* bitsize */
1201          FALSE,                 /* pc_relative */
1202          0,                     /* bitpos */
1203          complain_overflow_signed, /* complain_on_overflow */
1204          ppc64_elf_sectoff_reloc, /* special_function */
1205          "R_PPC64_SECTOFF_DS",  /* name */
1206          FALSE,                 /* partial_inplace */
1207          0,                     /* src_mask */
1208          0xfffc,                /* dst_mask */
1209          FALSE),                /* pcrel_offset */
1210
1211   /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field.  */
1212   HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1213          0,                     /* rightshift */
1214          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1215          16,                    /* bitsize */
1216          FALSE,                 /* pc_relative */
1217          0,                     /* bitpos */
1218          complain_overflow_dont, /* complain_on_overflow */
1219          ppc64_elf_sectoff_reloc, /* special_function */
1220          "R_PPC64_SECTOFF_LO_DS",/* name */
1221          FALSE,                 /* partial_inplace */
1222          0,                     /* src_mask */
1223          0xfffc,                /* dst_mask */
1224          FALSE),                /* pcrel_offset */
1225
1226   /* Like R_PPC64_TOC16, but for instructions with a DS field.  */
1227   HOWTO (R_PPC64_TOC16_DS,      /* type */
1228          0,                     /* rightshift */
1229          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1230          16,                    /* bitsize */
1231          FALSE,                 /* pc_relative */
1232          0,                     /* bitpos */
1233          complain_overflow_signed, /* complain_on_overflow */
1234          ppc64_elf_toc_reloc,   /* special_function */
1235          "R_PPC64_TOC16_DS",    /* name */
1236          FALSE,                 /* partial_inplace */
1237          0,                     /* src_mask */
1238          0xfffc,                /* dst_mask */
1239          FALSE),                /* pcrel_offset */
1240
1241   /* Like R_PPC64_TOC16_LO, but for instructions with a DS field.  */
1242   HOWTO (R_PPC64_TOC16_LO_DS,   /* type */
1243          0,                     /* rightshift */
1244          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1245          16,                    /* bitsize */
1246          FALSE,                 /* pc_relative */
1247          0,                     /* bitpos */
1248          complain_overflow_dont, /* complain_on_overflow */
1249          ppc64_elf_toc_reloc,   /* special_function */
1250          "R_PPC64_TOC16_LO_DS", /* name */
1251          FALSE,                 /* partial_inplace */
1252          0,                     /* src_mask */
1253          0xfffc,                /* dst_mask */
1254          FALSE),                /* pcrel_offset */
1255
1256   /* Like R_PPC64_PLTGOT16, but for instructions with a DS field.  */
1257   /* FIXME: R_PPC64_PLTGOT16_DS not implemented.  */
1258   HOWTO (R_PPC64_PLTGOT16_DS,   /* type */
1259          0,                     /* rightshift */
1260          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1261          16,                    /* bitsize */
1262          FALSE,                 /* pc_relative */
1263          0,                     /* bitpos */
1264          complain_overflow_signed, /* complain_on_overflow */
1265          ppc64_elf_unhandled_reloc, /* special_function */
1266          "R_PPC64_PLTGOT16_DS", /* name */
1267          FALSE,                 /* partial_inplace */
1268          0,                     /* src_mask */
1269          0xfffc,                /* dst_mask */
1270          FALSE),                /* pcrel_offset */
1271
1272   /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field.  */
1273   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1274   HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1275          0,                     /* rightshift */
1276          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1277          16,                    /* bitsize */
1278          FALSE,                 /* pc_relative */
1279          0,                     /* bitpos */
1280          complain_overflow_dont, /* complain_on_overflow */
1281          ppc64_elf_unhandled_reloc, /* special_function */
1282          "R_PPC64_PLTGOT16_LO_DS",/* name */
1283          FALSE,                 /* partial_inplace */
1284          0,                     /* src_mask */
1285          0xfffc,                /* dst_mask */
1286          FALSE),                /* pcrel_offset */
1287
1288   /* Marker relocs for TLS.  */
1289   HOWTO (R_PPC64_TLS,
1290          0,                     /* rightshift */
1291          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1292          32,                    /* bitsize */
1293          FALSE,                 /* pc_relative */
1294          0,                     /* bitpos */
1295          complain_overflow_dont, /* complain_on_overflow */
1296          bfd_elf_generic_reloc, /* special_function */
1297          "R_PPC64_TLS",         /* name */
1298          FALSE,                 /* partial_inplace */
1299          0,                     /* src_mask */
1300          0,                     /* dst_mask */
1301          FALSE),                /* pcrel_offset */
1302
1303   HOWTO (R_PPC64_TLSGD,
1304          0,                     /* rightshift */
1305          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1306          32,                    /* bitsize */
1307          FALSE,                 /* pc_relative */
1308          0,                     /* bitpos */
1309          complain_overflow_dont, /* complain_on_overflow */
1310          bfd_elf_generic_reloc, /* special_function */
1311          "R_PPC64_TLSGD",       /* name */
1312          FALSE,                 /* partial_inplace */
1313          0,                     /* src_mask */
1314          0,                     /* dst_mask */
1315          FALSE),                /* pcrel_offset */
1316
1317   HOWTO (R_PPC64_TLSLD,
1318          0,                     /* rightshift */
1319          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1320          32,                    /* bitsize */
1321          FALSE,                 /* pc_relative */
1322          0,                     /* bitpos */
1323          complain_overflow_dont, /* complain_on_overflow */
1324          bfd_elf_generic_reloc, /* special_function */
1325          "R_PPC64_TLSLD",       /* name */
1326          FALSE,                 /* partial_inplace */
1327          0,                     /* src_mask */
1328          0,                     /* dst_mask */
1329          FALSE),                /* pcrel_offset */
1330
1331   HOWTO (R_PPC64_TOCSAVE,
1332          0,                     /* rightshift */
1333          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1334          32,                    /* bitsize */
1335          FALSE,                 /* pc_relative */
1336          0,                     /* bitpos */
1337          complain_overflow_dont, /* complain_on_overflow */
1338          bfd_elf_generic_reloc, /* special_function */
1339          "R_PPC64_TOCSAVE",     /* name */
1340          FALSE,                 /* partial_inplace */
1341          0,                     /* src_mask */
1342          0,                     /* dst_mask */
1343          FALSE),                /* pcrel_offset */
1344
1345   /* Computes the load module index of the load module that contains the
1346      definition of its TLS sym.  */
1347   HOWTO (R_PPC64_DTPMOD64,
1348          0,                     /* rightshift */
1349          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1350          64,                    /* bitsize */
1351          FALSE,                 /* pc_relative */
1352          0,                     /* bitpos */
1353          complain_overflow_dont, /* complain_on_overflow */
1354          ppc64_elf_unhandled_reloc, /* special_function */
1355          "R_PPC64_DTPMOD64",    /* name */
1356          FALSE,                 /* partial_inplace */
1357          0,                     /* src_mask */
1358          ONES (64),             /* dst_mask */
1359          FALSE),                /* pcrel_offset */
1360
1361   /* Computes a dtv-relative displacement, the difference between the value
1362      of sym+add and the base address of the thread-local storage block that
1363      contains the definition of sym, minus 0x8000.  */
1364   HOWTO (R_PPC64_DTPREL64,
1365          0,                     /* rightshift */
1366          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1367          64,                    /* bitsize */
1368          FALSE,                 /* pc_relative */
1369          0,                     /* bitpos */
1370          complain_overflow_dont, /* complain_on_overflow */
1371          ppc64_elf_unhandled_reloc, /* special_function */
1372          "R_PPC64_DTPREL64",    /* name */
1373          FALSE,                 /* partial_inplace */
1374          0,                     /* src_mask */
1375          ONES (64),             /* dst_mask */
1376          FALSE),                /* pcrel_offset */
1377
1378   /* A 16 bit dtprel reloc.  */
1379   HOWTO (R_PPC64_DTPREL16,
1380          0,                     /* rightshift */
1381          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1382          16,                    /* bitsize */
1383          FALSE,                 /* pc_relative */
1384          0,                     /* bitpos */
1385          complain_overflow_signed, /* complain_on_overflow */
1386          ppc64_elf_unhandled_reloc, /* special_function */
1387          "R_PPC64_DTPREL16",    /* name */
1388          FALSE,                 /* partial_inplace */
1389          0,                     /* src_mask */
1390          0xffff,                /* dst_mask */
1391          FALSE),                /* pcrel_offset */
1392
1393   /* Like DTPREL16, but no overflow.  */
1394   HOWTO (R_PPC64_DTPREL16_LO,
1395          0,                     /* rightshift */
1396          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1397          16,                    /* bitsize */
1398          FALSE,                 /* pc_relative */
1399          0,                     /* bitpos */
1400          complain_overflow_dont, /* complain_on_overflow */
1401          ppc64_elf_unhandled_reloc, /* special_function */
1402          "R_PPC64_DTPREL16_LO", /* name */
1403          FALSE,                 /* partial_inplace */
1404          0,                     /* src_mask */
1405          0xffff,                /* dst_mask */
1406          FALSE),                /* pcrel_offset */
1407
1408   /* Like DTPREL16_LO, but next higher group of 16 bits.  */
1409   HOWTO (R_PPC64_DTPREL16_HI,
1410          16,                    /* rightshift */
1411          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1412          16,                    /* bitsize */
1413          FALSE,                 /* pc_relative */
1414          0,                     /* bitpos */
1415          complain_overflow_signed, /* complain_on_overflow */
1416          ppc64_elf_unhandled_reloc, /* special_function */
1417          "R_PPC64_DTPREL16_HI", /* name */
1418          FALSE,                 /* partial_inplace */
1419          0,                     /* src_mask */
1420          0xffff,                /* dst_mask */
1421          FALSE),                /* pcrel_offset */
1422
1423   /* Like DTPREL16_HI, but adjust for low 16 bits.  */
1424   HOWTO (R_PPC64_DTPREL16_HA,
1425          16,                    /* rightshift */
1426          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1427          16,                    /* bitsize */
1428          FALSE,                 /* pc_relative */
1429          0,                     /* bitpos */
1430          complain_overflow_signed, /* complain_on_overflow */
1431          ppc64_elf_unhandled_reloc, /* special_function */
1432          "R_PPC64_DTPREL16_HA", /* name */
1433          FALSE,                 /* partial_inplace */
1434          0,                     /* src_mask */
1435          0xffff,                /* dst_mask */
1436          FALSE),                /* pcrel_offset */
1437
1438   /* Like DTPREL16_HI, but next higher group of 16 bits.  */
1439   HOWTO (R_PPC64_DTPREL16_HIGHER,
1440          32,                    /* rightshift */
1441          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1442          16,                    /* bitsize */
1443          FALSE,                 /* pc_relative */
1444          0,                     /* bitpos */
1445          complain_overflow_dont, /* complain_on_overflow */
1446          ppc64_elf_unhandled_reloc, /* special_function */
1447          "R_PPC64_DTPREL16_HIGHER", /* name */
1448          FALSE,                 /* partial_inplace */
1449          0,                     /* src_mask */
1450          0xffff,                /* dst_mask */
1451          FALSE),                /* pcrel_offset */
1452
1453   /* Like DTPREL16_HIGHER, but adjust for low 16 bits.  */
1454   HOWTO (R_PPC64_DTPREL16_HIGHERA,
1455          32,                    /* rightshift */
1456          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1457          16,                    /* bitsize */
1458          FALSE,                 /* pc_relative */
1459          0,                     /* bitpos */
1460          complain_overflow_dont, /* complain_on_overflow */
1461          ppc64_elf_unhandled_reloc, /* special_function */
1462          "R_PPC64_DTPREL16_HIGHERA", /* name */
1463          FALSE,                 /* partial_inplace */
1464          0,                     /* src_mask */
1465          0xffff,                /* dst_mask */
1466          FALSE),                /* pcrel_offset */
1467
1468   /* Like DTPREL16_HIGHER, but next higher group of 16 bits.  */
1469   HOWTO (R_PPC64_DTPREL16_HIGHEST,
1470          48,                    /* rightshift */
1471          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1472          16,                    /* bitsize */
1473          FALSE,                 /* pc_relative */
1474          0,                     /* bitpos */
1475          complain_overflow_dont, /* complain_on_overflow */
1476          ppc64_elf_unhandled_reloc, /* special_function */
1477          "R_PPC64_DTPREL16_HIGHEST", /* name */
1478          FALSE,                 /* partial_inplace */
1479          0,                     /* src_mask */
1480          0xffff,                /* dst_mask */
1481          FALSE),                /* pcrel_offset */
1482
1483   /* Like DTPREL16_HIGHEST, but adjust for low 16 bits.  */
1484   HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1485          48,                    /* rightshift */
1486          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1487          16,                    /* bitsize */
1488          FALSE,                 /* pc_relative */
1489          0,                     /* bitpos */
1490          complain_overflow_dont, /* complain_on_overflow */
1491          ppc64_elf_unhandled_reloc, /* special_function */
1492          "R_PPC64_DTPREL16_HIGHESTA", /* name */
1493          FALSE,                 /* partial_inplace */
1494          0,                     /* src_mask */
1495          0xffff,                /* dst_mask */
1496          FALSE),                /* pcrel_offset */
1497
1498   /* Like DTPREL16, but for insns with a DS field.  */
1499   HOWTO (R_PPC64_DTPREL16_DS,
1500          0,                     /* rightshift */
1501          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1502          16,                    /* bitsize */
1503          FALSE,                 /* pc_relative */
1504          0,                     /* bitpos */
1505          complain_overflow_signed, /* complain_on_overflow */
1506          ppc64_elf_unhandled_reloc, /* special_function */
1507          "R_PPC64_DTPREL16_DS", /* name */
1508          FALSE,                 /* partial_inplace */
1509          0,                     /* src_mask */
1510          0xfffc,                /* dst_mask */
1511          FALSE),                /* pcrel_offset */
1512
1513   /* Like DTPREL16_DS, but no overflow.  */
1514   HOWTO (R_PPC64_DTPREL16_LO_DS,
1515          0,                     /* rightshift */
1516          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1517          16,                    /* bitsize */
1518          FALSE,                 /* pc_relative */
1519          0,                     /* bitpos */
1520          complain_overflow_dont, /* complain_on_overflow */
1521          ppc64_elf_unhandled_reloc, /* special_function */
1522          "R_PPC64_DTPREL16_LO_DS", /* name */
1523          FALSE,                 /* partial_inplace */
1524          0,                     /* src_mask */
1525          0xfffc,                /* dst_mask */
1526          FALSE),                /* pcrel_offset */
1527
1528   /* Computes a tp-relative displacement, the difference between the value of
1529      sym+add and the value of the thread pointer (r13).  */
1530   HOWTO (R_PPC64_TPREL64,
1531          0,                     /* rightshift */
1532          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1533          64,                    /* bitsize */
1534          FALSE,                 /* pc_relative */
1535          0,                     /* bitpos */
1536          complain_overflow_dont, /* complain_on_overflow */
1537          ppc64_elf_unhandled_reloc, /* special_function */
1538          "R_PPC64_TPREL64",     /* name */
1539          FALSE,                 /* partial_inplace */
1540          0,                     /* src_mask */
1541          ONES (64),             /* dst_mask */
1542          FALSE),                /* pcrel_offset */
1543
1544   /* A 16 bit tprel reloc.  */
1545   HOWTO (R_PPC64_TPREL16,
1546          0,                     /* rightshift */
1547          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1548          16,                    /* bitsize */
1549          FALSE,                 /* pc_relative */
1550          0,                     /* bitpos */
1551          complain_overflow_signed, /* complain_on_overflow */
1552          ppc64_elf_unhandled_reloc, /* special_function */
1553          "R_PPC64_TPREL16",     /* name */
1554          FALSE,                 /* partial_inplace */
1555          0,                     /* src_mask */
1556          0xffff,                /* dst_mask */
1557          FALSE),                /* pcrel_offset */
1558
1559   /* Like TPREL16, but no overflow.  */
1560   HOWTO (R_PPC64_TPREL16_LO,
1561          0,                     /* rightshift */
1562          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1563          16,                    /* bitsize */
1564          FALSE,                 /* pc_relative */
1565          0,                     /* bitpos */
1566          complain_overflow_dont, /* complain_on_overflow */
1567          ppc64_elf_unhandled_reloc, /* special_function */
1568          "R_PPC64_TPREL16_LO",  /* name */
1569          FALSE,                 /* partial_inplace */
1570          0,                     /* src_mask */
1571          0xffff,                /* dst_mask */
1572          FALSE),                /* pcrel_offset */
1573
1574   /* Like TPREL16_LO, but next higher group of 16 bits.  */
1575   HOWTO (R_PPC64_TPREL16_HI,
1576          16,                    /* rightshift */
1577          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1578          16,                    /* bitsize */
1579          FALSE,                 /* pc_relative */
1580          0,                     /* bitpos */
1581          complain_overflow_signed, /* complain_on_overflow */
1582          ppc64_elf_unhandled_reloc, /* special_function */
1583          "R_PPC64_TPREL16_HI",  /* name */
1584          FALSE,                 /* partial_inplace */
1585          0,                     /* src_mask */
1586          0xffff,                /* dst_mask */
1587          FALSE),                /* pcrel_offset */
1588
1589   /* Like TPREL16_HI, but adjust for low 16 bits.  */
1590   HOWTO (R_PPC64_TPREL16_HA,
1591          16,                    /* rightshift */
1592          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1593          16,                    /* bitsize */
1594          FALSE,                 /* pc_relative */
1595          0,                     /* bitpos */
1596          complain_overflow_signed, /* complain_on_overflow */
1597          ppc64_elf_unhandled_reloc, /* special_function */
1598          "R_PPC64_TPREL16_HA",  /* name */
1599          FALSE,                 /* partial_inplace */
1600          0,                     /* src_mask */
1601          0xffff,                /* dst_mask */
1602          FALSE),                /* pcrel_offset */
1603
1604   /* Like TPREL16_HI, but next higher group of 16 bits.  */
1605   HOWTO (R_PPC64_TPREL16_HIGHER,
1606          32,                    /* rightshift */
1607          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1608          16,                    /* bitsize */
1609          FALSE,                 /* pc_relative */
1610          0,                     /* bitpos */
1611          complain_overflow_dont, /* complain_on_overflow */
1612          ppc64_elf_unhandled_reloc, /* special_function */
1613          "R_PPC64_TPREL16_HIGHER",      /* name */
1614          FALSE,                 /* partial_inplace */
1615          0,                     /* src_mask */
1616          0xffff,                /* dst_mask */
1617          FALSE),                /* pcrel_offset */
1618
1619   /* Like TPREL16_HIGHER, but adjust for low 16 bits.  */
1620   HOWTO (R_PPC64_TPREL16_HIGHERA,
1621          32,                    /* rightshift */
1622          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1623          16,                    /* bitsize */
1624          FALSE,                 /* pc_relative */
1625          0,                     /* bitpos */
1626          complain_overflow_dont, /* complain_on_overflow */
1627          ppc64_elf_unhandled_reloc, /* special_function */
1628          "R_PPC64_TPREL16_HIGHERA", /* name */
1629          FALSE,                 /* partial_inplace */
1630          0,                     /* src_mask */
1631          0xffff,                /* dst_mask */
1632          FALSE),                /* pcrel_offset */
1633
1634   /* Like TPREL16_HIGHER, but next higher group of 16 bits.  */
1635   HOWTO (R_PPC64_TPREL16_HIGHEST,
1636          48,                    /* rightshift */
1637          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1638          16,                    /* bitsize */
1639          FALSE,                 /* pc_relative */
1640          0,                     /* bitpos */
1641          complain_overflow_dont, /* complain_on_overflow */
1642          ppc64_elf_unhandled_reloc, /* special_function */
1643          "R_PPC64_TPREL16_HIGHEST", /* name */
1644          FALSE,                 /* partial_inplace */
1645          0,                     /* src_mask */
1646          0xffff,                /* dst_mask */
1647          FALSE),                /* pcrel_offset */
1648
1649   /* Like TPREL16_HIGHEST, but adjust for low 16 bits.  */
1650   HOWTO (R_PPC64_TPREL16_HIGHESTA,
1651          48,                    /* rightshift */
1652          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1653          16,                    /* bitsize */
1654          FALSE,                 /* pc_relative */
1655          0,                     /* bitpos */
1656          complain_overflow_dont, /* complain_on_overflow */
1657          ppc64_elf_unhandled_reloc, /* special_function */
1658          "R_PPC64_TPREL16_HIGHESTA", /* name */
1659          FALSE,                 /* partial_inplace */
1660          0,                     /* src_mask */
1661          0xffff,                /* dst_mask */
1662          FALSE),                /* pcrel_offset */
1663
1664   /* Like TPREL16, but for insns with a DS field.  */
1665   HOWTO (R_PPC64_TPREL16_DS,
1666          0,                     /* rightshift */
1667          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1668          16,                    /* bitsize */
1669          FALSE,                 /* pc_relative */
1670          0,                     /* bitpos */
1671          complain_overflow_signed, /* complain_on_overflow */
1672          ppc64_elf_unhandled_reloc, /* special_function */
1673          "R_PPC64_TPREL16_DS",  /* name */
1674          FALSE,                 /* partial_inplace */
1675          0,                     /* src_mask */
1676          0xfffc,                /* dst_mask */
1677          FALSE),                /* pcrel_offset */
1678
1679   /* Like TPREL16_DS, but no overflow.  */
1680   HOWTO (R_PPC64_TPREL16_LO_DS,
1681          0,                     /* rightshift */
1682          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1683          16,                    /* bitsize */
1684          FALSE,                 /* pc_relative */
1685          0,                     /* bitpos */
1686          complain_overflow_dont, /* complain_on_overflow */
1687          ppc64_elf_unhandled_reloc, /* special_function */
1688          "R_PPC64_TPREL16_LO_DS", /* name */
1689          FALSE,                 /* partial_inplace */
1690          0,                     /* src_mask */
1691          0xfffc,                /* dst_mask */
1692          FALSE),                /* pcrel_offset */
1693
1694   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1695      with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1696      to the first entry relative to the TOC base (r2).  */
1697   HOWTO (R_PPC64_GOT_TLSGD16,
1698          0,                     /* rightshift */
1699          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1700          16,                    /* bitsize */
1701          FALSE,                 /* pc_relative */
1702          0,                     /* bitpos */
1703          complain_overflow_signed, /* complain_on_overflow */
1704          ppc64_elf_unhandled_reloc, /* special_function */
1705          "R_PPC64_GOT_TLSGD16", /* name */
1706          FALSE,                 /* partial_inplace */
1707          0,                     /* src_mask */
1708          0xffff,                /* dst_mask */
1709          FALSE),                /* pcrel_offset */
1710
1711   /* Like GOT_TLSGD16, but no overflow.  */
1712   HOWTO (R_PPC64_GOT_TLSGD16_LO,
1713          0,                     /* rightshift */
1714          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1715          16,                    /* bitsize */
1716          FALSE,                 /* pc_relative */
1717          0,                     /* bitpos */
1718          complain_overflow_dont, /* complain_on_overflow */
1719          ppc64_elf_unhandled_reloc, /* special_function */
1720          "R_PPC64_GOT_TLSGD16_LO", /* name */
1721          FALSE,                 /* partial_inplace */
1722          0,                     /* src_mask */
1723          0xffff,                /* dst_mask */
1724          FALSE),                /* pcrel_offset */
1725
1726   /* Like GOT_TLSGD16_LO, but next higher group of 16 bits.  */
1727   HOWTO (R_PPC64_GOT_TLSGD16_HI,
1728          16,                    /* rightshift */
1729          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1730          16,                    /* bitsize */
1731          FALSE,                 /* pc_relative */
1732          0,                     /* bitpos */
1733          complain_overflow_signed, /* complain_on_overflow */
1734          ppc64_elf_unhandled_reloc, /* special_function */
1735          "R_PPC64_GOT_TLSGD16_HI", /* name */
1736          FALSE,                 /* partial_inplace */
1737          0,                     /* src_mask */
1738          0xffff,                /* dst_mask */
1739          FALSE),                /* pcrel_offset */
1740
1741   /* Like GOT_TLSGD16_HI, but adjust for low 16 bits.  */
1742   HOWTO (R_PPC64_GOT_TLSGD16_HA,
1743          16,                    /* rightshift */
1744          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1745          16,                    /* bitsize */
1746          FALSE,                 /* pc_relative */
1747          0,                     /* bitpos */
1748          complain_overflow_signed, /* complain_on_overflow */
1749          ppc64_elf_unhandled_reloc, /* special_function */
1750          "R_PPC64_GOT_TLSGD16_HA", /* name */
1751          FALSE,                 /* partial_inplace */
1752          0,                     /* src_mask */
1753          0xffff,                /* dst_mask */
1754          FALSE),                /* pcrel_offset */
1755
1756   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1757      with values (sym+add)@dtpmod and zero, and computes the offset to the
1758      first entry relative to the TOC base (r2).  */
1759   HOWTO (R_PPC64_GOT_TLSLD16,
1760          0,                     /* rightshift */
1761          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1762          16,                    /* bitsize */
1763          FALSE,                 /* pc_relative */
1764          0,                     /* bitpos */
1765          complain_overflow_signed, /* complain_on_overflow */
1766          ppc64_elf_unhandled_reloc, /* special_function */
1767          "R_PPC64_GOT_TLSLD16", /* name */
1768          FALSE,                 /* partial_inplace */
1769          0,                     /* src_mask */
1770          0xffff,                /* dst_mask */
1771          FALSE),                /* pcrel_offset */
1772
1773   /* Like GOT_TLSLD16, but no overflow.  */
1774   HOWTO (R_PPC64_GOT_TLSLD16_LO,
1775          0,                     /* rightshift */
1776          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1777          16,                    /* bitsize */
1778          FALSE,                 /* pc_relative */
1779          0,                     /* bitpos */
1780          complain_overflow_dont, /* complain_on_overflow */
1781          ppc64_elf_unhandled_reloc, /* special_function */
1782          "R_PPC64_GOT_TLSLD16_LO", /* name */
1783          FALSE,                 /* partial_inplace */
1784          0,                     /* src_mask */
1785          0xffff,                /* dst_mask */
1786          FALSE),                /* pcrel_offset */
1787
1788   /* Like GOT_TLSLD16_LO, but next higher group of 16 bits.  */
1789   HOWTO (R_PPC64_GOT_TLSLD16_HI,
1790          16,                    /* rightshift */
1791          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1792          16,                    /* bitsize */
1793          FALSE,                 /* pc_relative */
1794          0,                     /* bitpos */
1795          complain_overflow_signed, /* complain_on_overflow */
1796          ppc64_elf_unhandled_reloc, /* special_function */
1797          "R_PPC64_GOT_TLSLD16_HI", /* name */
1798          FALSE,                 /* partial_inplace */
1799          0,                     /* src_mask */
1800          0xffff,                /* dst_mask */
1801          FALSE),                /* pcrel_offset */
1802
1803   /* Like GOT_TLSLD16_HI, but adjust for low 16 bits.  */
1804   HOWTO (R_PPC64_GOT_TLSLD16_HA,
1805          16,                    /* rightshift */
1806          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1807          16,                    /* bitsize */
1808          FALSE,                 /* pc_relative */
1809          0,                     /* bitpos */
1810          complain_overflow_signed, /* complain_on_overflow */
1811          ppc64_elf_unhandled_reloc, /* special_function */
1812          "R_PPC64_GOT_TLSLD16_HA", /* name */
1813          FALSE,                 /* partial_inplace */
1814          0,                     /* src_mask */
1815          0xffff,                /* dst_mask */
1816          FALSE),                /* pcrel_offset */
1817
1818   /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1819      the offset to the entry relative to the TOC base (r2).  */
1820   HOWTO (R_PPC64_GOT_DTPREL16_DS,
1821          0,                     /* rightshift */
1822          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1823          16,                    /* bitsize */
1824          FALSE,                 /* pc_relative */
1825          0,                     /* bitpos */
1826          complain_overflow_signed, /* complain_on_overflow */
1827          ppc64_elf_unhandled_reloc, /* special_function */
1828          "R_PPC64_GOT_DTPREL16_DS", /* name */
1829          FALSE,                 /* partial_inplace */
1830          0,                     /* src_mask */
1831          0xfffc,                /* dst_mask */
1832          FALSE),                /* pcrel_offset */
1833
1834   /* Like GOT_DTPREL16_DS, but no overflow.  */
1835   HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1836          0,                     /* rightshift */
1837          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1838          16,                    /* bitsize */
1839          FALSE,                 /* pc_relative */
1840          0,                     /* bitpos */
1841          complain_overflow_dont, /* complain_on_overflow */
1842          ppc64_elf_unhandled_reloc, /* special_function */
1843          "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1844          FALSE,                 /* partial_inplace */
1845          0,                     /* src_mask */
1846          0xfffc,                /* dst_mask */
1847          FALSE),                /* pcrel_offset */
1848
1849   /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits.  */
1850   HOWTO (R_PPC64_GOT_DTPREL16_HI,
1851          16,                    /* rightshift */
1852          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1853          16,                    /* bitsize */
1854          FALSE,                 /* pc_relative */
1855          0,                     /* bitpos */
1856          complain_overflow_signed, /* complain_on_overflow */
1857          ppc64_elf_unhandled_reloc, /* special_function */
1858          "R_PPC64_GOT_DTPREL16_HI", /* name */
1859          FALSE,                 /* partial_inplace */
1860          0,                     /* src_mask */
1861          0xffff,                /* dst_mask */
1862          FALSE),                /* pcrel_offset */
1863
1864   /* Like GOT_DTPREL16_HI, but adjust for low 16 bits.  */
1865   HOWTO (R_PPC64_GOT_DTPREL16_HA,
1866          16,                    /* rightshift */
1867          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1868          16,                    /* bitsize */
1869          FALSE,                 /* pc_relative */
1870          0,                     /* bitpos */
1871          complain_overflow_signed, /* complain_on_overflow */
1872          ppc64_elf_unhandled_reloc, /* special_function */
1873          "R_PPC64_GOT_DTPREL16_HA", /* name */
1874          FALSE,                 /* partial_inplace */
1875          0,                     /* src_mask */
1876          0xffff,                /* dst_mask */
1877          FALSE),                /* pcrel_offset */
1878
1879   /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1880      offset to the entry relative to the TOC base (r2).  */
1881   HOWTO (R_PPC64_GOT_TPREL16_DS,
1882          0,                     /* rightshift */
1883          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1884          16,                    /* bitsize */
1885          FALSE,                 /* pc_relative */
1886          0,                     /* bitpos */
1887          complain_overflow_signed, /* complain_on_overflow */
1888          ppc64_elf_unhandled_reloc, /* special_function */
1889          "R_PPC64_GOT_TPREL16_DS", /* name */
1890          FALSE,                 /* partial_inplace */
1891          0,                     /* src_mask */
1892          0xfffc,                /* dst_mask */
1893          FALSE),                /* pcrel_offset */
1894
1895   /* Like GOT_TPREL16_DS, but no overflow.  */
1896   HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1897          0,                     /* rightshift */
1898          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1899          16,                    /* bitsize */
1900          FALSE,                 /* pc_relative */
1901          0,                     /* bitpos */
1902          complain_overflow_dont, /* complain_on_overflow */
1903          ppc64_elf_unhandled_reloc, /* special_function */
1904          "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1905          FALSE,                 /* partial_inplace */
1906          0,                     /* src_mask */
1907          0xfffc,                /* dst_mask */
1908          FALSE),                /* pcrel_offset */
1909
1910   /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits.  */
1911   HOWTO (R_PPC64_GOT_TPREL16_HI,
1912          16,                    /* rightshift */
1913          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1914          16,                    /* bitsize */
1915          FALSE,                 /* pc_relative */
1916          0,                     /* bitpos */
1917          complain_overflow_signed, /* complain_on_overflow */
1918          ppc64_elf_unhandled_reloc, /* special_function */
1919          "R_PPC64_GOT_TPREL16_HI", /* name */
1920          FALSE,                 /* partial_inplace */
1921          0,                     /* src_mask */
1922          0xffff,                /* dst_mask */
1923          FALSE),                /* pcrel_offset */
1924
1925   /* Like GOT_TPREL16_HI, but adjust for low 16 bits.  */
1926   HOWTO (R_PPC64_GOT_TPREL16_HA,
1927          16,                    /* rightshift */
1928          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1929          16,                    /* bitsize */
1930          FALSE,                 /* pc_relative */
1931          0,                     /* bitpos */
1932          complain_overflow_signed, /* complain_on_overflow */
1933          ppc64_elf_unhandled_reloc, /* special_function */
1934          "R_PPC64_GOT_TPREL16_HA", /* name */
1935          FALSE,                 /* partial_inplace */
1936          0,                     /* src_mask */
1937          0xffff,                /* dst_mask */
1938          FALSE),                /* pcrel_offset */
1939
1940   HOWTO (R_PPC64_JMP_IREL,      /* type */
1941          0,                     /* rightshift */
1942          0,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1943          0,                     /* bitsize */
1944          FALSE,                 /* pc_relative */
1945          0,                     /* bitpos */
1946          complain_overflow_dont, /* complain_on_overflow */
1947          ppc64_elf_unhandled_reloc, /* special_function */
1948          "R_PPC64_JMP_IREL",    /* name */
1949          FALSE,                 /* partial_inplace */
1950          0,                     /* src_mask */
1951          0,                     /* dst_mask */
1952          FALSE),                /* pcrel_offset */
1953
1954   HOWTO (R_PPC64_IRELATIVE,     /* type */
1955          0,                     /* rightshift */
1956          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1957          64,                    /* bitsize */
1958          FALSE,                 /* pc_relative */
1959          0,                     /* bitpos */
1960          complain_overflow_dont, /* complain_on_overflow */
1961          bfd_elf_generic_reloc, /* special_function */
1962          "R_PPC64_IRELATIVE",   /* name */
1963          FALSE,                 /* partial_inplace */
1964          0,                     /* src_mask */
1965          ONES (64),             /* dst_mask */
1966          FALSE),                /* pcrel_offset */
1967
1968   /* A 16 bit relative relocation.  */
1969   HOWTO (R_PPC64_REL16,         /* type */
1970          0,                     /* rightshift */
1971          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1972          16,                    /* bitsize */
1973          TRUE,                  /* pc_relative */
1974          0,                     /* bitpos */
1975          complain_overflow_signed, /* complain_on_overflow */
1976          bfd_elf_generic_reloc, /* special_function */
1977          "R_PPC64_REL16",       /* name */
1978          FALSE,                 /* partial_inplace */
1979          0,                     /* src_mask */
1980          0xffff,                /* dst_mask */
1981          TRUE),                 /* pcrel_offset */
1982
1983   /* A 16 bit relative relocation without overflow.  */
1984   HOWTO (R_PPC64_REL16_LO,      /* type */
1985          0,                     /* rightshift */
1986          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1987          16,                    /* bitsize */
1988          TRUE,                  /* pc_relative */
1989          0,                     /* bitpos */
1990          complain_overflow_dont,/* complain_on_overflow */
1991          bfd_elf_generic_reloc, /* special_function */
1992          "R_PPC64_REL16_LO",    /* name */
1993          FALSE,                 /* partial_inplace */
1994          0,                     /* src_mask */
1995          0xffff,                /* dst_mask */
1996          TRUE),                 /* pcrel_offset */
1997
1998   /* The high order 16 bits of a relative address.  */
1999   HOWTO (R_PPC64_REL16_HI,      /* type */
2000          16,                    /* rightshift */
2001          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2002          16,                    /* bitsize */
2003          TRUE,                  /* pc_relative */
2004          0,                     /* bitpos */
2005          complain_overflow_signed, /* complain_on_overflow */
2006          bfd_elf_generic_reloc, /* special_function */
2007          "R_PPC64_REL16_HI",    /* name */
2008          FALSE,                 /* partial_inplace */
2009          0,                     /* src_mask */
2010          0xffff,                /* dst_mask */
2011          TRUE),                 /* pcrel_offset */
2012
2013   /* The high order 16 bits of a relative address, plus 1 if the contents of
2014      the low 16 bits, treated as a signed number, is negative.  */
2015   HOWTO (R_PPC64_REL16_HA,      /* type */
2016          16,                    /* rightshift */
2017          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2018          16,                    /* bitsize */
2019          TRUE,                  /* pc_relative */
2020          0,                     /* bitpos */
2021          complain_overflow_signed, /* complain_on_overflow */
2022          ppc64_elf_ha_reloc,    /* special_function */
2023          "R_PPC64_REL16_HA",    /* name */
2024          FALSE,                 /* partial_inplace */
2025          0,                     /* src_mask */
2026          0xffff,                /* dst_mask */
2027          TRUE),                 /* pcrel_offset */
2028
2029   /* Like R_PPC64_REL16_HA but for split field in addpcis.  */
2030   HOWTO (R_PPC64_REL16DX_HA,    /* type */
2031          16,                    /* rightshift */
2032          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2033          16,                    /* bitsize */
2034          TRUE,                  /* pc_relative */
2035          0,                     /* bitpos */
2036          complain_overflow_signed, /* complain_on_overflow */
2037          ppc64_elf_ha_reloc,    /* special_function */
2038          "R_PPC64_REL16DX_HA",  /* name */
2039          FALSE,                 /* partial_inplace */
2040          0,                     /* src_mask */
2041          0x1fffc1,              /* dst_mask */
2042          TRUE),                 /* pcrel_offset */
2043
2044   /* Like R_PPC64_ADDR16_HI, but no overflow.  */
2045   HOWTO (R_PPC64_ADDR16_HIGH,   /* type */
2046          16,                    /* rightshift */
2047          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2048          16,                    /* bitsize */
2049          FALSE,                 /* pc_relative */
2050          0,                     /* bitpos */
2051          complain_overflow_dont, /* complain_on_overflow */
2052          bfd_elf_generic_reloc, /* special_function */
2053          "R_PPC64_ADDR16_HIGH", /* name */
2054          FALSE,                 /* partial_inplace */
2055          0,                     /* src_mask */
2056          0xffff,                /* dst_mask */
2057          FALSE),                /* pcrel_offset */
2058
2059   /* Like R_PPC64_ADDR16_HA, but no overflow.  */
2060   HOWTO (R_PPC64_ADDR16_HIGHA,  /* type */
2061          16,                    /* rightshift */
2062          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2063          16,                    /* bitsize */
2064          FALSE,                 /* pc_relative */
2065          0,                     /* bitpos */
2066          complain_overflow_dont, /* complain_on_overflow */
2067          ppc64_elf_ha_reloc,    /* special_function */
2068          "R_PPC64_ADDR16_HIGHA",        /* name */
2069          FALSE,                 /* partial_inplace */
2070          0,                     /* src_mask */
2071          0xffff,                /* dst_mask */
2072          FALSE),                /* pcrel_offset */
2073
2074   /* Like R_PPC64_DTPREL16_HI, but no overflow.  */
2075   HOWTO (R_PPC64_DTPREL16_HIGH,
2076          16,                    /* rightshift */
2077          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2078          16,                    /* bitsize */
2079          FALSE,                 /* pc_relative */
2080          0,                     /* bitpos */
2081          complain_overflow_dont, /* complain_on_overflow */
2082          ppc64_elf_unhandled_reloc, /* special_function */
2083          "R_PPC64_DTPREL16_HIGH", /* name */
2084          FALSE,                 /* partial_inplace */
2085          0,                     /* src_mask */
2086          0xffff,                /* dst_mask */
2087          FALSE),                /* pcrel_offset */
2088
2089   /* Like R_PPC64_DTPREL16_HA, but no overflow.  */
2090   HOWTO (R_PPC64_DTPREL16_HIGHA,
2091          16,                    /* rightshift */
2092          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2093          16,                    /* bitsize */
2094          FALSE,                 /* pc_relative */
2095          0,                     /* bitpos */
2096          complain_overflow_dont, /* complain_on_overflow */
2097          ppc64_elf_unhandled_reloc, /* special_function */
2098          "R_PPC64_DTPREL16_HIGHA", /* name */
2099          FALSE,                 /* partial_inplace */
2100          0,                     /* src_mask */
2101          0xffff,                /* dst_mask */
2102          FALSE),                /* pcrel_offset */
2103
2104   /* Like R_PPC64_TPREL16_HI, but no overflow.  */
2105   HOWTO (R_PPC64_TPREL16_HIGH,
2106          16,                    /* rightshift */
2107          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2108          16,                    /* bitsize */
2109          FALSE,                 /* pc_relative */
2110          0,                     /* bitpos */
2111          complain_overflow_dont, /* complain_on_overflow */
2112          ppc64_elf_unhandled_reloc, /* special_function */
2113          "R_PPC64_TPREL16_HIGH",        /* name */
2114          FALSE,                 /* partial_inplace */
2115          0,                     /* src_mask */
2116          0xffff,                /* dst_mask */
2117          FALSE),                /* pcrel_offset */
2118
2119   /* Like R_PPC64_TPREL16_HA, but no overflow.  */
2120   HOWTO (R_PPC64_TPREL16_HIGHA,
2121          16,                    /* rightshift */
2122          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2123          16,                    /* bitsize */
2124          FALSE,                 /* pc_relative */
2125          0,                     /* bitpos */
2126          complain_overflow_dont, /* complain_on_overflow */
2127          ppc64_elf_unhandled_reloc, /* special_function */
2128          "R_PPC64_TPREL16_HIGHA",       /* name */
2129          FALSE,                 /* partial_inplace */
2130          0,                     /* src_mask */
2131          0xffff,                /* dst_mask */
2132          FALSE),                /* pcrel_offset */
2133
2134   /* Marker reloc on ELFv2 large-model function entry.  */
2135   HOWTO (R_PPC64_ENTRY,
2136          0,                     /* rightshift */
2137          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2138          32,                    /* bitsize */
2139          FALSE,                 /* pc_relative */
2140          0,                     /* bitpos */
2141          complain_overflow_dont, /* complain_on_overflow */
2142          bfd_elf_generic_reloc, /* special_function */
2143          "R_PPC64_ENTRY",       /* name */
2144          FALSE,                 /* partial_inplace */
2145          0,                     /* src_mask */
2146          0,                     /* dst_mask */
2147          FALSE),                /* pcrel_offset */
2148
2149   /* Like ADDR64, but use local entry point of function.  */
2150   HOWTO (R_PPC64_ADDR64_LOCAL,  /* type */
2151          0,                     /* rightshift */
2152          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2153          64,                    /* bitsize */
2154          FALSE,                 /* pc_relative */
2155          0,                     /* bitpos */
2156          complain_overflow_dont, /* complain_on_overflow */
2157          bfd_elf_generic_reloc, /* special_function */
2158          "R_PPC64_ADDR64_LOCAL", /* name */
2159          FALSE,                 /* partial_inplace */
2160          0,                     /* src_mask */
2161          ONES (64),             /* dst_mask */
2162          FALSE),                /* pcrel_offset */
2163
2164   /* GNU extension to record C++ vtable hierarchy.  */
2165   HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2166          0,                     /* rightshift */
2167          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2168          0,                     /* bitsize */
2169          FALSE,                 /* pc_relative */
2170          0,                     /* bitpos */
2171          complain_overflow_dont, /* complain_on_overflow */
2172          NULL,                  /* special_function */
2173          "R_PPC64_GNU_VTINHERIT", /* name */
2174          FALSE,                 /* partial_inplace */
2175          0,                     /* src_mask */
2176          0,                     /* dst_mask */
2177          FALSE),                /* pcrel_offset */
2178
2179   /* GNU extension to record C++ vtable member usage.  */
2180   HOWTO (R_PPC64_GNU_VTENTRY,   /* type */
2181          0,                     /* rightshift */
2182          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2183          0,                     /* bitsize */
2184          FALSE,                 /* pc_relative */
2185          0,                     /* bitpos */
2186          complain_overflow_dont, /* complain_on_overflow */
2187          NULL,                  /* special_function */
2188          "R_PPC64_GNU_VTENTRY", /* name */
2189          FALSE,                 /* partial_inplace */
2190          0,                     /* src_mask */
2191          0,                     /* dst_mask */
2192          FALSE),                /* pcrel_offset */
2193 };
2194
2195 \f
2196 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2197    be done.  */
2198
2199 static void
2200 ppc_howto_init (void)
2201 {
2202   unsigned int i, type;
2203
2204   for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2205     {
2206       type = ppc64_elf_howto_raw[i].type;
2207       BFD_ASSERT (type < ARRAY_SIZE (ppc64_elf_howto_table));
2208       ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2209     }
2210 }
2211
2212 static reloc_howto_type *
2213 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2214                              bfd_reloc_code_real_type code)
2215 {
2216   enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2217
2218   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2219     /* Initialize howto table if needed.  */
2220     ppc_howto_init ();
2221
2222   switch (code)
2223     {
2224     default:
2225       return NULL;
2226
2227     case BFD_RELOC_NONE:                        r = R_PPC64_NONE;
2228       break;
2229     case BFD_RELOC_32:                          r = R_PPC64_ADDR32;
2230       break;
2231     case BFD_RELOC_PPC_BA26:                    r = R_PPC64_ADDR24;
2232       break;
2233     case BFD_RELOC_16:                          r = R_PPC64_ADDR16;
2234       break;
2235     case BFD_RELOC_LO16:                        r = R_PPC64_ADDR16_LO;
2236       break;
2237     case BFD_RELOC_HI16:                        r = R_PPC64_ADDR16_HI;
2238       break;
2239     case BFD_RELOC_PPC64_ADDR16_HIGH:           r = R_PPC64_ADDR16_HIGH;
2240       break;
2241     case BFD_RELOC_HI16_S:                      r = R_PPC64_ADDR16_HA;
2242       break;
2243     case BFD_RELOC_PPC64_ADDR16_HIGHA:          r = R_PPC64_ADDR16_HIGHA;
2244       break;
2245     case BFD_RELOC_PPC_BA16:                    r = R_PPC64_ADDR14;
2246       break;
2247     case BFD_RELOC_PPC_BA16_BRTAKEN:            r = R_PPC64_ADDR14_BRTAKEN;
2248       break;
2249     case BFD_RELOC_PPC_BA16_BRNTAKEN:           r = R_PPC64_ADDR14_BRNTAKEN;
2250       break;
2251     case BFD_RELOC_PPC_B26:                     r = R_PPC64_REL24;
2252       break;
2253     case BFD_RELOC_PPC_B16:                     r = R_PPC64_REL14;
2254       break;
2255     case BFD_RELOC_PPC_B16_BRTAKEN:             r = R_PPC64_REL14_BRTAKEN;
2256       break;
2257     case BFD_RELOC_PPC_B16_BRNTAKEN:            r = R_PPC64_REL14_BRNTAKEN;
2258       break;
2259     case BFD_RELOC_16_GOTOFF:                   r = R_PPC64_GOT16;
2260       break;
2261     case BFD_RELOC_LO16_GOTOFF:                 r = R_PPC64_GOT16_LO;
2262       break;
2263     case BFD_RELOC_HI16_GOTOFF:                 r = R_PPC64_GOT16_HI;
2264       break;
2265     case BFD_RELOC_HI16_S_GOTOFF:               r = R_PPC64_GOT16_HA;
2266       break;
2267     case BFD_RELOC_PPC_COPY:                    r = R_PPC64_COPY;
2268       break;
2269     case BFD_RELOC_PPC_GLOB_DAT:                r = R_PPC64_GLOB_DAT;
2270       break;
2271     case BFD_RELOC_32_PCREL:                    r = R_PPC64_REL32;
2272       break;
2273     case BFD_RELOC_32_PLTOFF:                   r = R_PPC64_PLT32;
2274       break;
2275     case BFD_RELOC_32_PLT_PCREL:                r = R_PPC64_PLTREL32;
2276       break;
2277     case BFD_RELOC_LO16_PLTOFF:                 r = R_PPC64_PLT16_LO;
2278       break;
2279     case BFD_RELOC_HI16_PLTOFF:                 r = R_PPC64_PLT16_HI;
2280       break;
2281     case BFD_RELOC_HI16_S_PLTOFF:               r = R_PPC64_PLT16_HA;
2282       break;
2283     case BFD_RELOC_16_BASEREL:                  r = R_PPC64_SECTOFF;
2284       break;
2285     case BFD_RELOC_LO16_BASEREL:                r = R_PPC64_SECTOFF_LO;
2286       break;
2287     case BFD_RELOC_HI16_BASEREL:                r = R_PPC64_SECTOFF_HI;
2288       break;
2289     case BFD_RELOC_HI16_S_BASEREL:              r = R_PPC64_SECTOFF_HA;
2290       break;
2291     case BFD_RELOC_CTOR:                        r = R_PPC64_ADDR64;
2292       break;
2293     case BFD_RELOC_64:                          r = R_PPC64_ADDR64;
2294       break;
2295     case BFD_RELOC_PPC64_HIGHER:                r = R_PPC64_ADDR16_HIGHER;
2296       break;
2297     case BFD_RELOC_PPC64_HIGHER_S:              r = R_PPC64_ADDR16_HIGHERA;
2298       break;
2299     case BFD_RELOC_PPC64_HIGHEST:               r = R_PPC64_ADDR16_HIGHEST;
2300       break;
2301     case BFD_RELOC_PPC64_HIGHEST_S:             r = R_PPC64_ADDR16_HIGHESTA;
2302       break;
2303     case BFD_RELOC_64_PCREL:                    r = R_PPC64_REL64;
2304       break;
2305     case BFD_RELOC_64_PLTOFF:                   r = R_PPC64_PLT64;
2306       break;
2307     case BFD_RELOC_64_PLT_PCREL:                r = R_PPC64_PLTREL64;
2308       break;
2309     case BFD_RELOC_PPC_TOC16:                   r = R_PPC64_TOC16;
2310       break;
2311     case BFD_RELOC_PPC64_TOC16_LO:              r = R_PPC64_TOC16_LO;
2312       break;
2313     case BFD_RELOC_PPC64_TOC16_HI:              r = R_PPC64_TOC16_HI;
2314       break;
2315     case BFD_RELOC_PPC64_TOC16_HA:              r = R_PPC64_TOC16_HA;
2316       break;
2317     case BFD_RELOC_PPC64_TOC:                   r = R_PPC64_TOC;
2318       break;
2319     case BFD_RELOC_PPC64_PLTGOT16:              r = R_PPC64_PLTGOT16;
2320       break;
2321     case BFD_RELOC_PPC64_PLTGOT16_LO:           r = R_PPC64_PLTGOT16_LO;
2322       break;
2323     case BFD_RELOC_PPC64_PLTGOT16_HI:           r = R_PPC64_PLTGOT16_HI;
2324       break;
2325     case BFD_RELOC_PPC64_PLTGOT16_HA:           r = R_PPC64_PLTGOT16_HA;
2326       break;
2327     case BFD_RELOC_PPC64_ADDR16_DS:             r = R_PPC64_ADDR16_DS;
2328       break;
2329     case BFD_RELOC_PPC64_ADDR16_LO_DS:          r = R_PPC64_ADDR16_LO_DS;
2330       break;
2331     case BFD_RELOC_PPC64_GOT16_DS:              r = R_PPC64_GOT16_DS;
2332       break;
2333     case BFD_RELOC_PPC64_GOT16_LO_DS:           r = R_PPC64_GOT16_LO_DS;
2334       break;
2335     case BFD_RELOC_PPC64_PLT16_LO_DS:           r = R_PPC64_PLT16_LO_DS;
2336       break;
2337     case BFD_RELOC_PPC64_SECTOFF_DS:            r = R_PPC64_SECTOFF_DS;
2338       break;
2339     case BFD_RELOC_PPC64_SECTOFF_LO_DS:         r = R_PPC64_SECTOFF_LO_DS;
2340       break;
2341     case BFD_RELOC_PPC64_TOC16_DS:              r = R_PPC64_TOC16_DS;
2342       break;
2343     case BFD_RELOC_PPC64_TOC16_LO_DS:           r = R_PPC64_TOC16_LO_DS;
2344       break;
2345     case BFD_RELOC_PPC64_PLTGOT16_DS:           r = R_PPC64_PLTGOT16_DS;
2346       break;
2347     case BFD_RELOC_PPC64_PLTGOT16_LO_DS:        r = R_PPC64_PLTGOT16_LO_DS;
2348       break;
2349     case BFD_RELOC_PPC_TLS:                     r = R_PPC64_TLS;
2350       break;
2351     case BFD_RELOC_PPC_TLSGD:                   r = R_PPC64_TLSGD;
2352       break;
2353     case BFD_RELOC_PPC_TLSLD:                   r = R_PPC64_TLSLD;
2354       break;
2355     case BFD_RELOC_PPC_DTPMOD:                  r = R_PPC64_DTPMOD64;
2356       break;
2357     case BFD_RELOC_PPC_TPREL16:                 r = R_PPC64_TPREL16;
2358       break;
2359     case BFD_RELOC_PPC_TPREL16_LO:              r = R_PPC64_TPREL16_LO;
2360       break;
2361     case BFD_RELOC_PPC_TPREL16_HI:              r = R_PPC64_TPREL16_HI;
2362       break;
2363     case BFD_RELOC_PPC64_TPREL16_HIGH:          r = R_PPC64_TPREL16_HIGH;
2364       break;
2365     case BFD_RELOC_PPC_TPREL16_HA:              r = R_PPC64_TPREL16_HA;
2366       break;
2367     case BFD_RELOC_PPC64_TPREL16_HIGHA:         r = R_PPC64_TPREL16_HIGHA;
2368       break;
2369     case BFD_RELOC_PPC_TPREL:                   r = R_PPC64_TPREL64;
2370       break;
2371     case BFD_RELOC_PPC_DTPREL16:                r = R_PPC64_DTPREL16;
2372       break;
2373     case BFD_RELOC_PPC_DTPREL16_LO:             r = R_PPC64_DTPREL16_LO;
2374       break;
2375     case BFD_RELOC_PPC_DTPREL16_HI:             r = R_PPC64_DTPREL16_HI;
2376       break;
2377     case BFD_RELOC_PPC64_DTPREL16_HIGH:         r = R_PPC64_DTPREL16_HIGH;
2378       break;
2379     case BFD_RELOC_PPC_DTPREL16_HA:             r = R_PPC64_DTPREL16_HA;
2380       break;
2381     case BFD_RELOC_PPC64_DTPREL16_HIGHA:        r = R_PPC64_DTPREL16_HIGHA;
2382       break;
2383     case BFD_RELOC_PPC_DTPREL:                  r = R_PPC64_DTPREL64;
2384       break;
2385     case BFD_RELOC_PPC_GOT_TLSGD16:             r = R_PPC64_GOT_TLSGD16;
2386       break;
2387     case BFD_RELOC_PPC_GOT_TLSGD16_LO:          r = R_PPC64_GOT_TLSGD16_LO;
2388       break;
2389     case BFD_RELOC_PPC_GOT_TLSGD16_HI:          r = R_PPC64_GOT_TLSGD16_HI;
2390       break;
2391     case BFD_RELOC_PPC_GOT_TLSGD16_HA:          r = R_PPC64_GOT_TLSGD16_HA;
2392       break;
2393     case BFD_RELOC_PPC_GOT_TLSLD16:             r = R_PPC64_GOT_TLSLD16;
2394       break;
2395     case BFD_RELOC_PPC_GOT_TLSLD16_LO:          r = R_PPC64_GOT_TLSLD16_LO;
2396       break;
2397     case BFD_RELOC_PPC_GOT_TLSLD16_HI:          r = R_PPC64_GOT_TLSLD16_HI;
2398       break;
2399     case BFD_RELOC_PPC_GOT_TLSLD16_HA:          r = R_PPC64_GOT_TLSLD16_HA;
2400       break;
2401     case BFD_RELOC_PPC_GOT_TPREL16:             r = R_PPC64_GOT_TPREL16_DS;
2402       break;
2403     case BFD_RELOC_PPC_GOT_TPREL16_LO:          r = R_PPC64_GOT_TPREL16_LO_DS;
2404       break;
2405     case BFD_RELOC_PPC_GOT_TPREL16_HI:          r = R_PPC64_GOT_TPREL16_HI;
2406       break;
2407     case BFD_RELOC_PPC_GOT_TPREL16_HA:          r = R_PPC64_GOT_TPREL16_HA;
2408       break;
2409     case BFD_RELOC_PPC_GOT_DTPREL16:            r = R_PPC64_GOT_DTPREL16_DS;
2410       break;
2411     case BFD_RELOC_PPC_GOT_DTPREL16_LO:         r = R_PPC64_GOT_DTPREL16_LO_DS;
2412       break;
2413     case BFD_RELOC_PPC_GOT_DTPREL16_HI:         r = R_PPC64_GOT_DTPREL16_HI;
2414       break;
2415     case BFD_RELOC_PPC_GOT_DTPREL16_HA:         r = R_PPC64_GOT_DTPREL16_HA;
2416       break;
2417     case BFD_RELOC_PPC64_TPREL16_DS:            r = R_PPC64_TPREL16_DS;
2418       break;
2419     case BFD_RELOC_PPC64_TPREL16_LO_DS:         r = R_PPC64_TPREL16_LO_DS;
2420       break;
2421     case BFD_RELOC_PPC64_TPREL16_HIGHER:        r = R_PPC64_TPREL16_HIGHER;
2422       break;
2423     case BFD_RELOC_PPC64_TPREL16_HIGHERA:       r = R_PPC64_TPREL16_HIGHERA;
2424       break;
2425     case BFD_RELOC_PPC64_TPREL16_HIGHEST:       r = R_PPC64_TPREL16_HIGHEST;
2426       break;
2427     case BFD_RELOC_PPC64_TPREL16_HIGHESTA:      r = R_PPC64_TPREL16_HIGHESTA;
2428       break;
2429     case BFD_RELOC_PPC64_DTPREL16_DS:           r = R_PPC64_DTPREL16_DS;
2430       break;
2431     case BFD_RELOC_PPC64_DTPREL16_LO_DS:        r = R_PPC64_DTPREL16_LO_DS;
2432       break;
2433     case BFD_RELOC_PPC64_DTPREL16_HIGHER:       r = R_PPC64_DTPREL16_HIGHER;
2434       break;
2435     case BFD_RELOC_PPC64_DTPREL16_HIGHERA:      r = R_PPC64_DTPREL16_HIGHERA;
2436       break;
2437     case BFD_RELOC_PPC64_DTPREL16_HIGHEST:      r = R_PPC64_DTPREL16_HIGHEST;
2438       break;
2439     case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:     r = R_PPC64_DTPREL16_HIGHESTA;
2440       break;
2441     case BFD_RELOC_16_PCREL:                    r = R_PPC64_REL16;
2442       break;
2443     case BFD_RELOC_LO16_PCREL:                  r = R_PPC64_REL16_LO;
2444       break;
2445     case BFD_RELOC_HI16_PCREL:                  r = R_PPC64_REL16_HI;
2446       break;
2447     case BFD_RELOC_HI16_S_PCREL:                r = R_PPC64_REL16_HA;
2448       break;
2449     case BFD_RELOC_PPC_REL16DX_HA:              r = R_PPC64_REL16DX_HA;
2450       break;
2451     case BFD_RELOC_PPC64_ENTRY:                 r = R_PPC64_ENTRY;
2452       break;
2453     case BFD_RELOC_PPC64_ADDR64_LOCAL:          r = R_PPC64_ADDR64_LOCAL;
2454       break;
2455     case BFD_RELOC_VTABLE_INHERIT:              r = R_PPC64_GNU_VTINHERIT;
2456       break;
2457     case BFD_RELOC_VTABLE_ENTRY:                r = R_PPC64_GNU_VTENTRY;
2458       break;
2459     }
2460
2461   return ppc64_elf_howto_table[r];
2462 };
2463
2464 static reloc_howto_type *
2465 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2466                              const char *r_name)
2467 {
2468   unsigned int i;
2469
2470   for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2471     if (ppc64_elf_howto_raw[i].name != NULL
2472         && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2473       return &ppc64_elf_howto_raw[i];
2474
2475   return NULL;
2476 }
2477
2478 /* Set the howto pointer for a PowerPC ELF reloc.  */
2479
2480 static void
2481 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2482                          Elf_Internal_Rela *dst)
2483 {
2484   unsigned int type;
2485
2486   /* Initialize howto table if needed.  */
2487   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2488     ppc_howto_init ();
2489
2490   type = ELF64_R_TYPE (dst->r_info);
2491   if (type >= ARRAY_SIZE (ppc64_elf_howto_table))
2492     {
2493       _bfd_error_handler (_("%B: invalid relocation type %d"),
2494                           abfd, (int) type);
2495       type = R_PPC64_NONE;
2496     }
2497   cache_ptr->howto = ppc64_elf_howto_table[type];
2498 }
2499
2500 /* Handle the R_PPC64_ADDR16_HA and similar relocs.  */
2501
2502 static bfd_reloc_status_type
2503 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2504                     void *data, asection *input_section,
2505                     bfd *output_bfd, char **error_message)
2506 {
2507   enum elf_ppc64_reloc_type r_type;
2508   long insn;
2509   bfd_size_type octets;
2510   bfd_vma value;
2511
2512   /* If this is a relocatable link (output_bfd test tells us), just
2513      call the generic function.  Any adjustment will be done at final
2514      link time.  */
2515   if (output_bfd != NULL)
2516     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2517                                   input_section, output_bfd, error_message);
2518
2519   /* Adjust the addend for sign extension of the low 16 bits.
2520      We won't actually be using the low 16 bits, so trashing them
2521      doesn't matter.  */
2522   reloc_entry->addend += 0x8000;
2523   r_type = reloc_entry->howto->type;
2524   if (r_type != R_PPC64_REL16DX_HA)
2525     return bfd_reloc_continue;
2526
2527   value = 0;
2528   if (!bfd_is_com_section (symbol->section))
2529     value = symbol->value;
2530   value += (reloc_entry->addend
2531             + symbol->section->output_offset
2532             + symbol->section->output_section->vma);
2533   value -= (reloc_entry->address
2534             + input_section->output_offset
2535             + input_section->output_section->vma);
2536   value = (bfd_signed_vma) value >> 16;
2537
2538   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2539   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2540   insn &= ~0x1fffc1;
2541   insn |= (value & 0xffc1) | ((value & 0x3e) << 15);
2542   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2543   if (value + 0x8000 > 0xffff)
2544     return bfd_reloc_overflow;
2545   return bfd_reloc_ok;
2546 }
2547
2548 static bfd_reloc_status_type
2549 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2550                         void *data, asection *input_section,
2551                         bfd *output_bfd, char **error_message)
2552 {
2553   if (output_bfd != NULL)
2554     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2555                                   input_section, output_bfd, error_message);
2556
2557   if (strcmp (symbol->section->name, ".opd") == 0
2558       && (symbol->section->owner->flags & DYNAMIC) == 0)
2559     {
2560       bfd_vma dest = opd_entry_value (symbol->section,
2561                                       symbol->value + reloc_entry->addend,
2562                                       NULL, NULL, FALSE);
2563       if (dest != (bfd_vma) -1)
2564         reloc_entry->addend = dest - (symbol->value
2565                                       + symbol->section->output_section->vma
2566                                       + symbol->section->output_offset);
2567     }
2568   else
2569     {
2570       elf_symbol_type *elfsym = (elf_symbol_type *) symbol;
2571
2572       if (symbol->section->owner != abfd
2573           && symbol->section->owner != NULL
2574           && abiversion (symbol->section->owner) >= 2)
2575         {
2576           unsigned int i;
2577
2578           for (i = 0; i < symbol->section->owner->symcount; ++i)
2579             {
2580               asymbol *symdef = symbol->section->owner->outsymbols[i];
2581
2582               if (strcmp (symdef->name, symbol->name) == 0)
2583                 {
2584                   elfsym = (elf_symbol_type *) symdef;
2585                   break;
2586                 }
2587             }
2588         }
2589       reloc_entry->addend
2590         += PPC64_LOCAL_ENTRY_OFFSET (elfsym->internal_elf_sym.st_other);
2591     }
2592   return bfd_reloc_continue;
2593 }
2594
2595 static bfd_reloc_status_type
2596 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2597                          void *data, asection *input_section,
2598                          bfd *output_bfd, char **error_message)
2599 {
2600   long insn;
2601   enum elf_ppc64_reloc_type r_type;
2602   bfd_size_type octets;
2603   /* Assume 'at' branch hints.  */
2604   bfd_boolean is_isa_v2 = TRUE;
2605
2606   /* If this is a relocatable link (output_bfd test tells us), just
2607      call the generic function.  Any adjustment will be done at final
2608      link time.  */
2609   if (output_bfd != NULL)
2610     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2611                                   input_section, output_bfd, error_message);
2612
2613   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2614   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2615   insn &= ~(0x01 << 21);
2616   r_type = reloc_entry->howto->type;
2617   if (r_type == R_PPC64_ADDR14_BRTAKEN
2618       || r_type == R_PPC64_REL14_BRTAKEN)
2619     insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
2620
2621   if (is_isa_v2)
2622     {
2623       /* Set 'a' bit.  This is 0b00010 in BO field for branch
2624          on CR(BI) insns (BO == 001at or 011at), and 0b01000
2625          for branch on CTR insns (BO == 1a00t or 1a01t).  */
2626       if ((insn & (0x14 << 21)) == (0x04 << 21))
2627         insn |= 0x02 << 21;
2628       else if ((insn & (0x14 << 21)) == (0x10 << 21))
2629         insn |= 0x08 << 21;
2630       else
2631         goto out;
2632     }
2633   else
2634     {
2635       bfd_vma target = 0;
2636       bfd_vma from;
2637
2638       if (!bfd_is_com_section (symbol->section))
2639         target = symbol->value;
2640       target += symbol->section->output_section->vma;
2641       target += symbol->section->output_offset;
2642       target += reloc_entry->addend;
2643
2644       from = (reloc_entry->address
2645               + input_section->output_offset
2646               + input_section->output_section->vma);
2647
2648       /* Invert 'y' bit if not the default.  */
2649       if ((bfd_signed_vma) (target - from) < 0)
2650         insn ^= 0x01 << 21;
2651     }
2652   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2653  out:
2654   return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2655                                  input_section, output_bfd, error_message);
2656 }
2657
2658 static bfd_reloc_status_type
2659 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2660                          void *data, asection *input_section,
2661                          bfd *output_bfd, char **error_message)
2662 {
2663   /* If this is a relocatable link (output_bfd test tells us), just
2664      call the generic function.  Any adjustment will be done at final
2665      link time.  */
2666   if (output_bfd != NULL)
2667     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2668                                   input_section, output_bfd, error_message);
2669
2670   /* Subtract the symbol section base address.  */
2671   reloc_entry->addend -= symbol->section->output_section->vma;
2672   return bfd_reloc_continue;
2673 }
2674
2675 static bfd_reloc_status_type
2676 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2677                             void *data, asection *input_section,
2678                             bfd *output_bfd, char **error_message)
2679 {
2680   /* If this is a relocatable link (output_bfd test tells us), just
2681      call the generic function.  Any adjustment will be done at final
2682      link time.  */
2683   if (output_bfd != NULL)
2684     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2685                                   input_section, output_bfd, error_message);
2686
2687   /* Subtract the symbol section base address.  */
2688   reloc_entry->addend -= symbol->section->output_section->vma;
2689
2690   /* Adjust the addend for sign extension of the low 16 bits.  */
2691   reloc_entry->addend += 0x8000;
2692   return bfd_reloc_continue;
2693 }
2694
2695 static bfd_reloc_status_type
2696 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2697                      void *data, asection *input_section,
2698                      bfd *output_bfd, char **error_message)
2699 {
2700   bfd_vma TOCstart;
2701
2702   /* If this is a relocatable link (output_bfd test tells us), just
2703      call the generic function.  Any adjustment will be done at final
2704      link time.  */
2705   if (output_bfd != NULL)
2706     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2707                                   input_section, output_bfd, error_message);
2708
2709   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2710   if (TOCstart == 0)
2711     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2712
2713   /* Subtract the TOC base address.  */
2714   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2715   return bfd_reloc_continue;
2716 }
2717
2718 static bfd_reloc_status_type
2719 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2720                         void *data, asection *input_section,
2721                         bfd *output_bfd, char **error_message)
2722 {
2723   bfd_vma TOCstart;
2724
2725   /* If this is a relocatable link (output_bfd test tells us), just
2726      call the generic function.  Any adjustment will be done at final
2727      link time.  */
2728   if (output_bfd != NULL)
2729     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2730                                   input_section, output_bfd, error_message);
2731
2732   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2733   if (TOCstart == 0)
2734     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2735
2736   /* Subtract the TOC base address.  */
2737   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2738
2739   /* Adjust the addend for sign extension of the low 16 bits.  */
2740   reloc_entry->addend += 0x8000;
2741   return bfd_reloc_continue;
2742 }
2743
2744 static bfd_reloc_status_type
2745 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2746                        void *data, asection *input_section,
2747                        bfd *output_bfd, char **error_message)
2748 {
2749   bfd_vma TOCstart;
2750   bfd_size_type octets;
2751
2752   /* If this is a relocatable link (output_bfd test tells us), just
2753      call the generic function.  Any adjustment will be done at final
2754      link time.  */
2755   if (output_bfd != NULL)
2756     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2757                                   input_section, output_bfd, error_message);
2758
2759   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2760   if (TOCstart == 0)
2761     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2762
2763   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2764   bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2765   return bfd_reloc_ok;
2766 }
2767
2768 static bfd_reloc_status_type
2769 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2770                            void *data, asection *input_section,
2771                            bfd *output_bfd, char **error_message)
2772 {
2773   /* If this is a relocatable link (output_bfd test tells us), just
2774      call the generic function.  Any adjustment will be done at final
2775      link time.  */
2776   if (output_bfd != NULL)
2777     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2778                                   input_section, output_bfd, error_message);
2779
2780   if (error_message != NULL)
2781     {
2782       static char buf[60];
2783       sprintf (buf, "generic linker can't handle %s",
2784                reloc_entry->howto->name);
2785       *error_message = buf;
2786     }
2787   return bfd_reloc_dangerous;
2788 }
2789
2790 /* Track GOT entries needed for a given symbol.  We might need more
2791    than one got entry per symbol.  */
2792 struct got_entry
2793 {
2794   struct got_entry *next;
2795
2796   /* The symbol addend that we'll be placing in the GOT.  */
2797   bfd_vma addend;
2798
2799   /* Unlike other ELF targets, we use separate GOT entries for the same
2800      symbol referenced from different input files.  This is to support
2801      automatic multiple TOC/GOT sections, where the TOC base can vary
2802      from one input file to another.  After partitioning into TOC groups
2803      we merge entries within the group.
2804
2805      Point to the BFD owning this GOT entry.  */
2806   bfd *owner;
2807
2808   /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2809      TLS_TPREL or TLS_DTPREL for tls entries.  */
2810   unsigned char tls_type;
2811
2812   /* Non-zero if got.ent points to real entry.  */
2813   unsigned char is_indirect;
2814
2815   /* Reference count until size_dynamic_sections, GOT offset thereafter.  */
2816   union
2817     {
2818       bfd_signed_vma refcount;
2819       bfd_vma offset;
2820       struct got_entry *ent;
2821     } got;
2822 };
2823
2824 /* The same for PLT.  */
2825 struct plt_entry
2826 {
2827   struct plt_entry *next;
2828
2829   bfd_vma addend;
2830
2831   union
2832     {
2833       bfd_signed_vma refcount;
2834       bfd_vma offset;
2835     } plt;
2836 };
2837
2838 struct ppc64_elf_obj_tdata
2839 {
2840   struct elf_obj_tdata elf;
2841
2842   /* Shortcuts to dynamic linker sections.  */
2843   asection *got;
2844   asection *relgot;
2845
2846   /* Used during garbage collection.  We attach global symbols defined
2847      on removed .opd entries to this section so that the sym is removed.  */
2848   asection *deleted_section;
2849
2850   /* TLS local dynamic got entry handling.  Support for multiple GOT
2851      sections means we potentially need one of these for each input bfd.  */
2852   struct got_entry tlsld_got;
2853
2854   union {
2855     /* A copy of relocs before they are modified for --emit-relocs.  */
2856     Elf_Internal_Rela *relocs;
2857
2858     /* Section contents.  */
2859     bfd_byte *contents;
2860   } opd;
2861
2862   /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2863      the reloc to be in the range -32768 to 32767.  */
2864   unsigned int has_small_toc_reloc : 1;
2865
2866   /* Set if toc/got ha relocs detected not using r2, or lo reloc
2867      instruction not one we handle.  */
2868   unsigned int unexpected_toc_insn : 1;
2869 };
2870
2871 #define ppc64_elf_tdata(bfd) \
2872   ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2873
2874 #define ppc64_tlsld_got(bfd) \
2875   (&ppc64_elf_tdata (bfd)->tlsld_got)
2876
2877 #define is_ppc64_elf(bfd) \
2878   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2879    && elf_object_id (bfd) == PPC64_ELF_DATA)
2880
2881 /* Override the generic function because we store some extras.  */
2882
2883 static bfd_boolean
2884 ppc64_elf_mkobject (bfd *abfd)
2885 {
2886   return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2887                                   PPC64_ELF_DATA);
2888 }
2889
2890 /* Fix bad default arch selected for a 64 bit input bfd when the
2891    default is 32 bit.  Also select arch based on apuinfo.  */
2892
2893 static bfd_boolean
2894 ppc64_elf_object_p (bfd *abfd)
2895 {
2896   if (!abfd->arch_info->the_default)
2897     return TRUE;
2898
2899   if (abfd->arch_info->bits_per_word == 32)
2900     {
2901       Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2902
2903       if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2904         {
2905           /* Relies on arch after 32 bit default being 64 bit default.  */
2906           abfd->arch_info = abfd->arch_info->next;
2907           BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2908         }
2909     }
2910   return _bfd_elf_ppc_set_arch (abfd);
2911 }
2912
2913 /* Support for core dump NOTE sections.  */
2914
2915 static bfd_boolean
2916 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2917 {
2918   size_t offset, size;
2919
2920   if (note->descsz != 504)
2921     return FALSE;
2922
2923   /* pr_cursig */
2924   elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2925
2926   /* pr_pid */
2927   elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2928
2929   /* pr_reg */
2930   offset = 112;
2931   size = 384;
2932
2933   /* Make a ".reg/999" section.  */
2934   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2935                                           size, note->descpos + offset);
2936 }
2937
2938 static bfd_boolean
2939 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2940 {
2941   if (note->descsz != 136)
2942     return FALSE;
2943
2944   elf_tdata (abfd)->core->pid
2945     = bfd_get_32 (abfd, note->descdata + 24);
2946   elf_tdata (abfd)->core->program
2947     = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2948   elf_tdata (abfd)->core->command
2949     = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2950
2951   return TRUE;
2952 }
2953
2954 static char *
2955 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2956                            ...)
2957 {
2958   switch (note_type)
2959     {
2960     default:
2961       return NULL;
2962
2963     case NT_PRPSINFO:
2964       {
2965         char data[136];
2966         va_list ap;
2967
2968         va_start (ap, note_type);
2969         memset (data, 0, sizeof (data));
2970         strncpy (data + 40, va_arg (ap, const char *), 16);
2971         strncpy (data + 56, va_arg (ap, const char *), 80);
2972         va_end (ap);
2973         return elfcore_write_note (abfd, buf, bufsiz,
2974                                    "CORE", note_type, data, sizeof (data));
2975       }
2976
2977     case NT_PRSTATUS:
2978       {
2979         char data[504];
2980         va_list ap;
2981         long pid;
2982         int cursig;
2983         const void *greg;
2984
2985         va_start (ap, note_type);
2986         memset (data, 0, 112);
2987         pid = va_arg (ap, long);
2988         bfd_put_32 (abfd, pid, data + 32);
2989         cursig = va_arg (ap, int);
2990         bfd_put_16 (abfd, cursig, data + 12);
2991         greg = va_arg (ap, const void *);
2992         memcpy (data + 112, greg, 384);
2993         memset (data + 496, 0, 8);
2994         va_end (ap);
2995         return elfcore_write_note (abfd, buf, bufsiz,
2996                                    "CORE", note_type, data, sizeof (data));
2997       }
2998     }
2999 }
3000
3001 /* Add extra PPC sections.  */
3002
3003 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
3004 {
3005   { STRING_COMMA_LEN (".plt"),    0, SHT_NOBITS,   0 },
3006   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
3007   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3008   { STRING_COMMA_LEN (".toc"),    0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3009   { STRING_COMMA_LEN (".toc1"),   0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3010   { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
3011   { NULL,                     0,  0, 0,            0 }
3012 };
3013
3014 enum _ppc64_sec_type {
3015   sec_normal = 0,
3016   sec_opd = 1,
3017   sec_toc = 2
3018 };
3019
3020 struct _ppc64_elf_section_data
3021 {
3022   struct bfd_elf_section_data elf;
3023
3024   union
3025   {
3026     /* An array with one entry for each opd function descriptor,
3027        and some spares since opd entries may be either 16 or 24 bytes.  */
3028 #define OPD_NDX(OFF) ((OFF) >> 4)
3029     struct _opd_sec_data
3030     {
3031       /* Points to the function code section for local opd entries.  */
3032       asection **func_sec;
3033
3034       /* After editing .opd, adjust references to opd local syms.  */
3035       long *adjust;
3036     } opd;
3037
3038     /* An array for toc sections, indexed by offset/8.  */
3039     struct _toc_sec_data
3040     {
3041       /* Specifies the relocation symbol index used at a given toc offset.  */
3042       unsigned *symndx;
3043
3044       /* And the relocation addend.  */
3045       bfd_vma *add;
3046     } toc;
3047   } u;
3048
3049   enum _ppc64_sec_type sec_type:2;
3050
3051   /* Flag set when small branches are detected.  Used to
3052      select suitable defaults for the stub group size.  */
3053   unsigned int has_14bit_branch:1;
3054 };
3055
3056 #define ppc64_elf_section_data(sec) \
3057   ((struct _ppc64_elf_section_data *) elf_section_data (sec))
3058
3059 static bfd_boolean
3060 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
3061 {
3062   if (!sec->used_by_bfd)
3063     {
3064       struct _ppc64_elf_section_data *sdata;
3065       bfd_size_type amt = sizeof (*sdata);
3066
3067       sdata = bfd_zalloc (abfd, amt);
3068       if (sdata == NULL)
3069         return FALSE;
3070       sec->used_by_bfd = sdata;
3071     }
3072
3073   return _bfd_elf_new_section_hook (abfd, sec);
3074 }
3075
3076 static struct _opd_sec_data *
3077 get_opd_info (asection * sec)
3078 {
3079   if (sec != NULL
3080       && ppc64_elf_section_data (sec) != NULL
3081       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
3082     return &ppc64_elf_section_data (sec)->u.opd;
3083   return NULL;
3084 }
3085 \f
3086 /* Parameters for the qsort hook.  */
3087 static bfd_boolean synthetic_relocatable;
3088 static asection *synthetic_opd;
3089
3090 /* qsort comparison function for ppc64_elf_get_synthetic_symtab.  */
3091
3092 static int
3093 compare_symbols (const void *ap, const void *bp)
3094 {
3095   const asymbol *a = * (const asymbol **) ap;
3096   const asymbol *b = * (const asymbol **) bp;
3097
3098   /* Section symbols first.  */
3099   if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
3100     return -1;
3101   if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
3102     return 1;
3103
3104   /* then .opd symbols.  */
3105   if (synthetic_opd != NULL)
3106     {
3107       if (strcmp (a->section->name, ".opd") == 0
3108           && strcmp (b->section->name, ".opd") != 0)
3109         return -1;
3110       if (strcmp (a->section->name, ".opd") != 0
3111           && strcmp (b->section->name, ".opd") == 0)
3112         return 1;
3113     }
3114
3115   /* then other code symbols.  */
3116   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3117       == (SEC_CODE | SEC_ALLOC)
3118       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3119          != (SEC_CODE | SEC_ALLOC))
3120     return -1;
3121
3122   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3123       != (SEC_CODE | SEC_ALLOC)
3124       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3125          == (SEC_CODE | SEC_ALLOC))
3126     return 1;
3127
3128   if (synthetic_relocatable)
3129     {
3130       if (a->section->id < b->section->id)
3131         return -1;
3132
3133       if (a->section->id > b->section->id)
3134         return 1;
3135     }
3136
3137   if (a->value + a->section->vma < b->value + b->section->vma)
3138     return -1;
3139
3140   if (a->value + a->section->vma > b->value + b->section->vma)
3141     return 1;
3142
3143   /* For syms with the same value, prefer strong dynamic global function
3144      syms over other syms.  */
3145   if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3146     return -1;
3147
3148   if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3149     return 1;
3150
3151   if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3152     return -1;
3153
3154   if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3155     return 1;
3156
3157   if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3158     return -1;
3159
3160   if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3161     return 1;
3162
3163   if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3164     return -1;
3165
3166   if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3167     return 1;
3168
3169   return 0;
3170 }
3171
3172 /* Search SYMS for a symbol of the given VALUE.  */
3173
3174 static asymbol *
3175 sym_exists_at (asymbol **syms, long lo, long hi, unsigned int id, bfd_vma value)
3176 {
3177   long mid;
3178
3179   if (id == (unsigned) -1)
3180     {
3181       while (lo < hi)
3182         {
3183           mid = (lo + hi) >> 1;
3184           if (syms[mid]->value + syms[mid]->section->vma < value)
3185             lo = mid + 1;
3186           else if (syms[mid]->value + syms[mid]->section->vma > value)
3187             hi = mid;
3188           else
3189             return syms[mid];
3190         }
3191     }
3192   else
3193     {
3194       while (lo < hi)
3195         {
3196           mid = (lo + hi) >> 1;
3197           if (syms[mid]->section->id < id)
3198             lo = mid + 1;
3199           else if (syms[mid]->section->id > id)
3200             hi = mid;
3201           else if (syms[mid]->value < value)
3202             lo = mid + 1;
3203           else if (syms[mid]->value > value)
3204             hi = mid;
3205           else
3206             return syms[mid];
3207         }
3208     }
3209   return NULL;
3210 }
3211
3212 static bfd_boolean
3213 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3214 {
3215   bfd_vma vma = *(bfd_vma *) ptr;
3216   return ((section->flags & SEC_ALLOC) != 0
3217           && section->vma <= vma
3218           && vma < section->vma + section->size);
3219 }
3220
3221 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3222    entry syms.  Also generate @plt symbols for the glink branch table.
3223    Returns count of synthetic symbols in RET or -1 on error.  */
3224
3225 static long
3226 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3227                                 long static_count, asymbol **static_syms,
3228                                 long dyn_count, asymbol **dyn_syms,
3229                                 asymbol **ret)
3230 {
3231   asymbol *s;
3232   long i;
3233   long count;
3234   char *names;
3235   long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3236   asection *opd = NULL;
3237   bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3238   asymbol **syms;
3239   int abi = abiversion (abfd);
3240
3241   *ret = NULL;
3242
3243   if (abi < 2)
3244     {
3245       opd = bfd_get_section_by_name (abfd, ".opd");
3246       if (opd == NULL && abi == 1)
3247         return 0;
3248     }
3249
3250   symcount = static_count;
3251   if (!relocatable)
3252     symcount += dyn_count;
3253   if (symcount == 0)
3254     return 0;
3255
3256   syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3257   if (syms == NULL)
3258     return -1;
3259
3260   if (!relocatable && static_count != 0 && dyn_count != 0)
3261     {
3262       /* Use both symbol tables.  */
3263       memcpy (syms, static_syms, static_count * sizeof (*syms));
3264       memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3265     }
3266   else if (!relocatable && static_count == 0)
3267     memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3268   else
3269     memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3270
3271   synthetic_relocatable = relocatable;
3272   synthetic_opd = opd;
3273   qsort (syms, symcount, sizeof (*syms), compare_symbols);
3274
3275   if (!relocatable && symcount > 1)
3276     {
3277       long j;
3278       /* Trim duplicate syms, since we may have merged the normal and
3279          dynamic symbols.  Actually, we only care about syms that have
3280          different values, so trim any with the same value.  */
3281       for (i = 1, j = 1; i < symcount; ++i)
3282         if (syms[i - 1]->value + syms[i - 1]->section->vma
3283             != syms[i]->value + syms[i]->section->vma)
3284           syms[j++] = syms[i];
3285       symcount = j;
3286     }
3287
3288   i = 0;
3289   /* Note that here and in compare_symbols we can't compare opd and
3290      sym->section directly.  With separate debug info files, the
3291      symbols will be extracted from the debug file while abfd passed
3292      to this function is the real binary.  */
3293   if (opd != NULL && strcmp (syms[i]->section->name, ".opd") == 0)
3294     ++i;
3295   codesecsym = i;
3296
3297   for (; i < symcount; ++i)
3298     if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3299          != (SEC_CODE | SEC_ALLOC))
3300         || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3301       break;
3302   codesecsymend = i;
3303
3304   for (; i < symcount; ++i)
3305     if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3306       break;
3307   secsymend = i;
3308
3309   if (opd != NULL)
3310     for (; i < symcount; ++i)
3311       if (strcmp (syms[i]->section->name, ".opd") != 0)
3312         break;
3313   opdsymend = i;
3314
3315   for (; i < symcount; ++i)
3316     if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3317         != (SEC_CODE | SEC_ALLOC))
3318       break;
3319   symcount = i;
3320
3321   count = 0;
3322
3323   if (relocatable)
3324     {
3325       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3326       arelent *r;
3327       size_t size;
3328       long relcount;
3329
3330       if (opdsymend == secsymend)
3331         goto done;
3332
3333       slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3334       relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3335       if (relcount == 0)
3336         goto done;
3337
3338       if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3339         {
3340           count = -1;
3341           goto done;
3342         }
3343
3344       size = 0;
3345       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3346         {
3347           asymbol *sym;
3348
3349           while (r < opd->relocation + relcount
3350                  && r->address < syms[i]->value + opd->vma)
3351             ++r;
3352
3353           if (r == opd->relocation + relcount)
3354             break;
3355
3356           if (r->address != syms[i]->value + opd->vma)
3357             continue;
3358
3359           if (r->howto->type != R_PPC64_ADDR64)
3360             continue;
3361
3362           sym = *r->sym_ptr_ptr;
3363           if (!sym_exists_at (syms, opdsymend, symcount,
3364                               sym->section->id, sym->value + r->addend))
3365             {
3366               ++count;
3367               size += sizeof (asymbol);
3368               size += strlen (syms[i]->name) + 2;
3369             }
3370         }
3371
3372       if (size == 0)
3373         goto done;
3374       s = *ret = bfd_malloc (size);
3375       if (s == NULL)
3376         {
3377           count = -1;
3378           goto done;
3379         }
3380
3381       names = (char *) (s + count);
3382
3383       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3384         {
3385           asymbol *sym;
3386
3387           while (r < opd->relocation + relcount
3388                  && r->address < syms[i]->value + opd->vma)
3389             ++r;
3390
3391           if (r == opd->relocation + relcount)
3392             break;
3393
3394           if (r->address != syms[i]->value + opd->vma)
3395             continue;
3396
3397           if (r->howto->type != R_PPC64_ADDR64)
3398             continue;
3399
3400           sym = *r->sym_ptr_ptr;
3401           if (!sym_exists_at (syms, opdsymend, symcount,
3402                               sym->section->id, sym->value + r->addend))
3403             {
3404               size_t len;
3405
3406               *s = *syms[i];
3407               s->flags |= BSF_SYNTHETIC;
3408               s->section = sym->section;
3409               s->value = sym->value + r->addend;
3410               s->name = names;
3411               *names++ = '.';
3412               len = strlen (syms[i]->name);
3413               memcpy (names, syms[i]->name, len + 1);
3414               names += len + 1;
3415               /* Have udata.p point back to the original symbol this
3416                  synthetic symbol was derived from.  */
3417               s->udata.p = syms[i];
3418               s++;
3419             }
3420         }
3421     }
3422   else
3423     {
3424       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3425       bfd_byte *contents = NULL;
3426       size_t size;
3427       long plt_count = 0;
3428       bfd_vma glink_vma = 0, resolv_vma = 0;
3429       asection *dynamic, *glink = NULL, *relplt = NULL;
3430       arelent *p;
3431
3432       if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3433         {
3434         free_contents_and_exit_err:
3435           count = -1;
3436         free_contents_and_exit:
3437           if (contents)
3438             free (contents);
3439           goto done;
3440         }
3441
3442       size = 0;
3443       for (i = secsymend; i < opdsymend; ++i)
3444         {
3445           bfd_vma ent;
3446
3447           /* Ignore bogus symbols.  */
3448           if (syms[i]->value > opd->size - 8)
3449             continue;
3450
3451           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3452           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3453             {
3454               ++count;
3455               size += sizeof (asymbol);
3456               size += strlen (syms[i]->name) + 2;
3457             }
3458         }
3459
3460       /* Get start of .glink stubs from DT_PPC64_GLINK.  */
3461       if (dyn_count != 0
3462           && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3463         {
3464           bfd_byte *dynbuf, *extdyn, *extdynend;
3465           size_t extdynsize;
3466           void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3467
3468           if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3469             goto free_contents_and_exit_err;
3470
3471           extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3472           swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3473
3474           extdyn = dynbuf;
3475           extdynend = extdyn + dynamic->size;
3476           for (; extdyn < extdynend; extdyn += extdynsize)
3477             {
3478               Elf_Internal_Dyn dyn;
3479               (*swap_dyn_in) (abfd, extdyn, &dyn);
3480
3481               if (dyn.d_tag == DT_NULL)
3482                 break;
3483
3484               if (dyn.d_tag == DT_PPC64_GLINK)
3485                 {
3486                   /* The first glink stub starts at offset 32; see
3487                      comment in ppc64_elf_finish_dynamic_sections. */
3488                   glink_vma = dyn.d_un.d_val + GLINK_CALL_STUB_SIZE - 8 * 4;
3489                   /* The .glink section usually does not survive the final
3490                      link; search for the section (usually .text) where the
3491                      glink stubs now reside.  */
3492                   glink = bfd_sections_find_if (abfd, section_covers_vma,
3493                                                 &glink_vma);
3494                   break;
3495                 }
3496             }
3497
3498           free (dynbuf);
3499         }
3500
3501       if (glink != NULL)
3502         {
3503           /* Determine __glink trampoline by reading the relative branch
3504              from the first glink stub.  */
3505           bfd_byte buf[4];
3506           unsigned int off = 0;
3507
3508           while (bfd_get_section_contents (abfd, glink, buf,
3509                                            glink_vma + off - glink->vma, 4))
3510             {
3511               unsigned int insn = bfd_get_32 (abfd, buf);
3512               insn ^= B_DOT;
3513               if ((insn & ~0x3fffffc) == 0)
3514                 {
3515                   resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3516                   break;
3517                 }
3518               off += 4;
3519               if (off > 4)
3520                 break;
3521             }
3522
3523           if (resolv_vma)
3524             size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3525
3526           relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3527           if (relplt != NULL)
3528             {
3529               slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3530               if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3531                 goto free_contents_and_exit_err;
3532
3533               plt_count = relplt->size / sizeof (Elf64_External_Rela);
3534               size += plt_count * sizeof (asymbol);
3535
3536               p = relplt->relocation;
3537               for (i = 0; i < plt_count; i++, p++)
3538                 {
3539                   size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3540                   if (p->addend != 0)
3541                     size += sizeof ("+0x") - 1 + 16;
3542                 }
3543             }
3544         }
3545
3546       if (size == 0)
3547         goto free_contents_and_exit;
3548       s = *ret = bfd_malloc (size);
3549       if (s == NULL)
3550         goto free_contents_and_exit_err;
3551
3552       names = (char *) (s + count + plt_count + (resolv_vma != 0));
3553
3554       for (i = secsymend; i < opdsymend; ++i)
3555         {
3556           bfd_vma ent;
3557
3558           if (syms[i]->value > opd->size - 8)
3559             continue;
3560
3561           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3562           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3563             {
3564               long lo, hi;
3565               size_t len;
3566               asection *sec = abfd->sections;
3567
3568               *s = *syms[i];
3569               lo = codesecsym;
3570               hi = codesecsymend;
3571               while (lo < hi)
3572                 {
3573                   long mid = (lo + hi) >> 1;
3574                   if (syms[mid]->section->vma < ent)
3575                     lo = mid + 1;
3576                   else if (syms[mid]->section->vma > ent)
3577                     hi = mid;
3578                   else
3579                     {
3580                       sec = syms[mid]->section;
3581                       break;
3582                     }
3583                 }
3584
3585               if (lo >= hi && lo > codesecsym)
3586                 sec = syms[lo - 1]->section;
3587
3588               for (; sec != NULL; sec = sec->next)
3589                 {
3590                   if (sec->vma > ent)
3591                     break;
3592                   /* SEC_LOAD may not be set if SEC is from a separate debug
3593                      info file.  */
3594                   if ((sec->flags & SEC_ALLOC) == 0)
3595                     break;
3596                   if ((sec->flags & SEC_CODE) != 0)
3597                     s->section = sec;
3598                 }
3599               s->flags |= BSF_SYNTHETIC;
3600               s->value = ent - s->section->vma;
3601               s->name = names;
3602               *names++ = '.';
3603               len = strlen (syms[i]->name);
3604               memcpy (names, syms[i]->name, len + 1);
3605               names += len + 1;
3606               /* Have udata.p point back to the original symbol this
3607                  synthetic symbol was derived from.  */
3608               s->udata.p = syms[i];
3609               s++;
3610             }
3611         }
3612       free (contents);
3613
3614       if (glink != NULL && relplt != NULL)
3615         {
3616           if (resolv_vma)
3617             {
3618               /* Add a symbol for the main glink trampoline.  */
3619               memset (s, 0, sizeof *s);
3620               s->the_bfd = abfd;
3621               s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3622               s->section = glink;
3623               s->value = resolv_vma - glink->vma;
3624               s->name = names;
3625               memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3626               names += sizeof ("__glink_PLTresolve");
3627               s++;
3628               count++;
3629             }
3630
3631           /* FIXME: It would be very much nicer to put sym@plt on the
3632              stub rather than on the glink branch table entry.  The
3633              objdump disassembler would then use a sensible symbol
3634              name on plt calls.  The difficulty in doing so is
3635              a) finding the stubs, and,
3636              b) matching stubs against plt entries, and,
3637              c) there can be multiple stubs for a given plt entry.
3638
3639              Solving (a) could be done by code scanning, but older
3640              ppc64 binaries used different stubs to current code.
3641              (b) is the tricky one since you need to known the toc
3642              pointer for at least one function that uses a pic stub to
3643              be able to calculate the plt address referenced.
3644              (c) means gdb would need to set multiple breakpoints (or
3645              find the glink branch itself) when setting breakpoints
3646              for pending shared library loads.  */
3647           p = relplt->relocation;
3648           for (i = 0; i < plt_count; i++, p++)
3649             {
3650               size_t len;
3651
3652               *s = **p->sym_ptr_ptr;
3653               /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
3654                  we are defining a symbol, ensure one of them is set.  */
3655               if ((s->flags & BSF_LOCAL) == 0)
3656                 s->flags |= BSF_GLOBAL;
3657               s->flags |= BSF_SYNTHETIC;
3658               s->section = glink;
3659               s->value = glink_vma - glink->vma;
3660               s->name = names;
3661               s->udata.p = NULL;
3662               len = strlen ((*p->sym_ptr_ptr)->name);
3663               memcpy (names, (*p->sym_ptr_ptr)->name, len);
3664               names += len;
3665               if (p->addend != 0)
3666                 {
3667                   memcpy (names, "+0x", sizeof ("+0x") - 1);
3668                   names += sizeof ("+0x") - 1;
3669                   bfd_sprintf_vma (abfd, names, p->addend);
3670                   names += strlen (names);
3671                 }
3672               memcpy (names, "@plt", sizeof ("@plt"));
3673               names += sizeof ("@plt");
3674               s++;
3675               if (abi < 2)
3676                 {
3677                   glink_vma += 8;
3678                   if (i >= 0x8000)
3679                     glink_vma += 4;
3680                 }
3681               else
3682                 glink_vma += 4;
3683             }
3684           count += plt_count;
3685         }
3686     }
3687
3688  done:
3689   free (syms);
3690   return count;
3691 }
3692 \f
3693 /* The following functions are specific to the ELF linker, while
3694    functions above are used generally.  Those named ppc64_elf_* are
3695    called by the main ELF linker code.  They appear in this file more
3696    or less in the order in which they are called.  eg.
3697    ppc64_elf_check_relocs is called early in the link process,
3698    ppc64_elf_finish_dynamic_sections is one of the last functions
3699    called.
3700
3701    PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3702    functions have both a function code symbol and a function descriptor
3703    symbol.  A call to foo in a relocatable object file looks like:
3704
3705    .            .text
3706    .    x:
3707    .            bl      .foo
3708    .            nop
3709
3710    The function definition in another object file might be:
3711
3712    .            .section .opd
3713    .    foo:    .quad   .foo
3714    .            .quad   .TOC.@tocbase
3715    .            .quad   0
3716    .
3717    .            .text
3718    .    .foo:   blr
3719
3720    When the linker resolves the call during a static link, the branch
3721    unsurprisingly just goes to .foo and the .opd information is unused.
3722    If the function definition is in a shared library, things are a little
3723    different:  The call goes via a plt call stub, the opd information gets
3724    copied to the plt, and the linker patches the nop.
3725
3726    .    x:
3727    .            bl      .foo_stub
3728    .            ld      2,40(1)
3729    .
3730    .
3731    .    .foo_stub:
3732    .            std     2,40(1)                 # in practice, the call stub
3733    .            addis   11,2,Lfoo@toc@ha        # is slightly optimized, but
3734    .            addi    11,11,Lfoo@toc@l        # this is the general idea
3735    .            ld      12,0(11)
3736    .            ld      2,8(11)
3737    .            mtctr   12
3738    .            ld      11,16(11)
3739    .            bctr
3740    .
3741    .            .section .plt
3742    .    Lfoo:   reloc (R_PPC64_JMP_SLOT, foo)
3743
3744    The "reloc ()" notation is supposed to indicate that the linker emits
3745    an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
3746    copying.
3747
3748    What are the difficulties here?  Well, firstly, the relocations
3749    examined by the linker in check_relocs are against the function code
3750    sym .foo, while the dynamic relocation in the plt is emitted against
3751    the function descriptor symbol, foo.  Somewhere along the line, we need
3752    to carefully copy dynamic link information from one symbol to the other.
3753    Secondly, the generic part of the elf linker will make .foo a dynamic
3754    symbol as is normal for most other backends.  We need foo dynamic
3755    instead, at least for an application final link.  However, when
3756    creating a shared library containing foo, we need to have both symbols
3757    dynamic so that references to .foo are satisfied during the early
3758    stages of linking.  Otherwise the linker might decide to pull in a
3759    definition from some other object, eg. a static library.
3760
3761    Update: As of August 2004, we support a new convention.  Function
3762    calls may use the function descriptor symbol, ie. "bl foo".  This
3763    behaves exactly as "bl .foo".  */
3764
3765 /* Of those relocs that might be copied as dynamic relocs, this function
3766    selects those that must be copied when linking a shared library,
3767    even when the symbol is local.  */
3768
3769 static int
3770 must_be_dyn_reloc (struct bfd_link_info *info,
3771                    enum elf_ppc64_reloc_type r_type)
3772 {
3773   switch (r_type)
3774     {
3775     default:
3776       return 1;
3777
3778     case R_PPC64_REL32:
3779     case R_PPC64_REL64:
3780     case R_PPC64_REL30:
3781       return 0;
3782
3783     case R_PPC64_TPREL16:
3784     case R_PPC64_TPREL16_LO:
3785     case R_PPC64_TPREL16_HI:
3786     case R_PPC64_TPREL16_HA:
3787     case R_PPC64_TPREL16_DS:
3788     case R_PPC64_TPREL16_LO_DS:
3789     case R_PPC64_TPREL16_HIGH:
3790     case R_PPC64_TPREL16_HIGHA:
3791     case R_PPC64_TPREL16_HIGHER:
3792     case R_PPC64_TPREL16_HIGHERA:
3793     case R_PPC64_TPREL16_HIGHEST:
3794     case R_PPC64_TPREL16_HIGHESTA:
3795     case R_PPC64_TPREL64:
3796       return !bfd_link_executable (info);
3797     }
3798 }
3799
3800 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3801    copying dynamic variables from a shared lib into an app's dynbss
3802    section, and instead use a dynamic relocation to point into the
3803    shared lib.  With code that gcc generates, it's vital that this be
3804    enabled;  In the PowerPC64 ABI, the address of a function is actually
3805    the address of a function descriptor, which resides in the .opd
3806    section.  gcc uses the descriptor directly rather than going via the
3807    GOT as some other ABI's do, which means that initialized function
3808    pointers must reference the descriptor.  Thus, a function pointer
3809    initialized to the address of a function in a shared library will
3810    either require a copy reloc, or a dynamic reloc.  Using a copy reloc
3811    redefines the function descriptor symbol to point to the copy.  This
3812    presents a problem as a plt entry for that function is also
3813    initialized from the function descriptor symbol and the copy reloc
3814    may not be initialized first.  */
3815 #define ELIMINATE_COPY_RELOCS 1
3816
3817 /* Section name for stubs is the associated section name plus this
3818    string.  */
3819 #define STUB_SUFFIX ".stub"
3820
3821 /* Linker stubs.
3822    ppc_stub_long_branch:
3823    Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3824    destination, but a 24 bit branch in a stub section will reach.
3825    .    b       dest
3826
3827    ppc_stub_plt_branch:
3828    Similar to the above, but a 24 bit branch in the stub section won't
3829    reach its destination.
3830    .    addis   %r11,%r2,xxx@toc@ha
3831    .    ld      %r12,xxx@toc@l(%r11)
3832    .    mtctr   %r12
3833    .    bctr
3834
3835    ppc_stub_plt_call:
3836    Used to call a function in a shared library.  If it so happens that
3837    the plt entry referenced crosses a 64k boundary, then an extra
3838    "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3839    .    std     %r2,40(%r1)
3840    .    addis   %r11,%r2,xxx@toc@ha
3841    .    ld      %r12,xxx+0@toc@l(%r11)
3842    .    mtctr   %r12
3843    .    ld      %r2,xxx+8@toc@l(%r11)
3844    .    ld      %r11,xxx+16@toc@l(%r11)
3845    .    bctr
3846
3847    ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3848    code to adjust the value and save r2 to support multiple toc sections.
3849    A ppc_stub_long_branch with an r2 offset looks like:
3850    .    std     %r2,40(%r1)
3851    .    addis   %r2,%r2,off@ha
3852    .    addi    %r2,%r2,off@l
3853    .    b       dest
3854
3855    A ppc_stub_plt_branch with an r2 offset looks like:
3856    .    std     %r2,40(%r1)
3857    .    addis   %r11,%r2,xxx@toc@ha
3858    .    ld      %r12,xxx@toc@l(%r11)
3859    .    addis   %r2,%r2,off@ha
3860    .    addi    %r2,%r2,off@l
3861    .    mtctr   %r12
3862    .    bctr
3863
3864    In cases where the "addis" instruction would add zero, the "addis" is
3865    omitted and following instructions modified slightly in some cases.
3866 */
3867
3868 enum ppc_stub_type {
3869   ppc_stub_none,
3870   ppc_stub_long_branch,
3871   ppc_stub_long_branch_r2off,
3872   ppc_stub_plt_branch,
3873   ppc_stub_plt_branch_r2off,
3874   ppc_stub_plt_call,
3875   ppc_stub_plt_call_r2save,
3876   ppc_stub_global_entry,
3877   ppc_stub_save_res
3878 };
3879
3880 /* Information on stub grouping.  */
3881 struct map_stub
3882 {
3883   /* The stub section.  */
3884   asection *stub_sec;
3885   /* This is the section to which stubs in the group will be attached.  */
3886   asection *link_sec;
3887   /* Next group.  */
3888   struct map_stub *next;
3889   /* Whether to emit a copy of register save/restore functions in this
3890      group.  */
3891   int needs_save_res;
3892 };
3893
3894 struct ppc_stub_hash_entry {
3895
3896   /* Base hash table entry structure.  */
3897   struct bfd_hash_entry root;
3898
3899   enum ppc_stub_type stub_type;
3900
3901   /* Group information.  */
3902   struct map_stub *group;
3903
3904   /* Offset within stub_sec of the beginning of this stub.  */
3905   bfd_vma stub_offset;
3906
3907   /* Given the symbol's value and its section we can determine its final
3908      value when building the stubs (so the stub knows where to jump.  */
3909   bfd_vma target_value;
3910   asection *target_section;
3911
3912   /* The symbol table entry, if any, that this was derived from.  */
3913   struct ppc_link_hash_entry *h;
3914   struct plt_entry *plt_ent;
3915
3916   /* Symbol st_other.  */
3917   unsigned char other;
3918 };
3919
3920 struct ppc_branch_hash_entry {
3921
3922   /* Base hash table entry structure.  */
3923   struct bfd_hash_entry root;
3924
3925   /* Offset within branch lookup table.  */
3926   unsigned int offset;
3927
3928   /* Generation marker.  */
3929   unsigned int iter;
3930 };
3931
3932 /* Used to track dynamic relocations for local symbols.  */
3933 struct ppc_dyn_relocs
3934 {
3935   struct ppc_dyn_relocs *next;
3936
3937   /* The input section of the reloc.  */
3938   asection *sec;
3939
3940   /* Total number of relocs copied for the input section.  */
3941   unsigned int count : 31;
3942
3943   /* Whether this entry is for STT_GNU_IFUNC symbols.  */
3944   unsigned int ifunc : 1;
3945 };
3946
3947 struct ppc_link_hash_entry
3948 {
3949   struct elf_link_hash_entry elf;
3950
3951   union {
3952     /* A pointer to the most recently used stub hash entry against this
3953        symbol.  */
3954     struct ppc_stub_hash_entry *stub_cache;
3955
3956     /* A pointer to the next symbol starting with a '.'  */
3957     struct ppc_link_hash_entry *next_dot_sym;
3958   } u;
3959
3960   /* Track dynamic relocs copied for this symbol.  */
3961   struct elf_dyn_relocs *dyn_relocs;
3962
3963   /* Chain of aliases referring to a weakdef.  */
3964   struct ppc_link_hash_entry *weakref;
3965
3966   /* Link between function code and descriptor symbols.  */
3967   struct ppc_link_hash_entry *oh;
3968
3969   /* Flag function code and descriptor symbols.  */
3970   unsigned int is_func:1;
3971   unsigned int is_func_descriptor:1;
3972   unsigned int fake:1;
3973
3974   /* Whether global opd/toc sym has been adjusted or not.
3975      After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3976      should be set for all globals defined in any opd/toc section.  */
3977   unsigned int adjust_done:1;
3978
3979   /* Set if we twiddled this symbol to weak at some stage.  */
3980   unsigned int was_undefined:1;
3981
3982   /* Set if this is an out-of-line register save/restore function,
3983      with non-standard calling convention.  */
3984   unsigned int save_res:1;
3985
3986   /* Contexts in which symbol is used in the GOT (or TOC).
3987      TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3988      corresponding relocs are encountered during check_relocs.
3989      tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3990      indicate the corresponding GOT entry type is not needed.
3991      tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3992      a TPREL one.  We use a separate flag rather than setting TPREL
3993      just for convenience in distinguishing the two cases.  */
3994 #define TLS_GD           1      /* GD reloc. */
3995 #define TLS_LD           2      /* LD reloc. */
3996 #define TLS_TPREL        4      /* TPREL reloc, => IE. */
3997 #define TLS_DTPREL       8      /* DTPREL reloc, => LD. */
3998 #define TLS_TLS         16      /* Any TLS reloc.  */
3999 #define TLS_EXPLICIT    32      /* Marks TOC section TLS relocs. */
4000 #define TLS_TPRELGD     64      /* TPREL reloc resulting from GD->IE. */
4001 #define PLT_IFUNC      128      /* STT_GNU_IFUNC.  */
4002   unsigned char tls_mask;
4003 };
4004
4005 /* ppc64 ELF linker hash table.  */
4006
4007 struct ppc_link_hash_table
4008 {
4009   struct elf_link_hash_table elf;
4010
4011   /* The stub hash table.  */
4012   struct bfd_hash_table stub_hash_table;
4013
4014   /* Another hash table for plt_branch stubs.  */
4015   struct bfd_hash_table branch_hash_table;
4016
4017   /* Hash table for function prologue tocsave.  */
4018   htab_t tocsave_htab;
4019
4020   /* Various options and other info passed from the linker.  */
4021   struct ppc64_elf_params *params;
4022
4023   /* The size of sec_info below.  */
4024   unsigned int sec_info_arr_size;
4025
4026   /* Per-section array of extra section info.  Done this way rather
4027      than as part of ppc64_elf_section_data so we have the info for
4028      non-ppc64 sections.  */
4029   struct
4030   {
4031     /* Along with elf_gp, specifies the TOC pointer used by this section.  */
4032     bfd_vma toc_off;
4033
4034     union
4035     {
4036       /* The section group that this section belongs to.  */
4037       struct map_stub *group;
4038       /* A temp section list pointer.  */
4039       asection *list;
4040     } u;
4041   } *sec_info;
4042
4043   /* Linked list of groups.  */
4044   struct map_stub *group;
4045
4046   /* Temp used when calculating TOC pointers.  */
4047   bfd_vma toc_curr;
4048   bfd *toc_bfd;
4049   asection *toc_first_sec;
4050
4051   /* Used when adding symbols.  */
4052   struct ppc_link_hash_entry *dot_syms;
4053
4054   /* Shortcuts to get to dynamic linker sections.  */
4055   asection *dynbss;
4056   asection *relbss;
4057   asection *glink;
4058   asection *sfpr;
4059   asection *brlt;
4060   asection *relbrlt;
4061   asection *glink_eh_frame;
4062
4063   /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
4064   struct ppc_link_hash_entry *tls_get_addr;
4065   struct ppc_link_hash_entry *tls_get_addr_fd;
4066
4067   /* The size of reliplt used by got entry relocs.  */
4068   bfd_size_type got_reli_size;
4069
4070   /* Statistics.  */
4071   unsigned long stub_count[ppc_stub_global_entry];
4072
4073   /* Number of stubs against global syms.  */
4074   unsigned long stub_globals;
4075
4076   /* Set if we're linking code with function descriptors.  */
4077   unsigned int opd_abi:1;
4078
4079   /* Support for multiple toc sections.  */
4080   unsigned int do_multi_toc:1;
4081   unsigned int multi_toc_needed:1;
4082   unsigned int second_toc_pass:1;
4083   unsigned int do_toc_opt:1;
4084
4085   /* Set on error.  */
4086   unsigned int stub_error:1;
4087
4088   /* Temp used by ppc64_elf_before_check_relocs.  */
4089   unsigned int twiddled_syms:1;
4090
4091   /* Incremented every time we size stubs.  */
4092   unsigned int stub_iteration;
4093
4094   /* Small local sym cache.  */
4095   struct sym_cache sym_cache;
4096 };
4097
4098 /* Rename some of the generic section flags to better document how they
4099    are used here.  */
4100
4101 /* Nonzero if this section has TLS related relocations.  */
4102 #define has_tls_reloc sec_flg0
4103
4104 /* Nonzero if this section has a call to __tls_get_addr.  */
4105 #define has_tls_get_addr_call sec_flg1
4106
4107 /* Nonzero if this section has any toc or got relocs.  */
4108 #define has_toc_reloc sec_flg2
4109
4110 /* Nonzero if this section has a call to another section that uses
4111    the toc or got.  */
4112 #define makes_toc_func_call sec_flg3
4113
4114 /* Recursion protection when determining above flag.  */
4115 #define call_check_in_progress sec_flg4
4116 #define call_check_done sec_flg5
4117
4118 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
4119
4120 #define ppc_hash_table(p) \
4121   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
4122   == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
4123
4124 #define ppc_stub_hash_lookup(table, string, create, copy) \
4125   ((struct ppc_stub_hash_entry *) \
4126    bfd_hash_lookup ((table), (string), (create), (copy)))
4127
4128 #define ppc_branch_hash_lookup(table, string, create, copy) \
4129   ((struct ppc_branch_hash_entry *) \
4130    bfd_hash_lookup ((table), (string), (create), (copy)))
4131
4132 /* Create an entry in the stub hash table.  */
4133
4134 static struct bfd_hash_entry *
4135 stub_hash_newfunc (struct bfd_hash_entry *entry,
4136                    struct bfd_hash_table *table,
4137                    const char *string)
4138 {
4139   /* Allocate the structure if it has not already been allocated by a
4140      subclass.  */
4141   if (entry == NULL)
4142     {
4143       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4144       if (entry == NULL)
4145         return entry;
4146     }
4147
4148   /* Call the allocation method of the superclass.  */
4149   entry = bfd_hash_newfunc (entry, table, string);
4150   if (entry != NULL)
4151     {
4152       struct ppc_stub_hash_entry *eh;
4153
4154       /* Initialize the local fields.  */
4155       eh = (struct ppc_stub_hash_entry *) entry;
4156       eh->stub_type = ppc_stub_none;
4157       eh->group = NULL;
4158       eh->stub_offset = 0;
4159       eh->target_value = 0;
4160       eh->target_section = NULL;
4161       eh->h = NULL;
4162       eh->plt_ent = NULL;
4163       eh->other = 0;
4164     }
4165
4166   return entry;
4167 }
4168
4169 /* Create an entry in the branch hash table.  */
4170
4171 static struct bfd_hash_entry *
4172 branch_hash_newfunc (struct bfd_hash_entry *entry,
4173                      struct bfd_hash_table *table,
4174                      const char *string)
4175 {
4176   /* Allocate the structure if it has not already been allocated by a
4177      subclass.  */
4178   if (entry == NULL)
4179     {
4180       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4181       if (entry == NULL)
4182         return entry;
4183     }
4184
4185   /* Call the allocation method of the superclass.  */
4186   entry = bfd_hash_newfunc (entry, table, string);
4187   if (entry != NULL)
4188     {
4189       struct ppc_branch_hash_entry *eh;
4190
4191       /* Initialize the local fields.  */
4192       eh = (struct ppc_branch_hash_entry *) entry;
4193       eh->offset = 0;
4194       eh->iter = 0;
4195     }
4196
4197   return entry;
4198 }
4199
4200 /* Create an entry in a ppc64 ELF linker hash table.  */
4201
4202 static struct bfd_hash_entry *
4203 link_hash_newfunc (struct bfd_hash_entry *entry,
4204                    struct bfd_hash_table *table,
4205                    const char *string)
4206 {
4207   /* Allocate the structure if it has not already been allocated by a
4208      subclass.  */
4209   if (entry == NULL)
4210     {
4211       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4212       if (entry == NULL)
4213         return entry;
4214     }
4215
4216   /* Call the allocation method of the superclass.  */
4217   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4218   if (entry != NULL)
4219     {
4220       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4221
4222       memset (&eh->u.stub_cache, 0,
4223               (sizeof (struct ppc_link_hash_entry)
4224                - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4225
4226       /* When making function calls, old ABI code references function entry
4227          points (dot symbols), while new ABI code references the function
4228          descriptor symbol.  We need to make any combination of reference and
4229          definition work together, without breaking archive linking.
4230
4231          For a defined function "foo" and an undefined call to "bar":
4232          An old object defines "foo" and ".foo", references ".bar" (possibly
4233          "bar" too).
4234          A new object defines "foo" and references "bar".
4235
4236          A new object thus has no problem with its undefined symbols being
4237          satisfied by definitions in an old object.  On the other hand, the
4238          old object won't have ".bar" satisfied by a new object.
4239
4240          Keep a list of newly added dot-symbols.  */
4241
4242       if (string[0] == '.')
4243         {
4244           struct ppc_link_hash_table *htab;
4245
4246           htab = (struct ppc_link_hash_table *) table;
4247           eh->u.next_dot_sym = htab->dot_syms;
4248           htab->dot_syms = eh;
4249         }
4250     }
4251
4252   return entry;
4253 }
4254
4255 struct tocsave_entry {
4256   asection *sec;
4257   bfd_vma offset;
4258 };
4259
4260 static hashval_t
4261 tocsave_htab_hash (const void *p)
4262 {
4263   const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4264   return ((bfd_vma)(intptr_t) e->sec ^ e->offset) >> 3;
4265 }
4266
4267 static int
4268 tocsave_htab_eq (const void *p1, const void *p2)
4269 {
4270   const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4271   const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4272   return e1->sec == e2->sec && e1->offset == e2->offset;
4273 }
4274
4275 /* Destroy a ppc64 ELF linker hash table.  */
4276
4277 static void
4278 ppc64_elf_link_hash_table_free (bfd *obfd)
4279 {
4280   struct ppc_link_hash_table *htab;
4281
4282   htab = (struct ppc_link_hash_table *) obfd->link.hash;
4283   if (htab->tocsave_htab)
4284     htab_delete (htab->tocsave_htab);
4285   bfd_hash_table_free (&htab->branch_hash_table);
4286   bfd_hash_table_free (&htab->stub_hash_table);
4287   _bfd_elf_link_hash_table_free (obfd);
4288 }
4289
4290 /* Create a ppc64 ELF linker hash table.  */
4291
4292 static struct bfd_link_hash_table *
4293 ppc64_elf_link_hash_table_create (bfd *abfd)
4294 {
4295   struct ppc_link_hash_table *htab;
4296   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4297
4298   htab = bfd_zmalloc (amt);
4299   if (htab == NULL)
4300     return NULL;
4301
4302   if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4303                                       sizeof (struct ppc_link_hash_entry),
4304                                       PPC64_ELF_DATA))
4305     {
4306       free (htab);
4307       return NULL;
4308     }
4309
4310   /* Init the stub hash table too.  */
4311   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4312                             sizeof (struct ppc_stub_hash_entry)))
4313     {
4314       _bfd_elf_link_hash_table_free (abfd);
4315       return NULL;
4316     }
4317
4318   /* And the branch hash table.  */
4319   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4320                             sizeof (struct ppc_branch_hash_entry)))
4321     {
4322       bfd_hash_table_free (&htab->stub_hash_table);
4323       _bfd_elf_link_hash_table_free (abfd);
4324       return NULL;
4325     }
4326
4327   htab->tocsave_htab = htab_try_create (1024,
4328                                         tocsave_htab_hash,
4329                                         tocsave_htab_eq,
4330                                         NULL);
4331   if (htab->tocsave_htab == NULL)
4332     {
4333       ppc64_elf_link_hash_table_free (abfd);
4334       return NULL;
4335     }
4336   htab->elf.root.hash_table_free = ppc64_elf_link_hash_table_free;
4337
4338   /* Initializing two fields of the union is just cosmetic.  We really
4339      only care about glist, but when compiled on a 32-bit host the
4340      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
4341      debugger inspection of these fields look nicer.  */
4342   htab->elf.init_got_refcount.refcount = 0;
4343   htab->elf.init_got_refcount.glist = NULL;
4344   htab->elf.init_plt_refcount.refcount = 0;
4345   htab->elf.init_plt_refcount.glist = NULL;
4346   htab->elf.init_got_offset.offset = 0;
4347   htab->elf.init_got_offset.glist = NULL;
4348   htab->elf.init_plt_offset.offset = 0;
4349   htab->elf.init_plt_offset.glist = NULL;
4350
4351   return &htab->elf.root;
4352 }
4353
4354 /* Create sections for linker generated code.  */
4355
4356 static bfd_boolean
4357 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4358 {
4359   struct ppc_link_hash_table *htab;
4360   flagword flags;
4361
4362   htab = ppc_hash_table (info);
4363
4364   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4365            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4366   if (htab->params->save_restore_funcs)
4367     {
4368       /* Create .sfpr for code to save and restore fp regs.  */
4369       htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4370                                                        flags);
4371       if (htab->sfpr == NULL
4372           || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4373         return FALSE;
4374     }
4375
4376   if (bfd_link_relocatable (info))
4377     return TRUE;
4378
4379   /* Create .glink for lazy dynamic linking support.  */
4380   htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4381                                                     flags);
4382   if (htab->glink == NULL
4383       || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4384     return FALSE;
4385
4386   if (!info->no_ld_generated_unwind_info)
4387     {
4388       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4389                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4390       htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4391                                                                  ".eh_frame",
4392                                                                  flags);
4393       if (htab->glink_eh_frame == NULL
4394           || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4395         return FALSE;
4396     }
4397
4398   flags = SEC_ALLOC | SEC_LINKER_CREATED;
4399   htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4400   if (htab->elf.iplt == NULL
4401       || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4402     return FALSE;
4403
4404   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4405            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4406   htab->elf.irelplt
4407     = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4408   if (htab->elf.irelplt == NULL
4409       || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4410     return FALSE;
4411
4412   /* Create branch lookup table for plt_branch stubs.  */
4413   flags = (SEC_ALLOC | SEC_LOAD
4414            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4415   htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4416                                                    flags);
4417   if (htab->brlt == NULL
4418       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4419     return FALSE;
4420
4421   if (!bfd_link_pic (info))
4422     return TRUE;
4423
4424   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4425            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4426   htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4427                                                       ".rela.branch_lt",
4428                                                       flags);
4429   if (htab->relbrlt == NULL
4430       || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4431     return FALSE;
4432
4433   return TRUE;
4434 }
4435
4436 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
4437
4438 bfd_boolean
4439 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4440                          struct ppc64_elf_params *params)
4441 {
4442   struct ppc_link_hash_table *htab;
4443
4444   elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4445
4446 /* Always hook our dynamic sections into the first bfd, which is the
4447    linker created stub bfd.  This ensures that the GOT header is at
4448    the start of the output TOC section.  */
4449   htab = ppc_hash_table (info);
4450   htab->elf.dynobj = params->stub_bfd;
4451   htab->params = params;
4452
4453   return create_linkage_sections (htab->elf.dynobj, info);
4454 }
4455
4456 /* Build a name for an entry in the stub hash table.  */
4457
4458 static char *
4459 ppc_stub_name (const asection *input_section,
4460                const asection *sym_sec,
4461                const struct ppc_link_hash_entry *h,
4462                const Elf_Internal_Rela *rel)
4463 {
4464   char *stub_name;
4465   ssize_t len;
4466
4467   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4468      offsets from a sym as a branch target?  In fact, we could
4469      probably assume the addend is always zero.  */
4470   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4471
4472   if (h)
4473     {
4474       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4475       stub_name = bfd_malloc (len);
4476       if (stub_name == NULL)
4477         return stub_name;
4478
4479       len = sprintf (stub_name, "%08x.%s+%x",
4480                      input_section->id & 0xffffffff,
4481                      h->elf.root.root.string,
4482                      (int) rel->r_addend & 0xffffffff);
4483     }
4484   else
4485     {
4486       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4487       stub_name = bfd_malloc (len);
4488       if (stub_name == NULL)
4489         return stub_name;
4490
4491       len = sprintf (stub_name, "%08x.%x:%x+%x",
4492                      input_section->id & 0xffffffff,
4493                      sym_sec->id & 0xffffffff,
4494                      (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4495                      (int) rel->r_addend & 0xffffffff);
4496     }
4497   if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4498     stub_name[len - 2] = 0;
4499   return stub_name;
4500 }
4501
4502 /* Look up an entry in the stub hash.  Stub entries are cached because
4503    creating the stub name takes a bit of time.  */
4504
4505 static struct ppc_stub_hash_entry *
4506 ppc_get_stub_entry (const asection *input_section,
4507                     const asection *sym_sec,
4508                     struct ppc_link_hash_entry *h,
4509                     const Elf_Internal_Rela *rel,
4510                     struct ppc_link_hash_table *htab)
4511 {
4512   struct ppc_stub_hash_entry *stub_entry;
4513   struct map_stub *group;
4514
4515   /* If this input section is part of a group of sections sharing one
4516      stub section, then use the id of the first section in the group.
4517      Stub names need to include a section id, as there may well be
4518      more than one stub used to reach say, printf, and we need to
4519      distinguish between them.  */
4520   group = htab->sec_info[input_section->id].u.group;
4521   if (group == NULL)
4522     return NULL;
4523
4524   if (h != NULL && h->u.stub_cache != NULL
4525       && h->u.stub_cache->h == h
4526       && h->u.stub_cache->group == group)
4527     {
4528       stub_entry = h->u.stub_cache;
4529     }
4530   else
4531     {
4532       char *stub_name;
4533
4534       stub_name = ppc_stub_name (group->link_sec, sym_sec, h, rel);
4535       if (stub_name == NULL)
4536         return NULL;
4537
4538       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4539                                          stub_name, FALSE, FALSE);
4540       if (h != NULL)
4541         h->u.stub_cache = stub_entry;
4542
4543       free (stub_name);
4544     }
4545
4546   return stub_entry;
4547 }
4548
4549 /* Add a new stub entry to the stub hash.  Not all fields of the new
4550    stub entry are initialised.  */
4551
4552 static struct ppc_stub_hash_entry *
4553 ppc_add_stub (const char *stub_name,
4554               asection *section,
4555               struct bfd_link_info *info)
4556 {
4557   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4558   struct map_stub *group;
4559   asection *link_sec;
4560   asection *stub_sec;
4561   struct ppc_stub_hash_entry *stub_entry;
4562
4563   group = htab->sec_info[section->id].u.group;
4564   link_sec = group->link_sec;
4565   stub_sec = group->stub_sec;
4566   if (stub_sec == NULL)
4567     {
4568       size_t namelen;
4569       bfd_size_type len;
4570       char *s_name;
4571
4572       namelen = strlen (link_sec->name);
4573       len = namelen + sizeof (STUB_SUFFIX);
4574       s_name = bfd_alloc (htab->params->stub_bfd, len);
4575       if (s_name == NULL)
4576         return NULL;
4577
4578       memcpy (s_name, link_sec->name, namelen);
4579       memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4580       stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4581       if (stub_sec == NULL)
4582         return NULL;
4583       group->stub_sec = stub_sec;
4584     }
4585
4586   /* Enter this entry into the linker stub hash table.  */
4587   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4588                                      TRUE, FALSE);
4589   if (stub_entry == NULL)
4590     {
4591       info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4592                               section->owner, stub_name);
4593       return NULL;
4594     }
4595
4596   stub_entry->group = group;
4597   stub_entry->stub_offset = 0;
4598   return stub_entry;
4599 }
4600
4601 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4602    not already done.  */
4603
4604 static bfd_boolean
4605 create_got_section (bfd *abfd, struct bfd_link_info *info)
4606 {
4607   asection *got, *relgot;
4608   flagword flags;
4609   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4610
4611   if (!is_ppc64_elf (abfd))
4612     return FALSE;
4613   if (htab == NULL)
4614     return FALSE;
4615
4616   if (!htab->elf.sgot
4617       && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4618     return FALSE;
4619
4620   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4621            | SEC_LINKER_CREATED);
4622
4623   got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4624   if (!got
4625       || !bfd_set_section_alignment (abfd, got, 3))
4626     return FALSE;
4627
4628   relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4629                                                flags | SEC_READONLY);
4630   if (!relgot
4631       || ! bfd_set_section_alignment (abfd, relgot, 3))
4632     return FALSE;
4633
4634   ppc64_elf_tdata (abfd)->got = got;
4635   ppc64_elf_tdata (abfd)->relgot = relgot;
4636   return TRUE;
4637 }
4638
4639 /* Create the dynamic sections, and set up shortcuts.  */
4640
4641 static bfd_boolean
4642 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4643 {
4644   struct ppc_link_hash_table *htab;
4645
4646   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4647     return FALSE;
4648
4649   htab = ppc_hash_table (info);
4650   if (htab == NULL)
4651     return FALSE;
4652
4653   htab->dynbss = bfd_get_linker_section (dynobj, ".dynbss");
4654   if (!bfd_link_pic (info))
4655     htab->relbss = bfd_get_linker_section (dynobj, ".rela.bss");
4656
4657   if (!htab->elf.sgot || !htab->elf.splt || !htab->elf.srelplt || !htab->dynbss
4658       || (!bfd_link_pic (info) && !htab->relbss))
4659     abort ();
4660
4661   return TRUE;
4662 }
4663
4664 /* Follow indirect and warning symbol links.  */
4665
4666 static inline struct bfd_link_hash_entry *
4667 follow_link (struct bfd_link_hash_entry *h)
4668 {
4669   while (h->type == bfd_link_hash_indirect
4670          || h->type == bfd_link_hash_warning)
4671     h = h->u.i.link;
4672   return h;
4673 }
4674
4675 static inline struct elf_link_hash_entry *
4676 elf_follow_link (struct elf_link_hash_entry *h)
4677 {
4678   return (struct elf_link_hash_entry *) follow_link (&h->root);
4679 }
4680
4681 static inline struct ppc_link_hash_entry *
4682 ppc_follow_link (struct ppc_link_hash_entry *h)
4683 {
4684   return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4685 }
4686
4687 /* Merge PLT info on FROM with that on TO.  */
4688
4689 static void
4690 move_plt_plist (struct ppc_link_hash_entry *from,
4691                 struct ppc_link_hash_entry *to)
4692 {
4693   if (from->elf.plt.plist != NULL)
4694     {
4695       if (to->elf.plt.plist != NULL)
4696         {
4697           struct plt_entry **entp;
4698           struct plt_entry *ent;
4699
4700           for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4701             {
4702               struct plt_entry *dent;
4703
4704               for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4705                 if (dent->addend == ent->addend)
4706                   {
4707                     dent->plt.refcount += ent->plt.refcount;
4708                     *entp = ent->next;
4709                     break;
4710                   }
4711               if (dent == NULL)
4712                 entp = &ent->next;
4713             }
4714           *entp = to->elf.plt.plist;
4715         }
4716
4717       to->elf.plt.plist = from->elf.plt.plist;
4718       from->elf.plt.plist = NULL;
4719     }
4720 }
4721
4722 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
4723
4724 static void
4725 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4726                                 struct elf_link_hash_entry *dir,
4727                                 struct elf_link_hash_entry *ind)
4728 {
4729   struct ppc_link_hash_entry *edir, *eind;
4730
4731   edir = (struct ppc_link_hash_entry *) dir;
4732   eind = (struct ppc_link_hash_entry *) ind;
4733
4734   edir->is_func |= eind->is_func;
4735   edir->is_func_descriptor |= eind->is_func_descriptor;
4736   edir->tls_mask |= eind->tls_mask;
4737   if (eind->oh != NULL)
4738     edir->oh = ppc_follow_link (eind->oh);
4739
4740   /* If called to transfer flags for a weakdef during processing
4741      of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4742      We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
4743   if (!(ELIMINATE_COPY_RELOCS
4744         && eind->elf.root.type != bfd_link_hash_indirect
4745         && edir->elf.dynamic_adjusted))
4746     edir->elf.non_got_ref |= eind->elf.non_got_ref;
4747
4748   edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4749   edir->elf.ref_regular |= eind->elf.ref_regular;
4750   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4751   edir->elf.needs_plt |= eind->elf.needs_plt;
4752   edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4753
4754   /* If we were called to copy over info for a weak sym, don't copy
4755      dyn_relocs, plt/got info, or dynindx.  We used to copy dyn_relocs
4756      in order to simplify readonly_dynrelocs and save a field in the
4757      symbol hash entry, but that means dyn_relocs can't be used in any
4758      tests about a specific symbol, or affect other symbol flags which
4759      are then tested.
4760      Chain weakdefs so we can get from the weakdef back to an alias.
4761      The list is circular so that we don't need to use u.weakdef as
4762      well as this list to look at all aliases.  */
4763   if (eind->elf.root.type != bfd_link_hash_indirect)
4764     {
4765       struct ppc_link_hash_entry *cur, *add, *next;
4766
4767       add = eind;
4768       do
4769         {
4770           cur = edir->weakref;
4771           if (cur != NULL)
4772             {
4773               do
4774                 {
4775                   /* We can be called twice for the same symbols.
4776                      Don't make multiple loops.  */
4777                   if (cur == add)
4778                     return;
4779                   cur = cur->weakref;
4780                 } while (cur != edir);
4781             }
4782           next = add->weakref;
4783           if (cur != add)
4784             {
4785               add->weakref = edir->weakref != NULL ? edir->weakref : edir;
4786               edir->weakref = add;
4787             }
4788           add = next;
4789         } while (add != NULL && add != eind);
4790       return;
4791     }
4792
4793   /* Copy over any dynamic relocs we may have on the indirect sym.  */
4794   if (eind->dyn_relocs != NULL)
4795     {
4796       if (edir->dyn_relocs != NULL)
4797         {
4798           struct elf_dyn_relocs **pp;
4799           struct elf_dyn_relocs *p;
4800
4801           /* Add reloc counts against the indirect sym to the direct sym
4802              list.  Merge any entries against the same section.  */
4803           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4804             {
4805               struct elf_dyn_relocs *q;
4806
4807               for (q = edir->dyn_relocs; q != NULL; q = q->next)
4808                 if (q->sec == p->sec)
4809                   {
4810                     q->pc_count += p->pc_count;
4811                     q->count += p->count;
4812                     *pp = p->next;
4813                     break;
4814                   }
4815               if (q == NULL)
4816                 pp = &p->next;
4817             }
4818           *pp = edir->dyn_relocs;
4819         }
4820
4821       edir->dyn_relocs = eind->dyn_relocs;
4822       eind->dyn_relocs = NULL;
4823     }
4824
4825   /* Copy over got entries that we may have already seen to the
4826      symbol which just became indirect.  */
4827   if (eind->elf.got.glist != NULL)
4828     {
4829       if (edir->elf.got.glist != NULL)
4830         {
4831           struct got_entry **entp;
4832           struct got_entry *ent;
4833
4834           for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4835             {
4836               struct got_entry *dent;
4837
4838               for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4839                 if (dent->addend == ent->addend
4840                     && dent->owner == ent->owner
4841                     && dent->tls_type == ent->tls_type)
4842                   {
4843                     dent->got.refcount += ent->got.refcount;
4844                     *entp = ent->next;
4845                     break;
4846                   }
4847               if (dent == NULL)
4848                 entp = &ent->next;
4849             }
4850           *entp = edir->elf.got.glist;
4851         }
4852
4853       edir->elf.got.glist = eind->elf.got.glist;
4854       eind->elf.got.glist = NULL;
4855     }
4856
4857   /* And plt entries.  */
4858   move_plt_plist (eind, edir);
4859
4860   if (eind->elf.dynindx != -1)
4861     {
4862       if (edir->elf.dynindx != -1)
4863         _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4864                                 edir->elf.dynstr_index);
4865       edir->elf.dynindx = eind->elf.dynindx;
4866       edir->elf.dynstr_index = eind->elf.dynstr_index;
4867       eind->elf.dynindx = -1;
4868       eind->elf.dynstr_index = 0;
4869     }
4870 }
4871
4872 /* Find the function descriptor hash entry from the given function code
4873    hash entry FH.  Link the entries via their OH fields.  */
4874
4875 static struct ppc_link_hash_entry *
4876 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4877 {
4878   struct ppc_link_hash_entry *fdh = fh->oh;
4879
4880   if (fdh == NULL)
4881     {
4882       const char *fd_name = fh->elf.root.root.string + 1;
4883
4884       fdh = (struct ppc_link_hash_entry *)
4885         elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4886       if (fdh == NULL)
4887         return fdh;
4888
4889       fdh->is_func_descriptor = 1;
4890       fdh->oh = fh;
4891       fh->is_func = 1;
4892       fh->oh = fdh;
4893     }
4894
4895   return ppc_follow_link (fdh);
4896 }
4897
4898 /* Make a fake function descriptor sym for the code sym FH.  */
4899
4900 static struct ppc_link_hash_entry *
4901 make_fdh (struct bfd_link_info *info,
4902           struct ppc_link_hash_entry *fh)
4903 {
4904   bfd *abfd;
4905   asymbol *newsym;
4906   struct bfd_link_hash_entry *bh;
4907   struct ppc_link_hash_entry *fdh;
4908
4909   abfd = fh->elf.root.u.undef.abfd;
4910   newsym = bfd_make_empty_symbol (abfd);
4911   newsym->name = fh->elf.root.root.string + 1;
4912   newsym->section = bfd_und_section_ptr;
4913   newsym->value = 0;
4914   newsym->flags = BSF_WEAK;
4915
4916   bh = NULL;
4917   if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4918                                          newsym->flags, newsym->section,
4919                                          newsym->value, NULL, FALSE, FALSE,
4920                                          &bh))
4921     return NULL;
4922
4923   fdh = (struct ppc_link_hash_entry *) bh;
4924   fdh->elf.non_elf = 0;
4925   fdh->fake = 1;
4926   fdh->is_func_descriptor = 1;
4927   fdh->oh = fh;
4928   fh->is_func = 1;
4929   fh->oh = fdh;
4930   return fdh;
4931 }
4932
4933 /* Fix function descriptor symbols defined in .opd sections to be
4934    function type.  */
4935
4936 static bfd_boolean
4937 ppc64_elf_add_symbol_hook (bfd *ibfd,
4938                            struct bfd_link_info *info,
4939                            Elf_Internal_Sym *isym,
4940                            const char **name,
4941                            flagword *flags ATTRIBUTE_UNUSED,
4942                            asection **sec,
4943                            bfd_vma *value)
4944 {
4945   if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4946       && (ibfd->flags & DYNAMIC) == 0
4947       && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
4948     elf_tdata (info->output_bfd)->has_gnu_symbols |= elf_gnu_symbol_ifunc;
4949
4950   if (*sec != NULL
4951       && strcmp ((*sec)->name, ".opd") == 0)
4952     {
4953       asection *code_sec;
4954
4955       if (!(ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4956             || ELF_ST_TYPE (isym->st_info) == STT_FUNC))
4957         isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4958
4959       /* If the symbol is a function defined in .opd, and the function
4960          code is in a discarded group, let it appear to be undefined.  */
4961       if (!bfd_link_relocatable (info)
4962           && (*sec)->reloc_count != 0
4963           && opd_entry_value (*sec, *value, &code_sec, NULL,
4964                               FALSE) != (bfd_vma) -1
4965           && discarded_section (code_sec))
4966         {
4967           *sec = bfd_und_section_ptr;
4968           isym->st_shndx = SHN_UNDEF;
4969         }
4970     }
4971   else if (*sec != NULL
4972            && strcmp ((*sec)->name, ".toc") == 0
4973            && ELF_ST_TYPE (isym->st_info) == STT_OBJECT)
4974     {
4975       struct ppc_link_hash_table *htab = ppc_hash_table (info);
4976       if (htab != NULL)
4977         htab->params->object_in_toc = 1;
4978     }
4979
4980   if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4981     {
4982       if (abiversion (ibfd) == 0)
4983         set_abiversion (ibfd, 2);
4984       else if (abiversion (ibfd) == 1)
4985         {
4986           info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other"
4987                                     " for ABI version 1\n"), name);
4988           bfd_set_error (bfd_error_bad_value);
4989           return FALSE;
4990         }
4991     }
4992
4993   return TRUE;
4994 }
4995
4996 /* Merge non-visibility st_other attributes: local entry point.  */
4997
4998 static void
4999 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
5000                                   const Elf_Internal_Sym *isym,
5001                                   bfd_boolean definition,
5002                                   bfd_boolean dynamic)
5003 {
5004   if (definition && !dynamic)
5005     h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
5006                 | ELF_ST_VISIBILITY (h->other));
5007 }
5008
5009 /* This function makes an old ABI object reference to ".bar" cause the
5010    inclusion of a new ABI object archive that defines "bar".
5011    NAME is a symbol defined in an archive.  Return a symbol in the hash
5012    table that might be satisfied by the archive symbols.  */
5013
5014 static struct elf_link_hash_entry *
5015 ppc64_elf_archive_symbol_lookup (bfd *abfd,
5016                                  struct bfd_link_info *info,
5017                                  const char *name)
5018 {
5019   struct elf_link_hash_entry *h;
5020   char *dot_name;
5021   size_t len;
5022
5023   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
5024   if (h != NULL
5025       /* Don't return this sym if it is a fake function descriptor
5026          created by add_symbol_adjust.  */
5027       && !(h->root.type == bfd_link_hash_undefweak
5028            && ((struct ppc_link_hash_entry *) h)->fake))
5029     return h;
5030
5031   if (name[0] == '.')
5032     return h;
5033
5034   len = strlen (name);
5035   dot_name = bfd_alloc (abfd, len + 2);
5036   if (dot_name == NULL)
5037     return (struct elf_link_hash_entry *) 0 - 1;
5038   dot_name[0] = '.';
5039   memcpy (dot_name + 1, name, len + 1);
5040   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
5041   bfd_release (abfd, dot_name);
5042   return h;
5043 }
5044
5045 /* This function satisfies all old ABI object references to ".bar" if a
5046    new ABI object defines "bar".  Well, at least, undefined dot symbols
5047    are made weak.  This stops later archive searches from including an
5048    object if we already have a function descriptor definition.  It also
5049    prevents the linker complaining about undefined symbols.
5050    We also check and correct mismatched symbol visibility here.  The
5051    most restrictive visibility of the function descriptor and the
5052    function entry symbol is used.  */
5053
5054 static bfd_boolean
5055 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
5056 {
5057   struct ppc_link_hash_table *htab;
5058   struct ppc_link_hash_entry *fdh;
5059
5060   if (eh->elf.root.type == bfd_link_hash_indirect)
5061     return TRUE;
5062
5063   if (eh->elf.root.type == bfd_link_hash_warning)
5064     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
5065
5066   if (eh->elf.root.root.string[0] != '.')
5067     abort ();
5068
5069   htab = ppc_hash_table (info);
5070   if (htab == NULL)
5071     return FALSE;
5072
5073   fdh = lookup_fdh (eh, htab);
5074   if (fdh == NULL)
5075     {
5076       if (!bfd_link_relocatable (info)
5077           && (eh->elf.root.type == bfd_link_hash_undefined
5078               || eh->elf.root.type == bfd_link_hash_undefweak)
5079           && eh->elf.ref_regular)
5080         {
5081           /* Make an undefweak function descriptor sym, which is enough to
5082              pull in an --as-needed shared lib, but won't cause link
5083              errors.  Archives are handled elsewhere.  */
5084           fdh = make_fdh (info, eh);
5085           if (fdh == NULL)
5086             return FALSE;
5087           fdh->elf.ref_regular = 1;
5088         }
5089     }
5090   else
5091     {
5092       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
5093       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
5094       if (entry_vis < descr_vis)
5095         fdh->elf.other += entry_vis - descr_vis;
5096       else if (entry_vis > descr_vis)
5097         eh->elf.other += descr_vis - entry_vis;
5098
5099       if ((fdh->elf.root.type == bfd_link_hash_defined
5100            || fdh->elf.root.type == bfd_link_hash_defweak)
5101           && eh->elf.root.type == bfd_link_hash_undefined)
5102         {
5103           eh->elf.root.type = bfd_link_hash_undefweak;
5104           eh->was_undefined = 1;
5105           htab->twiddled_syms = 1;
5106         }
5107     }
5108
5109   return TRUE;
5110 }
5111
5112 /* Set up opd section info and abiversion for IBFD, and process list
5113    of dot-symbols we made in link_hash_newfunc.  */
5114
5115 static bfd_boolean
5116 ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
5117 {
5118   struct ppc_link_hash_table *htab;
5119   struct ppc_link_hash_entry **p, *eh;
5120   asection *opd = bfd_get_section_by_name (ibfd, ".opd");
5121
5122   if (opd != NULL && opd->size != 0)
5123     {
5124       if (abiversion (ibfd) == 0)
5125         set_abiversion (ibfd, 1);
5126       else if (abiversion (ibfd) >= 2)
5127         {
5128           info->callbacks->einfo (_("%P: %B .opd not allowed in ABI"
5129                                     " version %d\n"),
5130                                   ibfd, abiversion (ibfd));
5131           bfd_set_error (bfd_error_bad_value);
5132           return FALSE;
5133         }
5134
5135       if ((ibfd->flags & DYNAMIC) == 0
5136           && (opd->flags & SEC_RELOC) != 0
5137           && opd->reloc_count != 0
5138           && !bfd_is_abs_section (opd->output_section))
5139         {
5140           /* Garbage collection needs some extra help with .opd sections.
5141              We don't want to necessarily keep everything referenced by
5142              relocs in .opd, as that would keep all functions.  Instead,
5143              if we reference an .opd symbol (a function descriptor), we
5144              want to keep the function code symbol's section.  This is
5145              easy for global symbols, but for local syms we need to keep
5146              information about the associated function section.  */
5147           bfd_size_type amt;
5148           asection **opd_sym_map;
5149
5150           amt = OPD_NDX (opd->size) * sizeof (*opd_sym_map);
5151           opd_sym_map = bfd_zalloc (ibfd, amt);
5152           if (opd_sym_map == NULL)
5153             return FALSE;
5154           ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
5155           BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
5156           ppc64_elf_section_data (opd)->sec_type = sec_opd;
5157         }
5158     }
5159
5160   if (!is_ppc64_elf (info->output_bfd))
5161     return TRUE;
5162   htab = ppc_hash_table (info);
5163   if (htab == NULL)
5164     return FALSE;
5165
5166   /* For input files without an explicit abiversion in e_flags
5167      we should have flagged any with symbol st_other bits set
5168      as ELFv1 and above flagged those with .opd as ELFv2.
5169      Set the output abiversion if not yet set, and for any input
5170      still ambiguous, take its abiversion from the output.
5171      Differences in ABI are reported later.  */
5172   if (abiversion (info->output_bfd) == 0)
5173     set_abiversion (info->output_bfd, abiversion (ibfd));
5174   else if (abiversion (ibfd) == 0)
5175     set_abiversion (ibfd, abiversion (info->output_bfd));
5176
5177   p = &htab->dot_syms;
5178   while ((eh = *p) != NULL)
5179     {
5180       *p = NULL;
5181       if (&eh->elf == htab->elf.hgot)
5182         ;
5183       else if (htab->elf.hgot == NULL
5184                && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
5185         htab->elf.hgot = &eh->elf;
5186       else if (!add_symbol_adjust (eh, info))
5187         return FALSE;
5188       p = &eh->u.next_dot_sym;
5189     }
5190
5191   /* Clear the list for non-ppc64 input files.  */
5192   p = &htab->dot_syms;
5193   while ((eh = *p) != NULL)
5194     {
5195       *p = NULL;
5196       p = &eh->u.next_dot_sym;
5197     }
5198
5199   /* We need to fix the undefs list for any syms we have twiddled to
5200      undefweak.  */
5201   if (htab->twiddled_syms)
5202     {
5203       bfd_link_repair_undef_list (&htab->elf.root);
5204       htab->twiddled_syms = 0;
5205     }
5206   return TRUE;
5207 }
5208
5209 /* Undo hash table changes when an --as-needed input file is determined
5210    not to be needed.  */
5211
5212 static bfd_boolean
5213 ppc64_elf_notice_as_needed (bfd *ibfd,
5214                             struct bfd_link_info *info,
5215                             enum notice_asneeded_action act)
5216 {
5217   if (act == notice_not_needed)
5218     {
5219       struct ppc_link_hash_table *htab = ppc_hash_table (info);
5220
5221       if (htab == NULL)
5222         return FALSE;
5223
5224       htab->dot_syms = NULL;
5225     }
5226   return _bfd_elf_notice_as_needed (ibfd, info, act);
5227 }
5228
5229 /* If --just-symbols against a final linked binary, then assume we need
5230    toc adjusting stubs when calling functions defined there.  */
5231
5232 static void
5233 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5234 {
5235   if ((sec->flags & SEC_CODE) != 0
5236       && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5237       && is_ppc64_elf (sec->owner))
5238     {
5239       if (abiversion (sec->owner) >= 2
5240           || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5241         sec->has_toc_reloc = 1;
5242     }
5243   _bfd_elf_link_just_syms (sec, info);
5244 }
5245
5246 static struct plt_entry **
5247 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5248                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5249 {
5250   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5251   struct plt_entry **local_plt;
5252   unsigned char *local_got_tls_masks;
5253
5254   if (local_got_ents == NULL)
5255     {
5256       bfd_size_type size = symtab_hdr->sh_info;
5257
5258       size *= (sizeof (*local_got_ents)
5259                + sizeof (*local_plt)
5260                + sizeof (*local_got_tls_masks));
5261       local_got_ents = bfd_zalloc (abfd, size);
5262       if (local_got_ents == NULL)
5263         return NULL;
5264       elf_local_got_ents (abfd) = local_got_ents;
5265     }
5266
5267   if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
5268     {
5269       struct got_entry *ent;
5270
5271       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5272         if (ent->addend == r_addend
5273             && ent->owner == abfd
5274             && ent->tls_type == tls_type)
5275           break;
5276       if (ent == NULL)
5277         {
5278           bfd_size_type amt = sizeof (*ent);
5279           ent = bfd_alloc (abfd, amt);
5280           if (ent == NULL)
5281             return FALSE;
5282           ent->next = local_got_ents[r_symndx];
5283           ent->addend = r_addend;
5284           ent->owner = abfd;
5285           ent->tls_type = tls_type;
5286           ent->is_indirect = FALSE;
5287           ent->got.refcount = 0;
5288           local_got_ents[r_symndx] = ent;
5289         }
5290       ent->got.refcount += 1;
5291     }
5292
5293   local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5294   local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5295   local_got_tls_masks[r_symndx] |= tls_type;
5296
5297   return local_plt + r_symndx;
5298 }
5299
5300 static bfd_boolean
5301 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5302 {
5303   struct plt_entry *ent;
5304
5305   for (ent = *plist; ent != NULL; ent = ent->next)
5306     if (ent->addend == addend)
5307       break;
5308   if (ent == NULL)
5309     {
5310       bfd_size_type amt = sizeof (*ent);
5311       ent = bfd_alloc (abfd, amt);
5312       if (ent == NULL)
5313         return FALSE;
5314       ent->next = *plist;
5315       ent->addend = addend;
5316       ent->plt.refcount = 0;
5317       *plist = ent;
5318     }
5319   ent->plt.refcount += 1;
5320   return TRUE;
5321 }
5322
5323 static bfd_boolean
5324 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5325 {
5326   return (r_type == R_PPC64_REL24
5327           || r_type == R_PPC64_REL14
5328           || r_type == R_PPC64_REL14_BRTAKEN
5329           || r_type == R_PPC64_REL14_BRNTAKEN
5330           || r_type == R_PPC64_ADDR24
5331           || r_type == R_PPC64_ADDR14
5332           || r_type == R_PPC64_ADDR14_BRTAKEN
5333           || r_type == R_PPC64_ADDR14_BRNTAKEN);
5334 }
5335
5336 /* Look through the relocs for a section during the first phase, and
5337    calculate needed space in the global offset table, procedure
5338    linkage table, and dynamic reloc sections.  */
5339
5340 static bfd_boolean
5341 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5342                         asection *sec, const Elf_Internal_Rela *relocs)
5343 {
5344   struct ppc_link_hash_table *htab;
5345   Elf_Internal_Shdr *symtab_hdr;
5346   struct elf_link_hash_entry **sym_hashes;
5347   const Elf_Internal_Rela *rel;
5348   const Elf_Internal_Rela *rel_end;
5349   asection *sreloc;
5350   asection **opd_sym_map;
5351   struct elf_link_hash_entry *tga, *dottga;
5352
5353   if (bfd_link_relocatable (info))
5354     return TRUE;
5355
5356   /* Don't do anything special with non-loaded, non-alloced sections.
5357      In particular, any relocs in such sections should not affect GOT
5358      and PLT reference counting (ie. we don't allow them to create GOT
5359      or PLT entries), there's no possibility or desire to optimize TLS
5360      relocs, and there's not much point in propagating relocs to shared
5361      libs that the dynamic linker won't relocate.  */
5362   if ((sec->flags & SEC_ALLOC) == 0)
5363     return TRUE;
5364
5365   BFD_ASSERT (is_ppc64_elf (abfd));
5366
5367   htab = ppc_hash_table (info);
5368   if (htab == NULL)
5369     return FALSE;
5370
5371   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5372                               FALSE, FALSE, TRUE);
5373   dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5374                                  FALSE, FALSE, TRUE);
5375   symtab_hdr = &elf_symtab_hdr (abfd);
5376   sym_hashes = elf_sym_hashes (abfd);
5377   sreloc = NULL;
5378   opd_sym_map = NULL;
5379   if (ppc64_elf_section_data (sec) != NULL
5380       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
5381     opd_sym_map = ppc64_elf_section_data (sec)->u.opd.func_sec;
5382
5383   rel_end = relocs + sec->reloc_count;
5384   for (rel = relocs; rel < rel_end; rel++)
5385     {
5386       unsigned long r_symndx;
5387       struct elf_link_hash_entry *h;
5388       enum elf_ppc64_reloc_type r_type;
5389       int tls_type;
5390       struct _ppc64_elf_section_data *ppc64_sec;
5391       struct plt_entry **ifunc, **plt_list;
5392
5393       r_symndx = ELF64_R_SYM (rel->r_info);
5394       if (r_symndx < symtab_hdr->sh_info)
5395         h = NULL;
5396       else
5397         {
5398           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5399           h = elf_follow_link (h);
5400
5401           /* PR15323, ref flags aren't set for references in the same
5402              object.  */
5403           h->root.non_ir_ref = 1;
5404
5405           if (h == htab->elf.hgot)
5406             sec->has_toc_reloc = 1;
5407         }
5408
5409       tls_type = 0;
5410       ifunc = NULL;
5411       if (h != NULL)
5412         {
5413           if (h->type == STT_GNU_IFUNC)
5414             {
5415               h->needs_plt = 1;
5416               ifunc = &h->plt.plist;
5417             }
5418         }
5419       else
5420         {
5421           Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5422                                                           abfd, r_symndx);
5423           if (isym == NULL)
5424             return FALSE;
5425
5426           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5427             {
5428               ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5429                                              rel->r_addend, PLT_IFUNC);
5430               if (ifunc == NULL)
5431                 return FALSE;
5432             }
5433         }
5434
5435       r_type = ELF64_R_TYPE (rel->r_info);
5436       switch (r_type)
5437         {
5438         case R_PPC64_TLSGD:
5439         case R_PPC64_TLSLD:
5440           /* These special tls relocs tie a call to __tls_get_addr with
5441              its parameter symbol.  */
5442           break;
5443
5444         case R_PPC64_GOT_TLSLD16:
5445         case R_PPC64_GOT_TLSLD16_LO:
5446         case R_PPC64_GOT_TLSLD16_HI:
5447         case R_PPC64_GOT_TLSLD16_HA:
5448           tls_type = TLS_TLS | TLS_LD;
5449           goto dogottls;
5450
5451         case R_PPC64_GOT_TLSGD16:
5452         case R_PPC64_GOT_TLSGD16_LO:
5453         case R_PPC64_GOT_TLSGD16_HI:
5454         case R_PPC64_GOT_TLSGD16_HA:
5455           tls_type = TLS_TLS | TLS_GD;
5456           goto dogottls;
5457
5458         case R_PPC64_GOT_TPREL16_DS:
5459         case R_PPC64_GOT_TPREL16_LO_DS:
5460         case R_PPC64_GOT_TPREL16_HI:
5461         case R_PPC64_GOT_TPREL16_HA:
5462           if (bfd_link_pic (info))
5463             info->flags |= DF_STATIC_TLS;
5464           tls_type = TLS_TLS | TLS_TPREL;
5465           goto dogottls;
5466
5467         case R_PPC64_GOT_DTPREL16_DS:
5468         case R_PPC64_GOT_DTPREL16_LO_DS:
5469         case R_PPC64_GOT_DTPREL16_HI:
5470         case R_PPC64_GOT_DTPREL16_HA:
5471           tls_type = TLS_TLS | TLS_DTPREL;
5472         dogottls:
5473           sec->has_tls_reloc = 1;
5474           /* Fall through */
5475
5476         case R_PPC64_GOT16:
5477         case R_PPC64_GOT16_DS:
5478         case R_PPC64_GOT16_HA:
5479         case R_PPC64_GOT16_HI:
5480         case R_PPC64_GOT16_LO:
5481         case R_PPC64_GOT16_LO_DS:
5482           /* This symbol requires a global offset table entry.  */
5483           sec->has_toc_reloc = 1;
5484           if (r_type == R_PPC64_GOT_TLSLD16
5485               || r_type == R_PPC64_GOT_TLSGD16
5486               || r_type == R_PPC64_GOT_TPREL16_DS
5487               || r_type == R_PPC64_GOT_DTPREL16_DS
5488               || r_type == R_PPC64_GOT16
5489               || r_type == R_PPC64_GOT16_DS)
5490             {
5491               htab->do_multi_toc = 1;
5492               ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5493             }
5494
5495           if (ppc64_elf_tdata (abfd)->got == NULL
5496               && !create_got_section (abfd, info))
5497             return FALSE;
5498
5499           if (h != NULL)
5500             {
5501               struct ppc_link_hash_entry *eh;
5502               struct got_entry *ent;
5503
5504               eh = (struct ppc_link_hash_entry *) h;
5505               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5506                 if (ent->addend == rel->r_addend
5507                     && ent->owner == abfd
5508                     && ent->tls_type == tls_type)
5509                   break;
5510               if (ent == NULL)
5511                 {
5512                   bfd_size_type amt = sizeof (*ent);
5513                   ent = bfd_alloc (abfd, amt);
5514                   if (ent == NULL)
5515                     return FALSE;
5516                   ent->next = eh->elf.got.glist;
5517                   ent->addend = rel->r_addend;
5518                   ent->owner = abfd;
5519                   ent->tls_type = tls_type;
5520                   ent->is_indirect = FALSE;
5521                   ent->got.refcount = 0;
5522                   eh->elf.got.glist = ent;
5523                 }
5524               ent->got.refcount += 1;
5525               eh->tls_mask |= tls_type;
5526             }
5527           else
5528             /* This is a global offset table entry for a local symbol.  */
5529             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5530                                         rel->r_addend, tls_type))
5531               return FALSE;
5532
5533           /* We may also need a plt entry if the symbol turns out to be
5534              an ifunc.  */
5535           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1)
5536             {
5537               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5538                 return FALSE;
5539             }
5540           break;
5541
5542         case R_PPC64_PLT16_HA:
5543         case R_PPC64_PLT16_HI:
5544         case R_PPC64_PLT16_LO:
5545         case R_PPC64_PLT32:
5546         case R_PPC64_PLT64:
5547           /* This symbol requires a procedure linkage table entry.  */
5548           plt_list = ifunc;
5549           if (h != NULL)
5550             {
5551               h->needs_plt = 1;
5552               if (h->root.root.string[0] == '.'
5553                   && h->root.root.string[1] != '\0')
5554                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5555               plt_list = &h->plt.plist;
5556             }
5557           if (plt_list == NULL)
5558             {
5559               /* It does not make sense to have a procedure linkage
5560                  table entry for a non-ifunc local symbol.  */
5561               info->callbacks->einfo
5562                 (_("%P: %H: %s reloc against local symbol\n"),
5563                  abfd, sec, rel->r_offset,
5564                  ppc64_elf_howto_table[r_type]->name);
5565               bfd_set_error (bfd_error_bad_value);
5566               return FALSE;
5567             }
5568           if (!update_plt_info (abfd, plt_list, rel->r_addend))
5569             return FALSE;
5570           break;
5571
5572           /* The following relocations don't need to propagate the
5573              relocation if linking a shared object since they are
5574              section relative.  */
5575         case R_PPC64_SECTOFF:
5576         case R_PPC64_SECTOFF_LO:
5577         case R_PPC64_SECTOFF_HI:
5578         case R_PPC64_SECTOFF_HA:
5579         case R_PPC64_SECTOFF_DS:
5580         case R_PPC64_SECTOFF_LO_DS:
5581         case R_PPC64_DTPREL16:
5582         case R_PPC64_DTPREL16_LO:
5583         case R_PPC64_DTPREL16_HI:
5584         case R_PPC64_DTPREL16_HA:
5585         case R_PPC64_DTPREL16_DS:
5586         case R_PPC64_DTPREL16_LO_DS:
5587         case R_PPC64_DTPREL16_HIGH:
5588         case R_PPC64_DTPREL16_HIGHA:
5589         case R_PPC64_DTPREL16_HIGHER:
5590         case R_PPC64_DTPREL16_HIGHERA:
5591         case R_PPC64_DTPREL16_HIGHEST:
5592         case R_PPC64_DTPREL16_HIGHESTA:
5593           break;
5594
5595           /* Nor do these.  */
5596         case R_PPC64_REL16:
5597         case R_PPC64_REL16_LO:
5598         case R_PPC64_REL16_HI:
5599         case R_PPC64_REL16_HA:
5600         case R_PPC64_REL16DX_HA:
5601           break;
5602
5603           /* Not supported as a dynamic relocation.  */
5604         case R_PPC64_ADDR64_LOCAL:
5605           if (bfd_link_pic (info))
5606             {
5607               if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5608                 ppc_howto_init ();
5609               info->callbacks->einfo (_("%P: %H: %s reloc unsupported "
5610                                         "in shared libraries and PIEs.\n"),
5611                                       abfd, sec, rel->r_offset,
5612                                       ppc64_elf_howto_table[r_type]->name);
5613               bfd_set_error (bfd_error_bad_value);
5614               return FALSE;
5615             }
5616           break;
5617
5618         case R_PPC64_TOC16:
5619         case R_PPC64_TOC16_DS:
5620           htab->do_multi_toc = 1;
5621           ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5622           /* Fall through.  */
5623         case R_PPC64_TOC16_LO:
5624         case R_PPC64_TOC16_HI:
5625         case R_PPC64_TOC16_HA:
5626         case R_PPC64_TOC16_LO_DS:
5627           sec->has_toc_reloc = 1;
5628           break;
5629
5630           /* Marker reloc.  */
5631         case R_PPC64_ENTRY:
5632           break;
5633
5634           /* This relocation describes the C++ object vtable hierarchy.
5635              Reconstruct it for later use during GC.  */
5636         case R_PPC64_GNU_VTINHERIT:
5637           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5638             return FALSE;
5639           break;
5640
5641           /* This relocation describes which C++ vtable entries are actually
5642              used.  Record for later use during GC.  */
5643         case R_PPC64_GNU_VTENTRY:
5644           BFD_ASSERT (h != NULL);
5645           if (h != NULL
5646               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5647             return FALSE;
5648           break;
5649
5650         case R_PPC64_REL14:
5651         case R_PPC64_REL14_BRTAKEN:
5652         case R_PPC64_REL14_BRNTAKEN:
5653           {
5654             asection *dest = NULL;
5655
5656             /* Heuristic: If jumping outside our section, chances are
5657                we are going to need a stub.  */
5658             if (h != NULL)
5659               {
5660                 /* If the sym is weak it may be overridden later, so
5661                    don't assume we know where a weak sym lives.  */
5662                 if (h->root.type == bfd_link_hash_defined)
5663                   dest = h->root.u.def.section;
5664               }
5665             else
5666               {
5667                 Elf_Internal_Sym *isym;
5668
5669                 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5670                                               abfd, r_symndx);
5671                 if (isym == NULL)
5672                   return FALSE;
5673
5674                 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5675               }
5676
5677             if (dest != sec)
5678               ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5679           }
5680           /* Fall through.  */
5681
5682         case R_PPC64_REL24:
5683           plt_list = ifunc;
5684           if (h != NULL)
5685             {
5686               h->needs_plt = 1;
5687               if (h->root.root.string[0] == '.'
5688                   && h->root.root.string[1] != '\0')
5689                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5690
5691               if (h == tga || h == dottga)
5692                 {
5693                   sec->has_tls_reloc = 1;
5694                   if (rel != relocs
5695                       && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5696                           || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5697                     /* We have a new-style __tls_get_addr call with
5698                        a marker reloc.  */
5699                     ;
5700                   else
5701                     /* Mark this section as having an old-style call.  */
5702                     sec->has_tls_get_addr_call = 1;
5703                 }
5704               plt_list = &h->plt.plist;
5705             }
5706
5707           /* We may need a .plt entry if the function this reloc
5708              refers to is in a shared lib.  */
5709           if (plt_list
5710               && !update_plt_info (abfd, plt_list, rel->r_addend))
5711             return FALSE;
5712           break;
5713
5714         case R_PPC64_ADDR14:
5715         case R_PPC64_ADDR14_BRNTAKEN:
5716         case R_PPC64_ADDR14_BRTAKEN:
5717         case R_PPC64_ADDR24:
5718           goto dodyn;
5719
5720         case R_PPC64_TPREL64:
5721           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5722           if (bfd_link_pic (info))
5723             info->flags |= DF_STATIC_TLS;
5724           goto dotlstoc;
5725
5726         case R_PPC64_DTPMOD64:
5727           if (rel + 1 < rel_end
5728               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5729               && rel[1].r_offset == rel->r_offset + 8)
5730             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5731           else
5732             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5733           goto dotlstoc;
5734
5735         case R_PPC64_DTPREL64:
5736           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5737           if (rel != relocs
5738               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5739               && rel[-1].r_offset == rel->r_offset - 8)
5740             /* This is the second reloc of a dtpmod, dtprel pair.
5741                Don't mark with TLS_DTPREL.  */
5742             goto dodyn;
5743
5744         dotlstoc:
5745           sec->has_tls_reloc = 1;
5746           if (h != NULL)
5747             {
5748               struct ppc_link_hash_entry *eh;
5749               eh = (struct ppc_link_hash_entry *) h;
5750               eh->tls_mask |= tls_type;
5751             }
5752           else
5753             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5754                                         rel->r_addend, tls_type))
5755               return FALSE;
5756
5757           ppc64_sec = ppc64_elf_section_data (sec);
5758           if (ppc64_sec->sec_type != sec_toc)
5759             {
5760               bfd_size_type amt;
5761
5762               /* One extra to simplify get_tls_mask.  */
5763               amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5764               ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5765               if (ppc64_sec->u.toc.symndx == NULL)
5766                 return FALSE;
5767               amt = sec->size * sizeof (bfd_vma) / 8;
5768               ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5769               if (ppc64_sec->u.toc.add == NULL)
5770                 return FALSE;
5771               BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5772               ppc64_sec->sec_type = sec_toc;
5773             }
5774           BFD_ASSERT (rel->r_offset % 8 == 0);
5775           ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5776           ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5777
5778           /* Mark the second slot of a GD or LD entry.
5779              -1 to indicate GD and -2 to indicate LD.  */
5780           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5781             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5782           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5783             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5784           goto dodyn;
5785
5786         case R_PPC64_TPREL16:
5787         case R_PPC64_TPREL16_LO:
5788         case R_PPC64_TPREL16_HI:
5789         case R_PPC64_TPREL16_HA:
5790         case R_PPC64_TPREL16_DS:
5791         case R_PPC64_TPREL16_LO_DS:
5792         case R_PPC64_TPREL16_HIGH:
5793         case R_PPC64_TPREL16_HIGHA:
5794         case R_PPC64_TPREL16_HIGHER:
5795         case R_PPC64_TPREL16_HIGHERA:
5796         case R_PPC64_TPREL16_HIGHEST:
5797         case R_PPC64_TPREL16_HIGHESTA:
5798           if (bfd_link_pic (info))
5799             {
5800               info->flags |= DF_STATIC_TLS;
5801               goto dodyn;
5802             }
5803           break;
5804
5805         case R_PPC64_ADDR64:
5806           if (opd_sym_map != NULL
5807               && rel + 1 < rel_end
5808               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5809             {
5810               if (h != NULL)
5811                 {
5812                   if (h->root.root.string[0] == '.'
5813                       && h->root.root.string[1] != 0
5814                       && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
5815                     ;
5816                   else
5817                     ((struct ppc_link_hash_entry *) h)->is_func = 1;
5818                 }
5819               else
5820                 {
5821                   asection *s;
5822                   Elf_Internal_Sym *isym;
5823
5824                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5825                                                 abfd, r_symndx);
5826                   if (isym == NULL)
5827                     return FALSE;
5828
5829                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5830                   if (s != NULL && s != sec)
5831                     opd_sym_map[OPD_NDX (rel->r_offset)] = s;
5832                 }
5833             }
5834           /* Fall through.  */
5835
5836         case R_PPC64_ADDR16:
5837         case R_PPC64_ADDR16_DS:
5838         case R_PPC64_ADDR16_HA:
5839         case R_PPC64_ADDR16_HI:
5840         case R_PPC64_ADDR16_HIGH:
5841         case R_PPC64_ADDR16_HIGHA:
5842         case R_PPC64_ADDR16_HIGHER:
5843         case R_PPC64_ADDR16_HIGHERA:
5844         case R_PPC64_ADDR16_HIGHEST:
5845         case R_PPC64_ADDR16_HIGHESTA:
5846         case R_PPC64_ADDR16_LO:
5847         case R_PPC64_ADDR16_LO_DS:
5848           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1
5849               && rel->r_addend == 0)
5850             {
5851               /* We may need a .plt entry if this reloc refers to a
5852                  function in a shared lib.  */
5853               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5854                 return FALSE;
5855               h->pointer_equality_needed = 1;
5856             }
5857           /* Fall through.  */
5858
5859         case R_PPC64_REL30:
5860         case R_PPC64_REL32:
5861         case R_PPC64_REL64:
5862         case R_PPC64_ADDR32:
5863         case R_PPC64_UADDR16:
5864         case R_PPC64_UADDR32:
5865         case R_PPC64_UADDR64:
5866         case R_PPC64_TOC:
5867           if (h != NULL && !bfd_link_pic (info))
5868             /* We may need a copy reloc.  */
5869             h->non_got_ref = 1;
5870
5871           /* Don't propagate .opd relocs.  */
5872           if (NO_OPD_RELOCS && opd_sym_map != NULL)
5873             break;
5874
5875           /* If we are creating a shared library, and this is a reloc
5876              against a global symbol, or a non PC relative reloc
5877              against a local symbol, then we need to copy the reloc
5878              into the shared library.  However, if we are linking with
5879              -Bsymbolic, we do not need to copy a reloc against a
5880              global symbol which is defined in an object we are
5881              including in the link (i.e., DEF_REGULAR is set).  At
5882              this point we have not seen all the input files, so it is
5883              possible that DEF_REGULAR is not set now but will be set
5884              later (it is never cleared).  In case of a weak definition,
5885              DEF_REGULAR may be cleared later by a strong definition in
5886              a shared library.  We account for that possibility below by
5887              storing information in the dyn_relocs field of the hash
5888              table entry.  A similar situation occurs when creating
5889              shared libraries and symbol visibility changes render the
5890              symbol local.
5891
5892              If on the other hand, we are creating an executable, we
5893              may need to keep relocations for symbols satisfied by a
5894              dynamic library if we manage to avoid copy relocs for the
5895              symbol.  */
5896         dodyn:
5897           if ((bfd_link_pic (info)
5898                && (must_be_dyn_reloc (info, r_type)
5899                    || (h != NULL
5900                        && (!SYMBOLIC_BIND (info, h)
5901                            || h->root.type == bfd_link_hash_defweak
5902                            || !h->def_regular))))
5903               || (ELIMINATE_COPY_RELOCS
5904                   && !bfd_link_pic (info)
5905                   && h != NULL
5906                   && (h->root.type == bfd_link_hash_defweak
5907                       || !h->def_regular))
5908               || (!bfd_link_pic (info)
5909                   && ifunc != NULL))
5910             {
5911               /* We must copy these reloc types into the output file.
5912                  Create a reloc section in dynobj and make room for
5913                  this reloc.  */
5914               if (sreloc == NULL)
5915                 {
5916                   sreloc = _bfd_elf_make_dynamic_reloc_section
5917                     (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5918
5919                   if (sreloc == NULL)
5920                     return FALSE;
5921                 }
5922
5923               /* If this is a global symbol, we count the number of
5924                  relocations we need for this symbol.  */
5925               if (h != NULL)
5926                 {
5927                   struct elf_dyn_relocs *p;
5928                   struct elf_dyn_relocs **head;
5929
5930                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5931                   p = *head;
5932                   if (p == NULL || p->sec != sec)
5933                     {
5934                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5935                       if (p == NULL)
5936                         return FALSE;
5937                       p->next = *head;
5938                       *head = p;
5939                       p->sec = sec;
5940                       p->count = 0;
5941                       p->pc_count = 0;
5942                     }
5943                   p->count += 1;
5944                   if (!must_be_dyn_reloc (info, r_type))
5945                     p->pc_count += 1;
5946                 }
5947               else
5948                 {
5949                   /* Track dynamic relocs needed for local syms too.
5950                      We really need local syms available to do this
5951                      easily.  Oh well.  */
5952                   struct ppc_dyn_relocs *p;
5953                   struct ppc_dyn_relocs **head;
5954                   bfd_boolean is_ifunc;
5955                   asection *s;
5956                   void *vpp;
5957                   Elf_Internal_Sym *isym;
5958
5959                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5960                                                 abfd, r_symndx);
5961                   if (isym == NULL)
5962                     return FALSE;
5963
5964                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5965                   if (s == NULL)
5966                     s = sec;
5967
5968                   vpp = &elf_section_data (s)->local_dynrel;
5969                   head = (struct ppc_dyn_relocs **) vpp;
5970                   is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5971                   p = *head;
5972                   if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5973                     p = p->next;
5974                   if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5975                     {
5976                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5977                       if (p == NULL)
5978                         return FALSE;
5979                       p->next = *head;
5980                       *head = p;
5981                       p->sec = sec;
5982                       p->ifunc = is_ifunc;
5983                       p->count = 0;
5984                     }
5985                   p->count += 1;
5986                 }
5987             }
5988           break;
5989
5990         default:
5991           break;
5992         }
5993     }
5994
5995   return TRUE;
5996 }
5997
5998 /* Merge backend specific data from an object file to the output
5999    object file when linking.  */
6000
6001 static bfd_boolean
6002 ppc64_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
6003 {
6004   bfd *obfd = info->output_bfd;
6005   unsigned long iflags, oflags;
6006
6007   if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
6008     return TRUE;
6009
6010   if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
6011     return TRUE;
6012
6013   if (!_bfd_generic_verify_endian_match (ibfd, info))
6014     return FALSE;
6015
6016   iflags = elf_elfheader (ibfd)->e_flags;
6017   oflags = elf_elfheader (obfd)->e_flags;
6018
6019   if (iflags & ~EF_PPC64_ABI)
6020     {
6021       _bfd_error_handler
6022         (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
6023       bfd_set_error (bfd_error_bad_value);
6024       return FALSE;
6025     }
6026   else if (iflags != oflags && iflags != 0)
6027     {
6028       _bfd_error_handler
6029         (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
6030          ibfd, iflags, oflags);
6031       bfd_set_error (bfd_error_bad_value);
6032       return FALSE;
6033     }
6034
6035   _bfd_elf_ppc_merge_fp_attributes (ibfd, info);
6036
6037   /* Merge Tag_compatibility attributes and any common GNU ones.  */
6038   _bfd_elf_merge_object_attributes (ibfd, info);
6039
6040   return TRUE;
6041 }
6042
6043 static bfd_boolean
6044 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
6045 {
6046   /* Print normal ELF private data.  */
6047   _bfd_elf_print_private_bfd_data (abfd, ptr);
6048
6049   if (elf_elfheader (abfd)->e_flags != 0)
6050     {
6051       FILE *file = ptr;
6052
6053       /* xgettext:c-format */
6054       fprintf (file, _("private flags = 0x%lx:"),
6055                elf_elfheader (abfd)->e_flags);
6056
6057       if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
6058         fprintf (file, _(" [abiv%ld]"),
6059                  elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
6060       fputc ('\n', file);
6061     }
6062
6063   return TRUE;
6064 }
6065
6066 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
6067    of the code entry point, and its section, which must be in the same
6068    object as OPD_SEC.  Returns (bfd_vma) -1 on error.  */
6069
6070 static bfd_vma
6071 opd_entry_value (asection *opd_sec,
6072                  bfd_vma offset,
6073                  asection **code_sec,
6074                  bfd_vma *code_off,
6075                  bfd_boolean in_code_sec)
6076 {
6077   bfd *opd_bfd = opd_sec->owner;
6078   Elf_Internal_Rela *relocs;
6079   Elf_Internal_Rela *lo, *hi, *look;
6080   bfd_vma val;
6081
6082   /* No relocs implies we are linking a --just-symbols object, or looking
6083      at a final linked executable with addr2line or somesuch.  */
6084   if (opd_sec->reloc_count == 0)
6085     {
6086       bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
6087
6088       if (contents == NULL)
6089         {
6090           if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
6091             return (bfd_vma) -1;
6092           ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
6093         }
6094
6095       /* PR 17512: file: 64b9dfbb.  */
6096       if (offset + 7 >= opd_sec->size || offset + 7 < offset)
6097         return (bfd_vma) -1;
6098
6099       val = bfd_get_64 (opd_bfd, contents + offset);
6100       if (code_sec != NULL)
6101         {
6102           asection *sec, *likely = NULL;
6103
6104           if (in_code_sec)
6105             {
6106               sec = *code_sec;
6107               if (sec->vma <= val
6108                   && val < sec->vma + sec->size)
6109                 likely = sec;
6110               else
6111                 val = -1;
6112             }
6113           else
6114             for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
6115               if (sec->vma <= val
6116                   && (sec->flags & SEC_LOAD) != 0
6117                   && (sec->flags & SEC_ALLOC) != 0)
6118                 likely = sec;
6119           if (likely != NULL)
6120             {
6121               *code_sec = likely;
6122               if (code_off != NULL)
6123                 *code_off = val - likely->vma;
6124             }
6125         }
6126       return val;
6127     }
6128
6129   BFD_ASSERT (is_ppc64_elf (opd_bfd));
6130
6131   relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
6132   if (relocs == NULL)
6133     relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
6134   /* PR 17512: file: df8e1fd6.  */
6135   if (relocs == NULL)
6136     return (bfd_vma) -1;
6137
6138   /* Go find the opd reloc at the sym address.  */
6139   lo = relocs;
6140   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
6141   val = (bfd_vma) -1;
6142   while (lo < hi)
6143     {
6144       look = lo + (hi - lo) / 2;
6145       if (look->r_offset < offset)
6146         lo = look + 1;
6147       else if (look->r_offset > offset)
6148         hi = look;
6149       else
6150         {
6151           Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
6152
6153           if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
6154               && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
6155             {
6156               unsigned long symndx = ELF64_R_SYM (look->r_info);
6157               asection *sec = NULL;
6158
6159               if (symndx >= symtab_hdr->sh_info
6160                   && elf_sym_hashes (opd_bfd) != NULL)
6161                 {
6162                   struct elf_link_hash_entry **sym_hashes;
6163                   struct elf_link_hash_entry *rh;
6164
6165                   sym_hashes = elf_sym_hashes (opd_bfd);
6166                   rh = sym_hashes[symndx - symtab_hdr->sh_info];
6167                   if (rh != NULL)
6168                     {
6169                       rh = elf_follow_link (rh);
6170                       if (rh->root.type != bfd_link_hash_defined
6171                           && rh->root.type != bfd_link_hash_defweak)
6172                         break;
6173                       if (rh->root.u.def.section->owner == opd_bfd)
6174                         {
6175                           val = rh->root.u.def.value;
6176                           sec = rh->root.u.def.section;
6177                         }
6178                     }
6179                 }
6180
6181               if (sec == NULL)
6182                 {
6183                   Elf_Internal_Sym *sym;
6184
6185                   if (symndx < symtab_hdr->sh_info)
6186                     {
6187                       sym = (Elf_Internal_Sym *) symtab_hdr->contents;
6188                       if (sym == NULL)
6189                         {
6190                           size_t symcnt = symtab_hdr->sh_info;
6191                           sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6192                                                       symcnt, 0,
6193                                                       NULL, NULL, NULL);
6194                           if (sym == NULL)
6195                             break;
6196                           symtab_hdr->contents = (bfd_byte *) sym;
6197                         }
6198                       sym += symndx;
6199                     }
6200                   else
6201                     {
6202                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6203                                                   1, symndx,
6204                                                   NULL, NULL, NULL);
6205                       if (sym == NULL)
6206                         break;
6207                     }
6208                   sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6209                   if (sec == NULL)
6210                     break;
6211                   BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
6212                   val = sym->st_value;
6213                 }
6214
6215               val += look->r_addend;
6216               if (code_off != NULL)
6217                 *code_off = val;
6218               if (code_sec != NULL)
6219                 {
6220                   if (in_code_sec && *code_sec != sec)
6221                     return -1;
6222                   else
6223                     *code_sec = sec;
6224                 }
6225               if (sec->output_section != NULL)
6226                 val += sec->output_section->vma + sec->output_offset;
6227             }
6228           break;
6229         }
6230     }
6231
6232   return val;
6233 }
6234
6235 /* If the ELF symbol SYM might be a function in SEC, return the
6236    function size and set *CODE_OFF to the function's entry point,
6237    otherwise return zero.  */
6238
6239 static bfd_size_type
6240 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6241                               bfd_vma *code_off)
6242 {
6243   bfd_size_type size;
6244
6245   if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6246                      | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6247     return 0;
6248
6249   size = 0;
6250   if (!(sym->flags & BSF_SYNTHETIC))
6251     size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6252
6253   if (strcmp (sym->section->name, ".opd") == 0)
6254     {
6255       struct _opd_sec_data *opd = get_opd_info (sym->section);
6256       bfd_vma symval = sym->value;
6257
6258       if (opd != NULL
6259           && opd->adjust != NULL
6260           && elf_section_data (sym->section)->relocs != NULL)
6261         {
6262           /* opd_entry_value will use cached relocs that have been
6263              adjusted, but with raw symbols.  That means both local
6264              and global symbols need adjusting.  */
6265           long adjust = opd->adjust[OPD_NDX (symval)];
6266           if (adjust == -1)
6267             return 0;
6268           symval += adjust;
6269         }
6270
6271       if (opd_entry_value (sym->section, symval,
6272                            &sec, code_off, TRUE) == (bfd_vma) -1)
6273         return 0;
6274       /* An old ABI binary with dot-syms has a size of 24 on the .opd
6275          symbol.  This size has nothing to do with the code size of the
6276          function, which is what we're supposed to return, but the
6277          code size isn't available without looking up the dot-sym.
6278          However, doing that would be a waste of time particularly
6279          since elf_find_function will look at the dot-sym anyway.
6280          Now, elf_find_function will keep the largest size of any
6281          function sym found at the code address of interest, so return
6282          1 here to avoid it incorrectly caching a larger function size
6283          for a small function.  This does mean we return the wrong
6284          size for a new-ABI function of size 24, but all that does is
6285          disable caching for such functions.  */
6286       if (size == 24)
6287         size = 1;
6288     }
6289   else
6290     {
6291       if (sym->section != sec)
6292         return 0;
6293       *code_off = sym->value;
6294     }
6295   if (size == 0)
6296     size = 1;
6297   return size;
6298 }
6299
6300 /* Return true if symbol is defined in a regular object file.  */
6301
6302 static bfd_boolean
6303 is_static_defined (struct elf_link_hash_entry *h)
6304 {
6305   return ((h->root.type == bfd_link_hash_defined
6306            || h->root.type == bfd_link_hash_defweak)
6307           && h->root.u.def.section != NULL
6308           && h->root.u.def.section->output_section != NULL);
6309 }
6310
6311 /* If FDH is a function descriptor symbol, return the associated code
6312    entry symbol if it is defined.  Return NULL otherwise.  */
6313
6314 static struct ppc_link_hash_entry *
6315 defined_code_entry (struct ppc_link_hash_entry *fdh)
6316 {
6317   if (fdh->is_func_descriptor)
6318     {
6319       struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6320       if (fh->elf.root.type == bfd_link_hash_defined
6321           || fh->elf.root.type == bfd_link_hash_defweak)
6322         return fh;
6323     }
6324   return NULL;
6325 }
6326
6327 /* If FH is a function code entry symbol, return the associated
6328    function descriptor symbol if it is defined.  Return NULL otherwise.  */
6329
6330 static struct ppc_link_hash_entry *
6331 defined_func_desc (struct ppc_link_hash_entry *fh)
6332 {
6333   if (fh->oh != NULL
6334       && fh->oh->is_func_descriptor)
6335     {
6336       struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6337       if (fdh->elf.root.type == bfd_link_hash_defined
6338           || fdh->elf.root.type == bfd_link_hash_defweak)
6339         return fdh;
6340     }
6341   return NULL;
6342 }
6343
6344 /* Mark all our entry sym sections, both opd and code section.  */
6345
6346 static void
6347 ppc64_elf_gc_keep (struct bfd_link_info *info)
6348 {
6349   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6350   struct bfd_sym_chain *sym;
6351
6352   if (htab == NULL)
6353     return;
6354
6355   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6356     {
6357       struct ppc_link_hash_entry *eh, *fh;
6358       asection *sec;
6359
6360       eh = (struct ppc_link_hash_entry *)
6361         elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6362       if (eh == NULL)
6363         continue;
6364       if (eh->elf.root.type != bfd_link_hash_defined
6365           && eh->elf.root.type != bfd_link_hash_defweak)
6366         continue;
6367
6368       fh = defined_code_entry (eh);
6369       if (fh != NULL)
6370         {
6371           sec = fh->elf.root.u.def.section;
6372           sec->flags |= SEC_KEEP;
6373         }
6374       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6375                && opd_entry_value (eh->elf.root.u.def.section,
6376                                    eh->elf.root.u.def.value,
6377                                    &sec, NULL, FALSE) != (bfd_vma) -1)
6378         sec->flags |= SEC_KEEP;
6379
6380       sec = eh->elf.root.u.def.section;
6381       sec->flags |= SEC_KEEP;
6382     }
6383 }
6384
6385 /* Mark sections containing dynamically referenced symbols.  When
6386    building shared libraries, we must assume that any visible symbol is
6387    referenced.  */
6388
6389 static bfd_boolean
6390 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6391 {
6392   struct bfd_link_info *info = (struct bfd_link_info *) inf;
6393   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6394   struct ppc_link_hash_entry *fdh;
6395   struct bfd_elf_dynamic_list *d = info->dynamic_list;
6396
6397   /* Dynamic linking info is on the func descriptor sym.  */
6398   fdh = defined_func_desc (eh);
6399   if (fdh != NULL)
6400     eh = fdh;
6401
6402   if ((eh->elf.root.type == bfd_link_hash_defined
6403        || eh->elf.root.type == bfd_link_hash_defweak)
6404       && (eh->elf.ref_dynamic
6405           || ((eh->elf.def_regular || ELF_COMMON_DEF_P (&eh->elf))
6406               && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6407               && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6408               && (!bfd_link_executable (info)
6409                   || info->export_dynamic
6410                   || (eh->elf.dynamic
6411                       && d != NULL
6412                       && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
6413               && (strchr (eh->elf.root.root.string, ELF_VER_CHR) != NULL
6414                   || !bfd_hide_sym_by_version (info->version_info,
6415                                                eh->elf.root.root.string)))))
6416     {
6417       asection *code_sec;
6418       struct ppc_link_hash_entry *fh;
6419
6420       eh->elf.root.u.def.section->flags |= SEC_KEEP;
6421
6422       /* Function descriptor syms cause the associated
6423          function code sym section to be marked.  */
6424       fh = defined_code_entry (eh);
6425       if (fh != NULL)
6426         {
6427           code_sec = fh->elf.root.u.def.section;
6428           code_sec->flags |= SEC_KEEP;
6429         }
6430       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6431                && opd_entry_value (eh->elf.root.u.def.section,
6432                                    eh->elf.root.u.def.value,
6433                                    &code_sec, NULL, FALSE) != (bfd_vma) -1)
6434         code_sec->flags |= SEC_KEEP;
6435     }
6436
6437   return TRUE;
6438 }
6439
6440 /* Return the section that should be marked against GC for a given
6441    relocation.  */
6442
6443 static asection *
6444 ppc64_elf_gc_mark_hook (asection *sec,
6445                         struct bfd_link_info *info,
6446                         Elf_Internal_Rela *rel,
6447                         struct elf_link_hash_entry *h,
6448                         Elf_Internal_Sym *sym)
6449 {
6450   asection *rsec;
6451
6452   /* Syms return NULL if we're marking .opd, so we avoid marking all
6453      function sections, as all functions are referenced in .opd.  */
6454   rsec = NULL;
6455   if (get_opd_info (sec) != NULL)
6456     return rsec;
6457
6458   if (h != NULL)
6459     {
6460       enum elf_ppc64_reloc_type r_type;
6461       struct ppc_link_hash_entry *eh, *fh, *fdh;
6462
6463       r_type = ELF64_R_TYPE (rel->r_info);
6464       switch (r_type)
6465         {
6466         case R_PPC64_GNU_VTINHERIT:
6467         case R_PPC64_GNU_VTENTRY:
6468           break;
6469
6470         default:
6471           switch (h->root.type)
6472             {
6473             case bfd_link_hash_defined:
6474             case bfd_link_hash_defweak:
6475               eh = (struct ppc_link_hash_entry *) h;
6476               fdh = defined_func_desc (eh);
6477               if (fdh != NULL)
6478                 eh = fdh;
6479
6480               /* Function descriptor syms cause the associated
6481                  function code sym section to be marked.  */
6482               fh = defined_code_entry (eh);
6483               if (fh != NULL)
6484                 {
6485                   /* They also mark their opd section.  */
6486                   eh->elf.root.u.def.section->gc_mark = 1;
6487
6488                   rsec = fh->elf.root.u.def.section;
6489                 }
6490               else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6491                        && opd_entry_value (eh->elf.root.u.def.section,
6492                                            eh->elf.root.u.def.value,
6493                                            &rsec, NULL, FALSE) != (bfd_vma) -1)
6494                 eh->elf.root.u.def.section->gc_mark = 1;
6495               else
6496                 rsec = h->root.u.def.section;
6497               break;
6498
6499             case bfd_link_hash_common:
6500               rsec = h->root.u.c.p->section;
6501               break;
6502
6503             default:
6504               return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6505             }
6506         }
6507     }
6508   else
6509     {
6510       struct _opd_sec_data *opd;
6511
6512       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6513       opd = get_opd_info (rsec);
6514       if (opd != NULL && opd->func_sec != NULL)
6515         {
6516           rsec->gc_mark = 1;
6517
6518           rsec = opd->func_sec[OPD_NDX (sym->st_value + rel->r_addend)];
6519         }
6520     }
6521
6522   return rsec;
6523 }
6524
6525 /* Update the .got, .plt. and dynamic reloc reference counts for the
6526    section being removed.  */
6527
6528 static bfd_boolean
6529 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
6530                          asection *sec, const Elf_Internal_Rela *relocs)
6531 {
6532   struct ppc_link_hash_table *htab;
6533   Elf_Internal_Shdr *symtab_hdr;
6534   struct elf_link_hash_entry **sym_hashes;
6535   struct got_entry **local_got_ents;
6536   const Elf_Internal_Rela *rel, *relend;
6537
6538   if (bfd_link_relocatable (info))
6539     return TRUE;
6540
6541   if ((sec->flags & SEC_ALLOC) == 0)
6542     return TRUE;
6543
6544   elf_section_data (sec)->local_dynrel = NULL;
6545
6546   htab = ppc_hash_table (info);
6547   if (htab == NULL)
6548     return FALSE;
6549
6550   symtab_hdr = &elf_symtab_hdr (abfd);
6551   sym_hashes = elf_sym_hashes (abfd);
6552   local_got_ents = elf_local_got_ents (abfd);
6553
6554   relend = relocs + sec->reloc_count;
6555   for (rel = relocs; rel < relend; rel++)
6556     {
6557       unsigned long r_symndx;
6558       enum elf_ppc64_reloc_type r_type;
6559       struct elf_link_hash_entry *h = NULL;
6560       struct plt_entry **plt_list;
6561       unsigned char tls_type = 0;
6562
6563       r_symndx = ELF64_R_SYM (rel->r_info);
6564       r_type = ELF64_R_TYPE (rel->r_info);
6565       if (r_symndx >= symtab_hdr->sh_info)
6566         {
6567           struct ppc_link_hash_entry *eh;
6568           struct elf_dyn_relocs **pp;
6569           struct elf_dyn_relocs *p;
6570
6571           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6572           h = elf_follow_link (h);
6573           eh = (struct ppc_link_hash_entry *) h;
6574
6575           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6576             if (p->sec == sec)
6577               {
6578                 /* Everything must go for SEC.  */
6579                 *pp = p->next;
6580                 break;
6581               }
6582         }
6583
6584       switch (r_type)
6585         {
6586         case R_PPC64_GOT_TLSLD16:
6587         case R_PPC64_GOT_TLSLD16_LO:
6588         case R_PPC64_GOT_TLSLD16_HI:
6589         case R_PPC64_GOT_TLSLD16_HA:
6590           tls_type = TLS_TLS | TLS_LD;
6591           goto dogot;
6592
6593         case R_PPC64_GOT_TLSGD16:
6594         case R_PPC64_GOT_TLSGD16_LO:
6595         case R_PPC64_GOT_TLSGD16_HI:
6596         case R_PPC64_GOT_TLSGD16_HA:
6597           tls_type = TLS_TLS | TLS_GD;
6598           goto dogot;
6599
6600         case R_PPC64_GOT_TPREL16_DS:
6601         case R_PPC64_GOT_TPREL16_LO_DS:
6602         case R_PPC64_GOT_TPREL16_HI:
6603         case R_PPC64_GOT_TPREL16_HA:
6604           tls_type = TLS_TLS | TLS_TPREL;
6605           goto dogot;
6606
6607         case R_PPC64_GOT_DTPREL16_DS:
6608         case R_PPC64_GOT_DTPREL16_LO_DS:
6609         case R_PPC64_GOT_DTPREL16_HI:
6610         case R_PPC64_GOT_DTPREL16_HA:
6611           tls_type = TLS_TLS | TLS_DTPREL;
6612           goto dogot;
6613
6614         case R_PPC64_GOT16:
6615         case R_PPC64_GOT16_DS:
6616         case R_PPC64_GOT16_HA:
6617         case R_PPC64_GOT16_HI:
6618         case R_PPC64_GOT16_LO:
6619         case R_PPC64_GOT16_LO_DS:
6620         dogot:
6621           {
6622             struct got_entry *ent;
6623
6624             if (h != NULL)
6625               ent = h->got.glist;
6626             else
6627               ent = local_got_ents[r_symndx];
6628
6629             for (; ent != NULL; ent = ent->next)
6630               if (ent->addend == rel->r_addend
6631                   && ent->owner == abfd
6632                   && ent->tls_type == tls_type)
6633                 break;
6634             if (ent == NULL)
6635               abort ();
6636             if (ent->got.refcount > 0)
6637               ent->got.refcount -= 1;
6638           }
6639           break;
6640
6641         case R_PPC64_PLT16_HA:
6642         case R_PPC64_PLT16_HI:
6643         case R_PPC64_PLT16_LO:
6644         case R_PPC64_PLT32:
6645         case R_PPC64_PLT64:
6646         case R_PPC64_REL14:
6647         case R_PPC64_REL14_BRNTAKEN:
6648         case R_PPC64_REL14_BRTAKEN:
6649         case R_PPC64_REL24:
6650           plt_list = NULL;
6651           if (h != NULL)
6652             plt_list = &h->plt.plist;
6653           else if (local_got_ents != NULL)
6654             {
6655               struct plt_entry **local_plt = (struct plt_entry **)
6656                 (local_got_ents + symtab_hdr->sh_info);
6657               unsigned char *local_got_tls_masks = (unsigned char *)
6658                 (local_plt + symtab_hdr->sh_info);
6659               if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6660                 plt_list = local_plt + r_symndx;
6661             }
6662           if (plt_list)
6663             {
6664               struct plt_entry *ent;
6665
6666               for (ent = *plt_list; ent != NULL; ent = ent->next)
6667                 if (ent->addend == rel->r_addend)
6668                   break;
6669               if (ent != NULL && ent->plt.refcount > 0)
6670                 ent->plt.refcount -= 1;
6671             }
6672           break;
6673
6674         default:
6675           break;
6676         }
6677     }
6678   return TRUE;
6679 }
6680
6681 /* The maximum size of .sfpr.  */
6682 #define SFPR_MAX (218*4)
6683
6684 struct sfpr_def_parms
6685 {
6686   const char name[12];
6687   unsigned char lo, hi;
6688   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6689   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6690 };
6691
6692 /* Auto-generate _save*, _rest* functions in .sfpr.
6693    If STUB_SEC is non-null, define alias symbols in STUB_SEC
6694    instead.  */
6695
6696 static bfd_boolean
6697 sfpr_define (struct bfd_link_info *info,
6698              const struct sfpr_def_parms *parm,
6699              asection *stub_sec)
6700 {
6701   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6702   unsigned int i;
6703   size_t len = strlen (parm->name);
6704   bfd_boolean writing = FALSE;
6705   char sym[16];
6706
6707   if (htab == NULL)
6708     return FALSE;
6709
6710   memcpy (sym, parm->name, len);
6711   sym[len + 2] = 0;
6712
6713   for (i = parm->lo; i <= parm->hi; i++)
6714     {
6715       struct ppc_link_hash_entry *h;
6716
6717       sym[len + 0] = i / 10 + '0';
6718       sym[len + 1] = i % 10 + '0';
6719       h = (struct ppc_link_hash_entry *)
6720         elf_link_hash_lookup (&htab->elf, sym, writing, TRUE, TRUE);
6721       if (stub_sec != NULL)
6722         {
6723           if (h != NULL
6724               && h->elf.root.type == bfd_link_hash_defined
6725               && h->elf.root.u.def.section == htab->sfpr)
6726             {
6727               struct elf_link_hash_entry *s;
6728               char buf[32];
6729               sprintf (buf, "%08x.%s", stub_sec->id & 0xffffffff, sym);
6730               s = elf_link_hash_lookup (&htab->elf, buf, TRUE, TRUE, FALSE);
6731               if (s == NULL)
6732                 return FALSE;
6733               if (s->root.type == bfd_link_hash_new
6734                   || (s->root.type = bfd_link_hash_defined
6735                       && s->root.u.def.section == stub_sec))
6736                 {
6737                   s->root.type = bfd_link_hash_defined;
6738                   s->root.u.def.section = stub_sec;
6739                   s->root.u.def.value = (stub_sec->size
6740                                          + h->elf.root.u.def.value);
6741                   s->ref_regular = 1;
6742                   s->def_regular = 1;
6743                   s->ref_regular_nonweak = 1;
6744                   s->forced_local = 1;
6745                   s->non_elf = 0;
6746                   s->root.linker_def = 1;
6747                 }
6748             }
6749           continue;
6750         }
6751       if (h != NULL)
6752         {
6753           h->save_res = 1;
6754           if (!h->elf.def_regular)
6755             {
6756               h->elf.root.type = bfd_link_hash_defined;
6757               h->elf.root.u.def.section = htab->sfpr;
6758               h->elf.root.u.def.value = htab->sfpr->size;
6759               h->elf.type = STT_FUNC;
6760               h->elf.def_regular = 1;
6761               h->elf.non_elf = 0;
6762               _bfd_elf_link_hash_hide_symbol (info, &h->elf, TRUE);
6763               writing = TRUE;
6764               if (htab->sfpr->contents == NULL)
6765                 {
6766                   htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6767                   if (htab->sfpr->contents == NULL)
6768                     return FALSE;
6769                 }
6770             }
6771         }
6772       if (writing)
6773         {
6774           bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6775           if (i != parm->hi)
6776             p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6777           else
6778             p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6779           htab->sfpr->size = p - htab->sfpr->contents;
6780         }
6781     }
6782
6783   return TRUE;
6784 }
6785
6786 static bfd_byte *
6787 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6788 {
6789   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6790   return p + 4;
6791 }
6792
6793 static bfd_byte *
6794 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6795 {
6796   p = savegpr0 (abfd, p, r);
6797   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6798   p = p + 4;
6799   bfd_put_32 (abfd, BLR, p);
6800   return p + 4;
6801 }
6802
6803 static bfd_byte *
6804 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6805 {
6806   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6807   return p + 4;
6808 }
6809
6810 static bfd_byte *
6811 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6812 {
6813   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6814   p = p + 4;
6815   p = restgpr0 (abfd, p, r);
6816   bfd_put_32 (abfd, MTLR_R0, p);
6817   p = p + 4;
6818   if (r == 29)
6819     {
6820       p = restgpr0 (abfd, p, 30);
6821       p = restgpr0 (abfd, p, 31);
6822     }
6823   bfd_put_32 (abfd, BLR, p);
6824   return p + 4;
6825 }
6826
6827 static bfd_byte *
6828 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6829 {
6830   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6831   return p + 4;
6832 }
6833
6834 static bfd_byte *
6835 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6836 {
6837   p = savegpr1 (abfd, p, r);
6838   bfd_put_32 (abfd, BLR, p);
6839   return p + 4;
6840 }
6841
6842 static bfd_byte *
6843 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6844 {
6845   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6846   return p + 4;
6847 }
6848
6849 static bfd_byte *
6850 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6851 {
6852   p = restgpr1 (abfd, p, r);
6853   bfd_put_32 (abfd, BLR, p);
6854   return p + 4;
6855 }
6856
6857 static bfd_byte *
6858 savefpr (bfd *abfd, bfd_byte *p, int r)
6859 {
6860   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6861   return p + 4;
6862 }
6863
6864 static bfd_byte *
6865 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6866 {
6867   p = savefpr (abfd, p, r);
6868   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6869   p = p + 4;
6870   bfd_put_32 (abfd, BLR, p);
6871   return p + 4;
6872 }
6873
6874 static bfd_byte *
6875 restfpr (bfd *abfd, bfd_byte *p, int r)
6876 {
6877   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6878   return p + 4;
6879 }
6880
6881 static bfd_byte *
6882 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6883 {
6884   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6885   p = p + 4;
6886   p = restfpr (abfd, p, r);
6887   bfd_put_32 (abfd, MTLR_R0, p);
6888   p = p + 4;
6889   if (r == 29)
6890     {
6891       p = restfpr (abfd, p, 30);
6892       p = restfpr (abfd, p, 31);
6893     }
6894   bfd_put_32 (abfd, BLR, p);
6895   return p + 4;
6896 }
6897
6898 static bfd_byte *
6899 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6900 {
6901   p = savefpr (abfd, p, r);
6902   bfd_put_32 (abfd, BLR, p);
6903   return p + 4;
6904 }
6905
6906 static bfd_byte *
6907 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6908 {
6909   p = restfpr (abfd, p, r);
6910   bfd_put_32 (abfd, BLR, p);
6911   return p + 4;
6912 }
6913
6914 static bfd_byte *
6915 savevr (bfd *abfd, bfd_byte *p, int r)
6916 {
6917   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6918   p = p + 4;
6919   bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6920   return p + 4;
6921 }
6922
6923 static bfd_byte *
6924 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6925 {
6926   p = savevr (abfd, p, r);
6927   bfd_put_32 (abfd, BLR, p);
6928   return p + 4;
6929 }
6930
6931 static bfd_byte *
6932 restvr (bfd *abfd, bfd_byte *p, int r)
6933 {
6934   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6935   p = p + 4;
6936   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6937   return p + 4;
6938 }
6939
6940 static bfd_byte *
6941 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6942 {
6943   p = restvr (abfd, p, r);
6944   bfd_put_32 (abfd, BLR, p);
6945   return p + 4;
6946 }
6947
6948 /* Called via elf_link_hash_traverse to transfer dynamic linking
6949    information on function code symbol entries to their corresponding
6950    function descriptor symbol entries.  */
6951
6952 static bfd_boolean
6953 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6954 {
6955   struct bfd_link_info *info;
6956   struct ppc_link_hash_table *htab;
6957   struct plt_entry *ent;
6958   struct ppc_link_hash_entry *fh;
6959   struct ppc_link_hash_entry *fdh;
6960   bfd_boolean force_local;
6961
6962   fh = (struct ppc_link_hash_entry *) h;
6963   if (fh->elf.root.type == bfd_link_hash_indirect)
6964     return TRUE;
6965
6966   info = inf;
6967   htab = ppc_hash_table (info);
6968   if (htab == NULL)
6969     return FALSE;
6970
6971   /* Resolve undefined references to dot-symbols as the value
6972      in the function descriptor, if we have one in a regular object.
6973      This is to satisfy cases like ".quad .foo".  Calls to functions
6974      in dynamic objects are handled elsewhere.  */
6975   if (fh->elf.root.type == bfd_link_hash_undefweak
6976       && fh->was_undefined
6977       && (fdh = defined_func_desc (fh)) != NULL
6978       && get_opd_info (fdh->elf.root.u.def.section) != NULL
6979       && opd_entry_value (fdh->elf.root.u.def.section,
6980                           fdh->elf.root.u.def.value,
6981                           &fh->elf.root.u.def.section,
6982                           &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
6983     {
6984       fh->elf.root.type = fdh->elf.root.type;
6985       fh->elf.forced_local = 1;
6986       fh->elf.def_regular = fdh->elf.def_regular;
6987       fh->elf.def_dynamic = fdh->elf.def_dynamic;
6988     }
6989
6990   /* If this is a function code symbol, transfer dynamic linking
6991      information to the function descriptor symbol.  */
6992   if (!fh->is_func)
6993     return TRUE;
6994
6995   for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6996     if (ent->plt.refcount > 0)
6997       break;
6998   if (ent == NULL
6999       || fh->elf.root.root.string[0] != '.'
7000       || fh->elf.root.root.string[1] == '\0')
7001     return TRUE;
7002
7003   /* Find the corresponding function descriptor symbol.  Create it
7004      as undefined if necessary.  */
7005
7006   fdh = lookup_fdh (fh, htab);
7007   if (fdh == NULL
7008       && !bfd_link_executable (info)
7009       && (fh->elf.root.type == bfd_link_hash_undefined
7010           || fh->elf.root.type == bfd_link_hash_undefweak))
7011     {
7012       fdh = make_fdh (info, fh);
7013       if (fdh == NULL)
7014         return FALSE;
7015     }
7016
7017   /* Fake function descriptors are made undefweak.  If the function
7018      code symbol is strong undefined, make the fake sym the same.
7019      If the function code symbol is defined, then force the fake
7020      descriptor local;  We can't support overriding of symbols in a
7021      shared library on a fake descriptor.  */
7022
7023   if (fdh != NULL
7024       && fdh->fake
7025       && fdh->elf.root.type == bfd_link_hash_undefweak)
7026     {
7027       if (fh->elf.root.type == bfd_link_hash_undefined)
7028         {
7029           fdh->elf.root.type = bfd_link_hash_undefined;
7030           bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
7031         }
7032       else if (fh->elf.root.type == bfd_link_hash_defined
7033                || fh->elf.root.type == bfd_link_hash_defweak)
7034         {
7035           _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
7036         }
7037     }
7038
7039   if (fdh != NULL
7040       && !fdh->elf.forced_local
7041       && (!bfd_link_executable (info)
7042           || fdh->elf.def_dynamic
7043           || fdh->elf.ref_dynamic
7044           || (fdh->elf.root.type == bfd_link_hash_undefweak
7045               && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
7046     {
7047       if (fdh->elf.dynindx == -1)
7048         if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
7049           return FALSE;
7050       fdh->elf.ref_regular |= fh->elf.ref_regular;
7051       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
7052       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
7053       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
7054       if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
7055         {
7056           move_plt_plist (fh, fdh);
7057           fdh->elf.needs_plt = 1;
7058         }
7059       fdh->is_func_descriptor = 1;
7060       fdh->oh = fh;
7061       fh->oh = fdh;
7062     }
7063
7064   /* Now that the info is on the function descriptor, clear the
7065      function code sym info.  Any function code syms for which we
7066      don't have a definition in a regular file, we force local.
7067      This prevents a shared library from exporting syms that have
7068      been imported from another library.  Function code syms that
7069      are really in the library we must leave global to prevent the
7070      linker dragging in a definition from a static library.  */
7071   force_local = (!fh->elf.def_regular
7072                  || fdh == NULL
7073                  || !fdh->elf.def_regular
7074                  || fdh->elf.forced_local);
7075   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7076
7077   return TRUE;
7078 }
7079
7080 static const struct sfpr_def_parms save_res_funcs[] =
7081   {
7082     { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
7083     { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
7084     { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
7085     { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
7086     { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
7087     { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
7088     { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
7089     { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
7090     { "._savef", 14, 31, savefpr, savefpr1_tail },
7091     { "._restf", 14, 31, restfpr, restfpr1_tail },
7092     { "_savevr_", 20, 31, savevr, savevr_tail },
7093     { "_restvr_", 20, 31, restvr, restvr_tail }
7094   };
7095
7096 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
7097    this hook to a) provide some gcc support functions, and b) transfer
7098    dynamic linking information gathered so far on function code symbol
7099    entries, to their corresponding function descriptor symbol entries.  */
7100
7101 static bfd_boolean
7102 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
7103                             struct bfd_link_info *info)
7104 {
7105   struct ppc_link_hash_table *htab;
7106
7107   htab = ppc_hash_table (info);
7108   if (htab == NULL)
7109     return FALSE;
7110
7111   /* Provide any missing _save* and _rest* functions.  */
7112   if (htab->sfpr != NULL)
7113     {
7114       unsigned int i;
7115
7116       htab->sfpr->size = 0;
7117       for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
7118         if (!sfpr_define (info, &save_res_funcs[i], NULL))
7119           return FALSE;
7120       if (htab->sfpr->size == 0)
7121         htab->sfpr->flags |= SEC_EXCLUDE;
7122     }
7123
7124   if (bfd_link_relocatable (info))
7125     return TRUE;
7126
7127   if (htab->elf.hgot != NULL)
7128     {
7129       _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
7130       /* Make .TOC. defined so as to prevent it being made dynamic.
7131          The wrong value here is fixed later in ppc64_elf_set_toc.  */
7132       if (!htab->elf.hgot->def_regular
7133           || htab->elf.hgot->root.type != bfd_link_hash_defined)
7134         {
7135           htab->elf.hgot->root.type = bfd_link_hash_defined;
7136           htab->elf.hgot->root.u.def.value = 0;
7137           htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
7138           htab->elf.hgot->def_regular = 1;
7139           htab->elf.hgot->root.linker_def = 1;
7140         }
7141       htab->elf.hgot->type = STT_OBJECT;
7142       htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
7143                                | STV_HIDDEN);
7144     }
7145
7146   elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
7147
7148   return TRUE;
7149 }
7150
7151 /* Return true if we have dynamic relocs against H that apply to
7152    read-only sections.  */
7153
7154 static bfd_boolean
7155 readonly_dynrelocs (struct elf_link_hash_entry *h)
7156 {
7157   struct ppc_link_hash_entry *eh;
7158   struct elf_dyn_relocs *p;
7159
7160   eh = (struct ppc_link_hash_entry *) h;
7161   for (p = eh->dyn_relocs; p != NULL; p = p->next)
7162     {
7163       asection *s = p->sec->output_section;
7164
7165       if (s != NULL && (s->flags & SEC_READONLY) != 0)
7166         return TRUE;
7167     }
7168   return FALSE;
7169 }
7170
7171 /* Return true if we have dynamic relocs against H or any of its weak
7172    aliases, that apply to read-only sections.  */
7173
7174 static bfd_boolean
7175 alias_readonly_dynrelocs (struct elf_link_hash_entry *h)
7176 {
7177   struct ppc_link_hash_entry *eh;
7178
7179   eh = (struct ppc_link_hash_entry *) h;
7180   do
7181     {
7182       if (readonly_dynrelocs (&eh->elf))
7183         return TRUE;
7184       eh = eh->weakref;
7185     } while (eh != NULL && &eh->elf != h);
7186
7187   return FALSE;
7188 }
7189
7190 /* Return whether EH has pc-relative dynamic relocs.  */
7191
7192 static bfd_boolean
7193 pc_dynrelocs (struct ppc_link_hash_entry *eh)
7194 {
7195   struct elf_dyn_relocs *p;
7196
7197   for (p = eh->dyn_relocs; p != NULL; p = p->next)
7198     if (p->pc_count != 0)
7199       return TRUE;
7200   return FALSE;
7201 }
7202
7203 /* Return true if a global entry stub will be created for H.  Valid
7204    for ELFv2 before plt entries have been allocated.  */
7205
7206 static bfd_boolean
7207 global_entry_stub (struct elf_link_hash_entry *h)
7208 {
7209   struct plt_entry *pent;
7210
7211   if (!h->pointer_equality_needed
7212       || h->def_regular)
7213     return FALSE;
7214
7215   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
7216     if (pent->plt.refcount > 0
7217         && pent->addend == 0)
7218       return TRUE;
7219
7220   return FALSE;
7221 }
7222
7223 /* Adjust a symbol defined by a dynamic object and referenced by a
7224    regular object.  The current definition is in some section of the
7225    dynamic object, but we're not including those sections.  We have to
7226    change the definition to something the rest of the link can
7227    understand.  */
7228
7229 static bfd_boolean
7230 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
7231                                  struct elf_link_hash_entry *h)
7232 {
7233   struct ppc_link_hash_table *htab;
7234   asection *s;
7235
7236   htab = ppc_hash_table (info);
7237   if (htab == NULL)
7238     return FALSE;
7239
7240   /* Deal with function syms.  */
7241   if (h->type == STT_FUNC
7242       || h->type == STT_GNU_IFUNC
7243       || h->needs_plt)
7244     {
7245       /* Clear procedure linkage table information for any symbol that
7246          won't need a .plt entry.  */
7247       struct plt_entry *ent;
7248       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
7249         if (ent->plt.refcount > 0)
7250           break;
7251       if (ent == NULL
7252           || (h->type != STT_GNU_IFUNC
7253               && (SYMBOL_CALLS_LOCAL (info, h)
7254                   || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
7255                       && h->root.type == bfd_link_hash_undefweak)))
7256           || ((struct ppc_link_hash_entry *) h)->save_res)
7257         {
7258           h->plt.plist = NULL;
7259           h->needs_plt = 0;
7260           h->pointer_equality_needed = 0;
7261         }
7262       else if (abiversion (info->output_bfd) >= 2)
7263         {
7264           /* Taking a function's address in a read/write section
7265              doesn't require us to define the function symbol in the
7266              executable on a global entry stub.  A dynamic reloc can
7267              be used instead.  The reason we prefer a few more dynamic
7268              relocs is that calling via a global entry stub costs a
7269              few more instructions, and pointer_equality_needed causes
7270              extra work in ld.so when resolving these symbols.  */
7271           if (global_entry_stub (h)
7272               && !alias_readonly_dynrelocs (h))
7273             {
7274               h->pointer_equality_needed = 0;
7275               /* After adjust_dynamic_symbol, non_got_ref set in
7276                  the non-pic case means that dyn_relocs for this
7277                  symbol should be discarded.  */
7278               h->non_got_ref = 0;
7279             }
7280
7281           /* If making a plt entry, then we don't need copy relocs.  */
7282           return TRUE;
7283         }
7284     }
7285   else
7286     h->plt.plist = NULL;
7287
7288   /* If this is a weak symbol, and there is a real definition, the
7289      processor independent code will have arranged for us to see the
7290      real definition first, and we can just use the same value.  */
7291   if (h->u.weakdef != NULL)
7292     {
7293       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
7294                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
7295       h->root.u.def.section = h->u.weakdef->root.u.def.section;
7296       h->root.u.def.value = h->u.weakdef->root.u.def.value;
7297       if (ELIMINATE_COPY_RELOCS)
7298         h->non_got_ref = h->u.weakdef->non_got_ref;
7299       return TRUE;
7300     }
7301
7302   /* If we are creating a shared library, we must presume that the
7303      only references to the symbol are via the global offset table.
7304      For such cases we need not do anything here; the relocations will
7305      be handled correctly by relocate_section.  */
7306   if (bfd_link_pic (info))
7307     return TRUE;
7308
7309   /* If there are no references to this symbol that do not use the
7310      GOT, we don't need to generate a copy reloc.  */
7311   if (!h->non_got_ref)
7312     return TRUE;
7313
7314   /* Don't generate a copy reloc for symbols defined in the executable.  */
7315   if (!h->def_dynamic || !h->ref_regular || h->def_regular
7316
7317       /* If -z nocopyreloc was given, don't generate them either.  */
7318       || info->nocopyreloc
7319
7320       /* If we didn't find any dynamic relocs in read-only sections, then
7321          we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
7322       || (ELIMINATE_COPY_RELOCS && !alias_readonly_dynrelocs (h))
7323
7324       /* Protected variables do not work with .dynbss.  The copy in
7325          .dynbss won't be used by the shared library with the protected
7326          definition for the variable.  Text relocations are preferable
7327          to an incorrect program.  */
7328       || h->protected_def)
7329     {
7330       h->non_got_ref = 0;
7331       return TRUE;
7332     }
7333
7334   if (h->plt.plist != NULL)
7335     {
7336       /* We should never get here, but unfortunately there are versions
7337          of gcc out there that improperly (for this ABI) put initialized
7338          function pointers, vtable refs and suchlike in read-only
7339          sections.  Allow them to proceed, but warn that this might
7340          break at runtime.  */
7341       info->callbacks->einfo
7342         (_("%P: copy reloc against `%T' requires lazy plt linking; "
7343            "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7344          h->root.root.string);
7345     }
7346
7347   /* This is a reference to a symbol defined by a dynamic object which
7348      is not a function.  */
7349
7350   /* We must allocate the symbol in our .dynbss section, which will
7351      become part of the .bss section of the executable.  There will be
7352      an entry for this symbol in the .dynsym section.  The dynamic
7353      object will contain position independent code, so all references
7354      from the dynamic object to this symbol will go through the global
7355      offset table.  The dynamic linker will use the .dynsym entry to
7356      determine the address it must put in the global offset table, so
7357      both the dynamic object and the regular object will refer to the
7358      same memory location for the variable.  */
7359
7360   /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
7361      to copy the initial value out of the dynamic object and into the
7362      runtime process image.  We need to remember the offset into the
7363      .rela.bss section we are going to use.  */
7364   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7365     {
7366       htab->relbss->size += sizeof (Elf64_External_Rela);
7367       h->needs_copy = 1;
7368     }
7369
7370   s = htab->dynbss;
7371
7372   return _bfd_elf_adjust_dynamic_copy (info, h, s);
7373 }
7374
7375 /* If given a function descriptor symbol, hide both the function code
7376    sym and the descriptor.  */
7377 static void
7378 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7379                        struct elf_link_hash_entry *h,
7380                        bfd_boolean force_local)
7381 {
7382   struct ppc_link_hash_entry *eh;
7383   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7384
7385   eh = (struct ppc_link_hash_entry *) h;
7386   if (eh->is_func_descriptor)
7387     {
7388       struct ppc_link_hash_entry *fh = eh->oh;
7389
7390       if (fh == NULL)
7391         {
7392           const char *p, *q;
7393           struct ppc_link_hash_table *htab;
7394           char save;
7395
7396           /* We aren't supposed to use alloca in BFD because on
7397              systems which do not have alloca the version in libiberty
7398              calls xmalloc, which might cause the program to crash
7399              when it runs out of memory.  This function doesn't have a
7400              return status, so there's no way to gracefully return an
7401              error.  So cheat.  We know that string[-1] can be safely
7402              accessed;  It's either a string in an ELF string table,
7403              or allocated in an objalloc structure.  */
7404
7405           p = eh->elf.root.root.string - 1;
7406           save = *p;
7407           *(char *) p = '.';
7408           htab = ppc_hash_table (info);
7409           if (htab == NULL)
7410             return;
7411
7412           fh = (struct ppc_link_hash_entry *)
7413             elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7414           *(char *) p = save;
7415
7416           /* Unfortunately, if it so happens that the string we were
7417              looking for was allocated immediately before this string,
7418              then we overwrote the string terminator.  That's the only
7419              reason the lookup should fail.  */
7420           if (fh == NULL)
7421             {
7422               q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7423               while (q >= eh->elf.root.root.string && *q == *p)
7424                 --q, --p;
7425               if (q < eh->elf.root.root.string && *p == '.')
7426                 fh = (struct ppc_link_hash_entry *)
7427                   elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7428             }
7429           if (fh != NULL)
7430             {
7431               eh->oh = fh;
7432               fh->oh = eh;
7433             }
7434         }
7435       if (fh != NULL)
7436         _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7437     }
7438 }
7439
7440 static bfd_boolean
7441 get_sym_h (struct elf_link_hash_entry **hp,
7442            Elf_Internal_Sym **symp,
7443            asection **symsecp,
7444            unsigned char **tls_maskp,
7445            Elf_Internal_Sym **locsymsp,
7446            unsigned long r_symndx,
7447            bfd *ibfd)
7448 {
7449   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7450
7451   if (r_symndx >= symtab_hdr->sh_info)
7452     {
7453       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7454       struct elf_link_hash_entry *h;
7455
7456       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7457       h = elf_follow_link (h);
7458
7459       if (hp != NULL)
7460         *hp = h;
7461
7462       if (symp != NULL)
7463         *symp = NULL;
7464
7465       if (symsecp != NULL)
7466         {
7467           asection *symsec = NULL;
7468           if (h->root.type == bfd_link_hash_defined
7469               || h->root.type == bfd_link_hash_defweak)
7470             symsec = h->root.u.def.section;
7471           *symsecp = symsec;
7472         }
7473
7474       if (tls_maskp != NULL)
7475         {
7476           struct ppc_link_hash_entry *eh;
7477
7478           eh = (struct ppc_link_hash_entry *) h;
7479           *tls_maskp = &eh->tls_mask;
7480         }
7481     }
7482   else
7483     {
7484       Elf_Internal_Sym *sym;
7485       Elf_Internal_Sym *locsyms = *locsymsp;
7486
7487       if (locsyms == NULL)
7488         {
7489           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7490           if (locsyms == NULL)
7491             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7492                                             symtab_hdr->sh_info,
7493                                             0, NULL, NULL, NULL);
7494           if (locsyms == NULL)
7495             return FALSE;
7496           *locsymsp = locsyms;
7497         }
7498       sym = locsyms + r_symndx;
7499
7500       if (hp != NULL)
7501         *hp = NULL;
7502
7503       if (symp != NULL)
7504         *symp = sym;
7505
7506       if (symsecp != NULL)
7507         *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7508
7509       if (tls_maskp != NULL)
7510         {
7511           struct got_entry **lgot_ents;
7512           unsigned char *tls_mask;
7513
7514           tls_mask = NULL;
7515           lgot_ents = elf_local_got_ents (ibfd);
7516           if (lgot_ents != NULL)
7517             {
7518               struct plt_entry **local_plt = (struct plt_entry **)
7519                 (lgot_ents + symtab_hdr->sh_info);
7520               unsigned char *lgot_masks = (unsigned char *)
7521                 (local_plt + symtab_hdr->sh_info);
7522               tls_mask = &lgot_masks[r_symndx];
7523             }
7524           *tls_maskp = tls_mask;
7525         }
7526     }
7527   return TRUE;
7528 }
7529
7530 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
7531    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7532    type suitable for optimization, and 1 otherwise.  */
7533
7534 static int
7535 get_tls_mask (unsigned char **tls_maskp,
7536               unsigned long *toc_symndx,
7537               bfd_vma *toc_addend,
7538               Elf_Internal_Sym **locsymsp,
7539               const Elf_Internal_Rela *rel,
7540               bfd *ibfd)
7541 {
7542   unsigned long r_symndx;
7543   int next_r;
7544   struct elf_link_hash_entry *h;
7545   Elf_Internal_Sym *sym;
7546   asection *sec;
7547   bfd_vma off;
7548
7549   r_symndx = ELF64_R_SYM (rel->r_info);
7550   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7551     return 0;
7552
7553   if ((*tls_maskp != NULL && **tls_maskp != 0)
7554       || sec == NULL
7555       || ppc64_elf_section_data (sec) == NULL
7556       || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7557     return 1;
7558
7559   /* Look inside a TOC section too.  */
7560   if (h != NULL)
7561     {
7562       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7563       off = h->root.u.def.value;
7564     }
7565   else
7566     off = sym->st_value;
7567   off += rel->r_addend;
7568   BFD_ASSERT (off % 8 == 0);
7569   r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7570   next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7571   if (toc_symndx != NULL)
7572     *toc_symndx = r_symndx;
7573   if (toc_addend != NULL)
7574     *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7575   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7576     return 0;
7577   if ((h == NULL || is_static_defined (h))
7578       && (next_r == -1 || next_r == -2))
7579     return 1 - next_r;
7580   return 1;
7581 }
7582
7583 /* Find (or create) an entry in the tocsave hash table.  */
7584
7585 static struct tocsave_entry *
7586 tocsave_find (struct ppc_link_hash_table *htab,
7587               enum insert_option insert,
7588               Elf_Internal_Sym **local_syms,
7589               const Elf_Internal_Rela *irela,
7590               bfd *ibfd)
7591 {
7592   unsigned long r_indx;
7593   struct elf_link_hash_entry *h;
7594   Elf_Internal_Sym *sym;
7595   struct tocsave_entry ent, *p;
7596   hashval_t hash;
7597   struct tocsave_entry **slot;
7598
7599   r_indx = ELF64_R_SYM (irela->r_info);
7600   if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7601     return NULL;
7602   if (ent.sec == NULL || ent.sec->output_section == NULL)
7603     {
7604       _bfd_error_handler
7605         (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"));
7606       return NULL;
7607     }
7608
7609   if (h != NULL)
7610     ent.offset = h->root.u.def.value;
7611   else
7612     ent.offset = sym->st_value;
7613   ent.offset += irela->r_addend;
7614
7615   hash = tocsave_htab_hash (&ent);
7616   slot = ((struct tocsave_entry **)
7617           htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7618   if (slot == NULL)
7619     return NULL;
7620
7621   if (*slot == NULL)
7622     {
7623       p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7624       if (p == NULL)
7625         return NULL;
7626       *p = ent;
7627       *slot = p;
7628     }
7629   return *slot;
7630 }
7631
7632 /* Adjust all global syms defined in opd sections.  In gcc generated
7633    code for the old ABI, these will already have been done.  */
7634
7635 static bfd_boolean
7636 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7637 {
7638   struct ppc_link_hash_entry *eh;
7639   asection *sym_sec;
7640   struct _opd_sec_data *opd;
7641
7642   if (h->root.type == bfd_link_hash_indirect)
7643     return TRUE;
7644
7645   if (h->root.type != bfd_link_hash_defined
7646       && h->root.type != bfd_link_hash_defweak)
7647     return TRUE;
7648
7649   eh = (struct ppc_link_hash_entry *) h;
7650   if (eh->adjust_done)
7651     return TRUE;
7652
7653   sym_sec = eh->elf.root.u.def.section;
7654   opd = get_opd_info (sym_sec);
7655   if (opd != NULL && opd->adjust != NULL)
7656     {
7657       long adjust = opd->adjust[OPD_NDX (eh->elf.root.u.def.value)];
7658       if (adjust == -1)
7659         {
7660           /* This entry has been deleted.  */
7661           asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7662           if (dsec == NULL)
7663             {
7664               for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7665                 if (discarded_section (dsec))
7666                   {
7667                     ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7668                     break;
7669                   }
7670             }
7671           eh->elf.root.u.def.value = 0;
7672           eh->elf.root.u.def.section = dsec;
7673         }
7674       else
7675         eh->elf.root.u.def.value += adjust;
7676       eh->adjust_done = 1;
7677     }
7678   return TRUE;
7679 }
7680
7681 /* Handles decrementing dynamic reloc counts for the reloc specified by
7682    R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM
7683    have already been determined.  */
7684
7685 static bfd_boolean
7686 dec_dynrel_count (bfd_vma r_info,
7687                   asection *sec,
7688                   struct bfd_link_info *info,
7689                   Elf_Internal_Sym **local_syms,
7690                   struct elf_link_hash_entry *h,
7691                   Elf_Internal_Sym *sym)
7692 {
7693   enum elf_ppc64_reloc_type r_type;
7694   asection *sym_sec = NULL;
7695
7696   /* Can this reloc be dynamic?  This switch, and later tests here
7697      should be kept in sync with the code in check_relocs.  */
7698   r_type = ELF64_R_TYPE (r_info);
7699   switch (r_type)
7700     {
7701     default:
7702       return TRUE;
7703
7704     case R_PPC64_TPREL16:
7705     case R_PPC64_TPREL16_LO:
7706     case R_PPC64_TPREL16_HI:
7707     case R_PPC64_TPREL16_HA:
7708     case R_PPC64_TPREL16_DS:
7709     case R_PPC64_TPREL16_LO_DS:
7710     case R_PPC64_TPREL16_HIGH:
7711     case R_PPC64_TPREL16_HIGHA:
7712     case R_PPC64_TPREL16_HIGHER:
7713     case R_PPC64_TPREL16_HIGHERA:
7714     case R_PPC64_TPREL16_HIGHEST:
7715     case R_PPC64_TPREL16_HIGHESTA:
7716       if (!bfd_link_pic (info))
7717         return TRUE;
7718
7719     case R_PPC64_TPREL64:
7720     case R_PPC64_DTPMOD64:
7721     case R_PPC64_DTPREL64:
7722     case R_PPC64_ADDR64:
7723     case R_PPC64_REL30:
7724     case R_PPC64_REL32:
7725     case R_PPC64_REL64:
7726     case R_PPC64_ADDR14:
7727     case R_PPC64_ADDR14_BRNTAKEN:
7728     case R_PPC64_ADDR14_BRTAKEN:
7729     case R_PPC64_ADDR16:
7730     case R_PPC64_ADDR16_DS:
7731     case R_PPC64_ADDR16_HA:
7732     case R_PPC64_ADDR16_HI:
7733     case R_PPC64_ADDR16_HIGH:
7734     case R_PPC64_ADDR16_HIGHA:
7735     case R_PPC64_ADDR16_HIGHER:
7736     case R_PPC64_ADDR16_HIGHERA:
7737     case R_PPC64_ADDR16_HIGHEST:
7738     case R_PPC64_ADDR16_HIGHESTA:
7739     case R_PPC64_ADDR16_LO:
7740     case R_PPC64_ADDR16_LO_DS:
7741     case R_PPC64_ADDR24:
7742     case R_PPC64_ADDR32:
7743     case R_PPC64_UADDR16:
7744     case R_PPC64_UADDR32:
7745     case R_PPC64_UADDR64:
7746     case R_PPC64_TOC:
7747       break;
7748     }
7749
7750   if (local_syms != NULL)
7751     {
7752       unsigned long r_symndx;
7753       bfd *ibfd = sec->owner;
7754
7755       r_symndx = ELF64_R_SYM (r_info);
7756       if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7757         return FALSE;
7758     }
7759
7760   if ((bfd_link_pic (info)
7761        && (must_be_dyn_reloc (info, r_type)
7762            || (h != NULL
7763                && (!SYMBOLIC_BIND (info, h)
7764                    || h->root.type == bfd_link_hash_defweak
7765                    || !h->def_regular))))
7766       || (ELIMINATE_COPY_RELOCS
7767           && !bfd_link_pic (info)
7768           && h != NULL
7769           && (h->root.type == bfd_link_hash_defweak
7770               || !h->def_regular)))
7771     ;
7772   else
7773     return TRUE;
7774
7775   if (h != NULL)
7776     {
7777       struct elf_dyn_relocs *p;
7778       struct elf_dyn_relocs **pp;
7779       pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7780
7781       /* elf_gc_sweep may have already removed all dyn relocs associated
7782          with local syms for a given section.  Also, symbol flags are
7783          changed by elf_gc_sweep_symbol, confusing the test above.  Don't
7784          report a dynreloc miscount.  */
7785       if (*pp == NULL && info->gc_sections)
7786         return TRUE;
7787
7788       while ((p = *pp) != NULL)
7789         {
7790           if (p->sec == sec)
7791             {
7792               if (!must_be_dyn_reloc (info, r_type))
7793                 p->pc_count -= 1;
7794               p->count -= 1;
7795               if (p->count == 0)
7796                 *pp = p->next;
7797               return TRUE;
7798             }
7799           pp = &p->next;
7800         }
7801     }
7802   else
7803     {
7804       struct ppc_dyn_relocs *p;
7805       struct ppc_dyn_relocs **pp;
7806       void *vpp;
7807       bfd_boolean is_ifunc;
7808
7809       if (local_syms == NULL)
7810         sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7811       if (sym_sec == NULL)
7812         sym_sec = sec;
7813
7814       vpp = &elf_section_data (sym_sec)->local_dynrel;
7815       pp = (struct ppc_dyn_relocs **) vpp;
7816
7817       if (*pp == NULL && info->gc_sections)
7818         return TRUE;
7819
7820       is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7821       while ((p = *pp) != NULL)
7822         {
7823           if (p->sec == sec && p->ifunc == is_ifunc)
7824             {
7825               p->count -= 1;
7826               if (p->count == 0)
7827                 *pp = p->next;
7828               return TRUE;
7829             }
7830           pp = &p->next;
7831         }
7832     }
7833
7834   info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7835                           sec->owner, sec);
7836   bfd_set_error (bfd_error_bad_value);
7837   return FALSE;
7838 }
7839
7840 /* Remove unused Official Procedure Descriptor entries.  Currently we
7841    only remove those associated with functions in discarded link-once
7842    sections, or weakly defined functions that have been overridden.  It
7843    would be possible to remove many more entries for statically linked
7844    applications.  */
7845
7846 bfd_boolean
7847 ppc64_elf_edit_opd (struct bfd_link_info *info)
7848 {
7849   bfd *ibfd;
7850   bfd_boolean some_edited = FALSE;
7851   asection *need_pad = NULL;
7852   struct ppc_link_hash_table *htab;
7853
7854   htab = ppc_hash_table (info);
7855   if (htab == NULL)
7856     return FALSE;
7857
7858   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
7859     {
7860       asection *sec;
7861       Elf_Internal_Rela *relstart, *rel, *relend;
7862       Elf_Internal_Shdr *symtab_hdr;
7863       Elf_Internal_Sym *local_syms;
7864       struct _opd_sec_data *opd;
7865       bfd_boolean need_edit, add_aux_fields, broken;
7866       bfd_size_type cnt_16b = 0;
7867
7868       if (!is_ppc64_elf (ibfd))
7869         continue;
7870
7871       sec = bfd_get_section_by_name (ibfd, ".opd");
7872       if (sec == NULL || sec->size == 0)
7873         continue;
7874
7875       if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7876         continue;
7877
7878       if (sec->output_section == bfd_abs_section_ptr)
7879         continue;
7880
7881       /* Look through the section relocs.  */
7882       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7883         continue;
7884
7885       local_syms = NULL;
7886       symtab_hdr = &elf_symtab_hdr (ibfd);
7887
7888       /* Read the relocations.  */
7889       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7890                                             info->keep_memory);
7891       if (relstart == NULL)
7892         return FALSE;
7893
7894       /* First run through the relocs to check they are sane, and to
7895          determine whether we need to edit this opd section.  */
7896       need_edit = FALSE;
7897       broken = FALSE;
7898       need_pad = sec;
7899       relend = relstart + sec->reloc_count;
7900       for (rel = relstart; rel < relend; )
7901         {
7902           enum elf_ppc64_reloc_type r_type;
7903           unsigned long r_symndx;
7904           asection *sym_sec;
7905           struct elf_link_hash_entry *h;
7906           Elf_Internal_Sym *sym;
7907           bfd_vma offset;
7908
7909           /* .opd contains an array of 16 or 24 byte entries.  We're
7910              only interested in the reloc pointing to a function entry
7911              point.  */
7912           offset = rel->r_offset;
7913           if (rel + 1 == relend
7914               || rel[1].r_offset != offset + 8)
7915             {
7916               /* If someone messes with .opd alignment then after a
7917                  "ld -r" we might have padding in the middle of .opd.
7918                  Also, there's nothing to prevent someone putting
7919                  something silly in .opd with the assembler.  No .opd
7920                  optimization for them!  */
7921             broken_opd:
7922               _bfd_error_handler
7923                 (_("%B: .opd is not a regular array of opd entries"), ibfd);
7924               broken = TRUE;
7925               break;
7926             }
7927
7928           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7929               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7930             {
7931               _bfd_error_handler
7932                 (_("%B: unexpected reloc type %u in .opd section"),
7933                  ibfd, r_type);
7934               broken = TRUE;
7935               break;
7936             }
7937
7938           r_symndx = ELF64_R_SYM (rel->r_info);
7939           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7940                           r_symndx, ibfd))
7941             goto error_ret;
7942
7943           if (sym_sec == NULL || sym_sec->owner == NULL)
7944             {
7945               const char *sym_name;
7946               if (h != NULL)
7947                 sym_name = h->root.root.string;
7948               else
7949                 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7950                                              sym_sec);
7951
7952               _bfd_error_handler
7953                 (_("%B: undefined sym `%s' in .opd section"),
7954                  ibfd, sym_name);
7955               broken = TRUE;
7956               break;
7957             }
7958
7959           /* opd entries are always for functions defined in the
7960              current input bfd.  If the symbol isn't defined in the
7961              input bfd, then we won't be using the function in this
7962              bfd;  It must be defined in a linkonce section in another
7963              bfd, or is weak.  It's also possible that we are
7964              discarding the function due to a linker script /DISCARD/,
7965              which we test for via the output_section.  */
7966           if (sym_sec->owner != ibfd
7967               || sym_sec->output_section == bfd_abs_section_ptr)
7968             need_edit = TRUE;
7969
7970           rel += 2;
7971           if (rel + 1 == relend
7972               || (rel + 2 < relend
7973                   && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC))
7974             ++rel;
7975
7976           if (rel == relend)
7977             {
7978               if (sec->size == offset + 24)
7979                 {
7980                   need_pad = NULL;
7981                   break;
7982                 }
7983               if (sec->size == offset + 16)
7984                 {
7985                   cnt_16b++;
7986                   break;
7987                 }
7988               goto broken_opd;
7989             }
7990           else if (rel + 1 < relend
7991                    && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7992                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7993             {
7994               if (rel[0].r_offset == offset + 16)
7995                 cnt_16b++;
7996               else if (rel[0].r_offset != offset + 24)
7997                 goto broken_opd;
7998             }
7999           else
8000             goto broken_opd;
8001         }
8002
8003       add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
8004
8005       if (!broken && (need_edit || add_aux_fields))
8006         {
8007           Elf_Internal_Rela *write_rel;
8008           Elf_Internal_Shdr *rel_hdr;
8009           bfd_byte *rptr, *wptr;
8010           bfd_byte *new_contents;
8011           bfd_size_type amt;
8012
8013           new_contents = NULL;
8014           amt = OPD_NDX (sec->size) * sizeof (long);
8015           opd = &ppc64_elf_section_data (sec)->u.opd;
8016           opd->adjust = bfd_zalloc (sec->owner, amt);
8017           if (opd->adjust == NULL)
8018             return FALSE;
8019           ppc64_elf_section_data (sec)->sec_type = sec_opd;
8020
8021           /* This seems a waste of time as input .opd sections are all
8022              zeros as generated by gcc, but I suppose there's no reason
8023              this will always be so.  We might start putting something in
8024              the third word of .opd entries.  */
8025           if ((sec->flags & SEC_IN_MEMORY) == 0)
8026             {
8027               bfd_byte *loc;
8028               if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
8029                 {
8030                   if (loc != NULL)
8031                     free (loc);
8032                 error_ret:
8033                   if (local_syms != NULL
8034                       && symtab_hdr->contents != (unsigned char *) local_syms)
8035                     free (local_syms);
8036                   if (elf_section_data (sec)->relocs != relstart)
8037                     free (relstart);
8038                   return FALSE;
8039                 }
8040               sec->contents = loc;
8041               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8042             }
8043
8044           elf_section_data (sec)->relocs = relstart;
8045
8046           new_contents = sec->contents;
8047           if (add_aux_fields)
8048             {
8049               new_contents = bfd_malloc (sec->size + cnt_16b * 8);
8050               if (new_contents == NULL)
8051                 return FALSE;
8052               need_pad = NULL;
8053             }
8054           wptr = new_contents;
8055           rptr = sec->contents;
8056           write_rel = relstart;
8057           for (rel = relstart; rel < relend; )
8058             {
8059               unsigned long r_symndx;
8060               asection *sym_sec;
8061               struct elf_link_hash_entry *h;
8062               struct ppc_link_hash_entry *fdh = NULL;
8063               Elf_Internal_Sym *sym;
8064               long opd_ent_size;
8065               Elf_Internal_Rela *next_rel;
8066               bfd_boolean skip;
8067
8068               r_symndx = ELF64_R_SYM (rel->r_info);
8069               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8070                               r_symndx, ibfd))
8071                 goto error_ret;
8072
8073               next_rel = rel + 2;
8074               if (next_rel + 1 == relend
8075                   || (next_rel + 2 < relend
8076                       && ELF64_R_TYPE (next_rel[2].r_info) == R_PPC64_TOC))
8077                 ++next_rel;
8078
8079               /* See if the .opd entry is full 24 byte or
8080                  16 byte (with fd_aux entry overlapped with next
8081                  fd_func).  */
8082               opd_ent_size = 24;
8083               if (next_rel == relend)
8084                 {
8085                   if (sec->size == rel->r_offset + 16)
8086                     opd_ent_size = 16;
8087                 }
8088               else if (next_rel->r_offset == rel->r_offset + 16)
8089                 opd_ent_size = 16;
8090
8091               if (h != NULL
8092                   && h->root.root.string[0] == '.')
8093                 {
8094                   fdh = lookup_fdh ((struct ppc_link_hash_entry *) h, htab);
8095                   if (fdh != NULL
8096                       && fdh->elf.root.type != bfd_link_hash_defined
8097                       && fdh->elf.root.type != bfd_link_hash_defweak)
8098                     fdh = NULL;
8099                 }
8100
8101               skip = (sym_sec->owner != ibfd
8102                       || sym_sec->output_section == bfd_abs_section_ptr);
8103               if (skip)
8104                 {
8105                   if (fdh != NULL && sym_sec->owner == ibfd)
8106                     {
8107                       /* Arrange for the function descriptor sym
8108                          to be dropped.  */
8109                       fdh->elf.root.u.def.value = 0;
8110                       fdh->elf.root.u.def.section = sym_sec;
8111                     }
8112                   opd->adjust[OPD_NDX (rel->r_offset)] = -1;
8113
8114                   if (NO_OPD_RELOCS || bfd_link_relocatable (info))
8115                     rel = next_rel;
8116                   else
8117                     while (1)
8118                       {
8119                         if (!dec_dynrel_count (rel->r_info, sec, info,
8120                                                NULL, h, sym))
8121                           goto error_ret;
8122
8123                         if (++rel == next_rel)
8124                           break;
8125
8126                         r_symndx = ELF64_R_SYM (rel->r_info);
8127                         if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8128                                         r_symndx, ibfd))
8129                           goto error_ret;
8130                       }
8131                 }
8132               else
8133                 {
8134                   /* We'll be keeping this opd entry.  */
8135                   long adjust;
8136
8137                   if (fdh != NULL)
8138                     {
8139                       /* Redefine the function descriptor symbol to
8140                          this location in the opd section.  It is
8141                          necessary to update the value here rather
8142                          than using an array of adjustments as we do
8143                          for local symbols, because various places
8144                          in the generic ELF code use the value
8145                          stored in u.def.value.  */
8146                       fdh->elf.root.u.def.value = wptr - new_contents;
8147                       fdh->adjust_done = 1;
8148                     }
8149
8150                   /* Local syms are a bit tricky.  We could
8151                      tweak them as they can be cached, but
8152                      we'd need to look through the local syms
8153                      for the function descriptor sym which we
8154                      don't have at the moment.  So keep an
8155                      array of adjustments.  */
8156                   adjust = (wptr - new_contents) - (rptr - sec->contents);
8157                   opd->adjust[OPD_NDX (rel->r_offset)] = adjust;
8158
8159                   if (wptr != rptr)
8160                     memcpy (wptr, rptr, opd_ent_size);
8161                   wptr += opd_ent_size;
8162                   if (add_aux_fields && opd_ent_size == 16)
8163                     {
8164                       memset (wptr, '\0', 8);
8165                       wptr += 8;
8166                     }
8167
8168                   /* We need to adjust any reloc offsets to point to the
8169                      new opd entries.  */
8170                   for ( ; rel != next_rel; ++rel)
8171                     {
8172                       rel->r_offset += adjust;
8173                       if (write_rel != rel)
8174                         memcpy (write_rel, rel, sizeof (*rel));
8175                       ++write_rel;
8176                     }
8177                 }
8178
8179               rptr += opd_ent_size;
8180             }
8181
8182           sec->size = wptr - new_contents;
8183           sec->reloc_count = write_rel - relstart;
8184           if (add_aux_fields)
8185             {
8186               free (sec->contents);
8187               sec->contents = new_contents;
8188             }
8189
8190           /* Fudge the header size too, as this is used later in
8191              elf_bfd_final_link if we are emitting relocs.  */
8192           rel_hdr = _bfd_elf_single_rel_hdr (sec);
8193           rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
8194           some_edited = TRUE;
8195         }
8196       else if (elf_section_data (sec)->relocs != relstart)
8197         free (relstart);
8198
8199       if (local_syms != NULL
8200           && symtab_hdr->contents != (unsigned char *) local_syms)
8201         {
8202           if (!info->keep_memory)
8203             free (local_syms);
8204           else
8205             symtab_hdr->contents = (unsigned char *) local_syms;
8206         }
8207     }
8208
8209   if (some_edited)
8210     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
8211
8212   /* If we are doing a final link and the last .opd entry is just 16 byte
8213      long, add a 8 byte padding after it.  */
8214   if (need_pad != NULL && !bfd_link_relocatable (info))
8215     {
8216       bfd_byte *p;
8217
8218       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
8219         {
8220           BFD_ASSERT (need_pad->size > 0);
8221
8222           p = bfd_malloc (need_pad->size + 8);
8223           if (p == NULL)
8224             return FALSE;
8225
8226           if (! bfd_get_section_contents (need_pad->owner, need_pad,
8227                                           p, 0, need_pad->size))
8228             return FALSE;
8229
8230           need_pad->contents = p;
8231           need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8232         }
8233       else
8234         {
8235           p = bfd_realloc (need_pad->contents, need_pad->size + 8);
8236           if (p == NULL)
8237             return FALSE;
8238
8239           need_pad->contents = p;
8240         }
8241
8242       memset (need_pad->contents + need_pad->size, 0, 8);
8243       need_pad->size += 8;
8244     }
8245
8246   return TRUE;
8247 }
8248
8249 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
8250
8251 asection *
8252 ppc64_elf_tls_setup (struct bfd_link_info *info)
8253 {
8254   struct ppc_link_hash_table *htab;
8255
8256   htab = ppc_hash_table (info);
8257   if (htab == NULL)
8258     return NULL;
8259
8260   if (abiversion (info->output_bfd) == 1)
8261     htab->opd_abi = 1;
8262
8263   if (htab->params->no_multi_toc)
8264     htab->do_multi_toc = 0;
8265   else if (!htab->do_multi_toc)
8266     htab->params->no_multi_toc = 1;
8267
8268   htab->tls_get_addr = ((struct ppc_link_hash_entry *)
8269                         elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
8270                                               FALSE, FALSE, TRUE));
8271   /* Move dynamic linking info to the function descriptor sym.  */
8272   if (htab->tls_get_addr != NULL)
8273     func_desc_adjust (&htab->tls_get_addr->elf, info);
8274   htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
8275                            elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
8276                                                  FALSE, FALSE, TRUE));
8277   if (htab->params->tls_get_addr_opt)
8278     {
8279       struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
8280
8281       opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
8282                                   FALSE, FALSE, TRUE);
8283       if (opt != NULL)
8284         func_desc_adjust (opt, info);
8285       opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
8286                                      FALSE, FALSE, TRUE);
8287       if (opt_fd != NULL
8288           && (opt_fd->root.type == bfd_link_hash_defined
8289               || opt_fd->root.type == bfd_link_hash_defweak))
8290         {
8291           /* If glibc supports an optimized __tls_get_addr call stub,
8292              signalled by the presence of __tls_get_addr_opt, and we'll
8293              be calling __tls_get_addr via a plt call stub, then
8294              make __tls_get_addr point to __tls_get_addr_opt.  */
8295           tga_fd = &htab->tls_get_addr_fd->elf;
8296           if (htab->elf.dynamic_sections_created
8297               && tga_fd != NULL
8298               && (tga_fd->type == STT_FUNC
8299                   || tga_fd->needs_plt)
8300               && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
8301                    || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
8302                        && tga_fd->root.type == bfd_link_hash_undefweak)))
8303             {
8304               struct plt_entry *ent;
8305
8306               for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
8307                 if (ent->plt.refcount > 0)
8308                   break;
8309               if (ent != NULL)
8310                 {
8311                   tga_fd->root.type = bfd_link_hash_indirect;
8312                   tga_fd->root.u.i.link = &opt_fd->root;
8313                   ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
8314                   opt_fd->forced_local = 0;
8315                   if (opt_fd->dynindx != -1)
8316                     {
8317                       /* Use __tls_get_addr_opt in dynamic relocations.  */
8318                       opt_fd->dynindx = -1;
8319                       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8320                                               opt_fd->dynstr_index);
8321                       if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8322                         return NULL;
8323                     }
8324                   htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8325                   tga = &htab->tls_get_addr->elf;
8326                   if (opt != NULL && tga != NULL)
8327                     {
8328                       tga->root.type = bfd_link_hash_indirect;
8329                       tga->root.u.i.link = &opt->root;
8330                       ppc64_elf_copy_indirect_symbol (info, opt, tga);
8331                       opt->forced_local = 0;
8332                       _bfd_elf_link_hash_hide_symbol (info, opt,
8333                                                       tga->forced_local);
8334                       htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8335                     }
8336                   htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8337                   htab->tls_get_addr_fd->is_func_descriptor = 1;
8338                   if (htab->tls_get_addr != NULL)
8339                     {
8340                       htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8341                       htab->tls_get_addr->is_func = 1;
8342                     }
8343                 }
8344             }
8345         }
8346       else if (htab->params->tls_get_addr_opt < 0)
8347         htab->params->tls_get_addr_opt = 0;
8348     }
8349   return _bfd_elf_tls_setup (info->output_bfd, info);
8350 }
8351
8352 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8353    HASH1 or HASH2.  */
8354
8355 static bfd_boolean
8356 branch_reloc_hash_match (const bfd *ibfd,
8357                          const Elf_Internal_Rela *rel,
8358                          const struct ppc_link_hash_entry *hash1,
8359                          const struct ppc_link_hash_entry *hash2)
8360 {
8361   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8362   enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8363   unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8364
8365   if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8366     {
8367       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8368       struct elf_link_hash_entry *h;
8369
8370       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8371       h = elf_follow_link (h);
8372       if (h == &hash1->elf || h == &hash2->elf)
8373         return TRUE;
8374     }
8375   return FALSE;
8376 }
8377
8378 /* Run through all the TLS relocs looking for optimization
8379    opportunities.  The linker has been hacked (see ppc64elf.em) to do
8380    a preliminary section layout so that we know the TLS segment
8381    offsets.  We can't optimize earlier because some optimizations need
8382    to know the tp offset, and we need to optimize before allocating
8383    dynamic relocations.  */
8384
8385 bfd_boolean
8386 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8387 {
8388   bfd *ibfd;
8389   asection *sec;
8390   struct ppc_link_hash_table *htab;
8391   unsigned char *toc_ref;
8392   int pass;
8393
8394   if (!bfd_link_executable (info))
8395     return TRUE;
8396
8397   htab = ppc_hash_table (info);
8398   if (htab == NULL)
8399     return FALSE;
8400
8401   /* Make two passes over the relocs.  On the first pass, mark toc
8402      entries involved with tls relocs, and check that tls relocs
8403      involved in setting up a tls_get_addr call are indeed followed by
8404      such a call.  If they are not, we can't do any tls optimization.
8405      On the second pass twiddle tls_mask flags to notify
8406      relocate_section that optimization can be done, and adjust got
8407      and plt refcounts.  */
8408   toc_ref = NULL;
8409   for (pass = 0; pass < 2; ++pass)
8410     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8411       {
8412         Elf_Internal_Sym *locsyms = NULL;
8413         asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8414
8415         for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8416           if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8417             {
8418               Elf_Internal_Rela *relstart, *rel, *relend;
8419               bfd_boolean found_tls_get_addr_arg = 0;
8420
8421               /* Read the relocations.  */
8422               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8423                                                     info->keep_memory);
8424               if (relstart == NULL)
8425                 {
8426                   free (toc_ref);
8427                   return FALSE;
8428                 }
8429
8430               relend = relstart + sec->reloc_count;
8431               for (rel = relstart; rel < relend; rel++)
8432                 {
8433                   enum elf_ppc64_reloc_type r_type;
8434                   unsigned long r_symndx;
8435                   struct elf_link_hash_entry *h;
8436                   Elf_Internal_Sym *sym;
8437                   asection *sym_sec;
8438                   unsigned char *tls_mask;
8439                   unsigned char tls_set, tls_clear, tls_type = 0;
8440                   bfd_vma value;
8441                   bfd_boolean ok_tprel, is_local;
8442                   long toc_ref_index = 0;
8443                   int expecting_tls_get_addr = 0;
8444                   bfd_boolean ret = FALSE;
8445
8446                   r_symndx = ELF64_R_SYM (rel->r_info);
8447                   if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8448                                   r_symndx, ibfd))
8449                     {
8450                     err_free_rel:
8451                       if (elf_section_data (sec)->relocs != relstart)
8452                         free (relstart);
8453                       if (toc_ref != NULL)
8454                         free (toc_ref);
8455                       if (locsyms != NULL
8456                           && (elf_symtab_hdr (ibfd).contents
8457                               != (unsigned char *) locsyms))
8458                         free (locsyms);
8459                       return ret;
8460                     }
8461
8462                   if (h != NULL)
8463                     {
8464                       if (h->root.type == bfd_link_hash_defined
8465                           || h->root.type == bfd_link_hash_defweak)
8466                         value = h->root.u.def.value;
8467                       else if (h->root.type == bfd_link_hash_undefweak)
8468                         value = 0;
8469                       else
8470                         {
8471                           found_tls_get_addr_arg = 0;
8472                           continue;
8473                         }
8474                     }
8475                   else
8476                     /* Symbols referenced by TLS relocs must be of type
8477                        STT_TLS.  So no need for .opd local sym adjust.  */
8478                     value = sym->st_value;
8479
8480                   ok_tprel = FALSE;
8481                   is_local = FALSE;
8482                   if (h == NULL
8483                       || !h->def_dynamic)
8484                     {
8485                       is_local = TRUE;
8486                       if (h != NULL
8487                           && h->root.type == bfd_link_hash_undefweak)
8488                         ok_tprel = TRUE;
8489                       else if (sym_sec != NULL
8490                                && sym_sec->output_section != NULL)
8491                         {
8492                           value += sym_sec->output_offset;
8493                           value += sym_sec->output_section->vma;
8494                           value -= htab->elf.tls_sec->vma;
8495                           ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8496                                       < (bfd_vma) 1 << 32);
8497                         }
8498                     }
8499
8500                   r_type = ELF64_R_TYPE (rel->r_info);
8501                   /* If this section has old-style __tls_get_addr calls
8502                      without marker relocs, then check that each
8503                      __tls_get_addr call reloc is preceded by a reloc
8504                      that conceivably belongs to the __tls_get_addr arg
8505                      setup insn.  If we don't find matching arg setup
8506                      relocs, don't do any tls optimization.  */
8507                   if (pass == 0
8508                       && sec->has_tls_get_addr_call
8509                       && h != NULL
8510                       && (h == &htab->tls_get_addr->elf
8511                           || h == &htab->tls_get_addr_fd->elf)
8512                       && !found_tls_get_addr_arg
8513                       && is_branch_reloc (r_type))
8514                     {
8515                       info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8516                                                 "TLS optimization disabled\n"),
8517                                               ibfd, sec, rel->r_offset);
8518                       ret = TRUE;
8519                       goto err_free_rel;
8520                     }
8521
8522                   found_tls_get_addr_arg = 0;
8523                   switch (r_type)
8524                     {
8525                     case R_PPC64_GOT_TLSLD16:
8526                     case R_PPC64_GOT_TLSLD16_LO:
8527                       expecting_tls_get_addr = 1;
8528                       found_tls_get_addr_arg = 1;
8529                       /* Fall through.  */
8530
8531                     case R_PPC64_GOT_TLSLD16_HI:
8532                     case R_PPC64_GOT_TLSLD16_HA:
8533                       /* These relocs should never be against a symbol
8534                          defined in a shared lib.  Leave them alone if
8535                          that turns out to be the case.  */
8536                       if (!is_local)
8537                         continue;
8538
8539                       /* LD -> LE */
8540                       tls_set = 0;
8541                       tls_clear = TLS_LD;
8542                       tls_type = TLS_TLS | TLS_LD;
8543                       break;
8544
8545                     case R_PPC64_GOT_TLSGD16:
8546                     case R_PPC64_GOT_TLSGD16_LO:
8547                       expecting_tls_get_addr = 1;
8548                       found_tls_get_addr_arg = 1;
8549                       /* Fall through. */
8550
8551                     case R_PPC64_GOT_TLSGD16_HI:
8552                     case R_PPC64_GOT_TLSGD16_HA:
8553                       if (ok_tprel)
8554                         /* GD -> LE */
8555                         tls_set = 0;
8556                       else
8557                         /* GD -> IE */
8558                         tls_set = TLS_TLS | TLS_TPRELGD;
8559                       tls_clear = TLS_GD;
8560                       tls_type = TLS_TLS | TLS_GD;
8561                       break;
8562
8563                     case R_PPC64_GOT_TPREL16_DS:
8564                     case R_PPC64_GOT_TPREL16_LO_DS:
8565                     case R_PPC64_GOT_TPREL16_HI:
8566                     case R_PPC64_GOT_TPREL16_HA:
8567                       if (ok_tprel)
8568                         {
8569                           /* IE -> LE */
8570                           tls_set = 0;
8571                           tls_clear = TLS_TPREL;
8572                           tls_type = TLS_TLS | TLS_TPREL;
8573                           break;
8574                         }
8575                       continue;
8576
8577                     case R_PPC64_TLSGD:
8578                     case R_PPC64_TLSLD:
8579                       found_tls_get_addr_arg = 1;
8580                       /* Fall through.  */
8581
8582                     case R_PPC64_TLS:
8583                     case R_PPC64_TOC16:
8584                     case R_PPC64_TOC16_LO:
8585                       if (sym_sec == NULL || sym_sec != toc)
8586                         continue;
8587
8588                       /* Mark this toc entry as referenced by a TLS
8589                          code sequence.  We can do that now in the
8590                          case of R_PPC64_TLS, and after checking for
8591                          tls_get_addr for the TOC16 relocs.  */
8592                       if (toc_ref == NULL)
8593                         toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8594                       if (toc_ref == NULL)
8595                         goto err_free_rel;
8596
8597                       if (h != NULL)
8598                         value = h->root.u.def.value;
8599                       else
8600                         value = sym->st_value;
8601                       value += rel->r_addend;
8602                       if (value % 8 != 0)
8603                         continue;
8604                       BFD_ASSERT (value < toc->size
8605                                   && toc->output_offset % 8 == 0);
8606                       toc_ref_index = (value + toc->output_offset) / 8;
8607                       if (r_type == R_PPC64_TLS
8608                           || r_type == R_PPC64_TLSGD
8609                           || r_type == R_PPC64_TLSLD)
8610                         {
8611                           toc_ref[toc_ref_index] = 1;
8612                           continue;
8613                         }
8614
8615                       if (pass != 0 && toc_ref[toc_ref_index] == 0)
8616                         continue;
8617
8618                       tls_set = 0;
8619                       tls_clear = 0;
8620                       expecting_tls_get_addr = 2;
8621                       break;
8622
8623                     case R_PPC64_TPREL64:
8624                       if (pass == 0
8625                           || sec != toc
8626                           || toc_ref == NULL
8627                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8628                         continue;
8629                       if (ok_tprel)
8630                         {
8631                           /* IE -> LE */
8632                           tls_set = TLS_EXPLICIT;
8633                           tls_clear = TLS_TPREL;
8634                           break;
8635                         }
8636                       continue;
8637
8638                     case R_PPC64_DTPMOD64:
8639                       if (pass == 0
8640                           || sec != toc
8641                           || toc_ref == NULL
8642                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8643                         continue;
8644                       if (rel + 1 < relend
8645                           && (rel[1].r_info
8646                               == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8647                           && rel[1].r_offset == rel->r_offset + 8)
8648                         {
8649                           if (ok_tprel)
8650                             /* GD -> LE */
8651                             tls_set = TLS_EXPLICIT | TLS_GD;
8652                           else
8653                             /* GD -> IE */
8654                             tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8655                           tls_clear = TLS_GD;
8656                         }
8657                       else
8658                         {
8659                           if (!is_local)
8660                             continue;
8661
8662                           /* LD -> LE */
8663                           tls_set = TLS_EXPLICIT;
8664                           tls_clear = TLS_LD;
8665                         }
8666                       break;
8667
8668                     default:
8669                       continue;
8670                     }
8671
8672                   if (pass == 0)
8673                     {
8674                       if (!expecting_tls_get_addr
8675                           || !sec->has_tls_get_addr_call)
8676                         continue;
8677
8678                       if (rel + 1 < relend
8679                           && branch_reloc_hash_match (ibfd, rel + 1,
8680                                                       htab->tls_get_addr,
8681                                                       htab->tls_get_addr_fd))
8682                         {
8683                           if (expecting_tls_get_addr == 2)
8684                             {
8685                               /* Check for toc tls entries.  */
8686                               unsigned char *toc_tls;
8687                               int retval;
8688
8689                               retval = get_tls_mask (&toc_tls, NULL, NULL,
8690                                                      &locsyms,
8691                                                      rel, ibfd);
8692                               if (retval == 0)
8693                                 goto err_free_rel;
8694                               if (toc_tls != NULL)
8695                                 {
8696                                   if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8697                                     found_tls_get_addr_arg = 1;
8698                                   if (retval > 1)
8699                                     toc_ref[toc_ref_index] = 1;
8700                                 }
8701                             }
8702                           continue;
8703                         }
8704
8705                       if (expecting_tls_get_addr != 1)
8706                         continue;
8707
8708                       /* Uh oh, we didn't find the expected call.  We
8709                          could just mark this symbol to exclude it
8710                          from tls optimization but it's safer to skip
8711                          the entire optimization.  */
8712                       info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8713                                                 "TLS optimization disabled\n"),
8714                                               ibfd, sec, rel->r_offset);
8715                       ret = TRUE;
8716                       goto err_free_rel;
8717                     }
8718
8719                   if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8720                     {
8721                       struct plt_entry *ent;
8722                       for (ent = htab->tls_get_addr->elf.plt.plist;
8723                            ent != NULL;
8724                            ent = ent->next)
8725                         if (ent->addend == 0)
8726                           {
8727                             if (ent->plt.refcount > 0)
8728                               {
8729                                 ent->plt.refcount -= 1;
8730                                 expecting_tls_get_addr = 0;
8731                               }
8732                             break;
8733                           }
8734                     }
8735
8736                   if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8737                     {
8738                       struct plt_entry *ent;
8739                       for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8740                            ent != NULL;
8741                            ent = ent->next)
8742                         if (ent->addend == 0)
8743                           {
8744                             if (ent->plt.refcount > 0)
8745                               ent->plt.refcount -= 1;
8746                             break;
8747                           }
8748                     }
8749
8750                   if (tls_clear == 0)
8751                     continue;
8752
8753                   if ((tls_set & TLS_EXPLICIT) == 0)
8754                     {
8755                       struct got_entry *ent;
8756
8757                       /* Adjust got entry for this reloc.  */
8758                       if (h != NULL)
8759                         ent = h->got.glist;
8760                       else
8761                         ent = elf_local_got_ents (ibfd)[r_symndx];
8762
8763                       for (; ent != NULL; ent = ent->next)
8764                         if (ent->addend == rel->r_addend
8765                             && ent->owner == ibfd
8766                             && ent->tls_type == tls_type)
8767                           break;
8768                       if (ent == NULL)
8769                         abort ();
8770
8771                       if (tls_set == 0)
8772                         {
8773                           /* We managed to get rid of a got entry.  */
8774                           if (ent->got.refcount > 0)
8775                             ent->got.refcount -= 1;
8776                         }
8777                     }
8778                   else
8779                     {
8780                       /* If we got rid of a DTPMOD/DTPREL reloc pair then
8781                          we'll lose one or two dyn relocs.  */
8782                       if (!dec_dynrel_count (rel->r_info, sec, info,
8783                                              NULL, h, sym))
8784                         return FALSE;
8785
8786                       if (tls_set == (TLS_EXPLICIT | TLS_GD))
8787                         {
8788                           if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8789                                                  NULL, h, sym))
8790                             return FALSE;
8791                         }
8792                     }
8793
8794                   *tls_mask |= tls_set;
8795                   *tls_mask &= ~tls_clear;
8796                 }
8797
8798               if (elf_section_data (sec)->relocs != relstart)
8799                 free (relstart);
8800             }
8801
8802         if (locsyms != NULL
8803             && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8804           {
8805             if (!info->keep_memory)
8806               free (locsyms);
8807             else
8808               elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8809           }
8810       }
8811
8812   if (toc_ref != NULL)
8813     free (toc_ref);
8814   return TRUE;
8815 }
8816
8817 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8818    the values of any global symbols in a toc section that has been
8819    edited.  Globals in toc sections should be a rarity, so this function
8820    sets a flag if any are found in toc sections other than the one just
8821    edited, so that futher hash table traversals can be avoided.  */
8822
8823 struct adjust_toc_info
8824 {
8825   asection *toc;
8826   unsigned long *skip;
8827   bfd_boolean global_toc_syms;
8828 };
8829
8830 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8831
8832 static bfd_boolean
8833 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8834 {
8835   struct ppc_link_hash_entry *eh;
8836   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8837   unsigned long i;
8838
8839   if (h->root.type != bfd_link_hash_defined
8840       && h->root.type != bfd_link_hash_defweak)
8841     return TRUE;
8842
8843   eh = (struct ppc_link_hash_entry *) h;
8844   if (eh->adjust_done)
8845     return TRUE;
8846
8847   if (eh->elf.root.u.def.section == toc_inf->toc)
8848     {
8849       if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8850         i = toc_inf->toc->rawsize >> 3;
8851       else
8852         i = eh->elf.root.u.def.value >> 3;
8853
8854       if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8855         {
8856           _bfd_error_handler
8857             (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8858           do
8859             ++i;
8860           while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8861           eh->elf.root.u.def.value = (bfd_vma) i << 3;
8862         }
8863
8864       eh->elf.root.u.def.value -= toc_inf->skip[i];
8865       eh->adjust_done = 1;
8866     }
8867   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8868     toc_inf->global_toc_syms = TRUE;
8869
8870   return TRUE;
8871 }
8872
8873 /* Return TRUE iff INSN is one we expect on a _LO variety toc/got reloc.  */
8874
8875 static bfd_boolean
8876 ok_lo_toc_insn (unsigned int insn)
8877 {
8878   return ((insn & (0x3f << 26)) == 14u << 26 /* addi */
8879           || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8880           || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8881           || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8882           || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8883           || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8884           || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8885           || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8886           || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8887           || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8888           || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8889           || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8890           || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8891           || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8892           || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
8893               && (insn & 3) != 1)
8894           || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
8895               && ((insn & 3) == 0 || (insn & 3) == 3))
8896           || (insn & (0x3f << 26)) == 12u << 26 /* addic */);
8897 }
8898
8899 /* Examine all relocs referencing .toc sections in order to remove
8900    unused .toc entries.  */
8901
8902 bfd_boolean
8903 ppc64_elf_edit_toc (struct bfd_link_info *info)
8904 {
8905   bfd *ibfd;
8906   struct adjust_toc_info toc_inf;
8907   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8908
8909   htab->do_toc_opt = 1;
8910   toc_inf.global_toc_syms = TRUE;
8911   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8912     {
8913       asection *toc, *sec;
8914       Elf_Internal_Shdr *symtab_hdr;
8915       Elf_Internal_Sym *local_syms;
8916       Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8917       unsigned long *skip, *drop;
8918       unsigned char *used;
8919       unsigned char *keep, last, some_unused;
8920
8921       if (!is_ppc64_elf (ibfd))
8922         continue;
8923
8924       toc = bfd_get_section_by_name (ibfd, ".toc");
8925       if (toc == NULL
8926           || toc->size == 0
8927           || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8928           || discarded_section (toc))
8929         continue;
8930
8931       toc_relocs = NULL;
8932       local_syms = NULL;
8933       symtab_hdr = &elf_symtab_hdr (ibfd);
8934
8935       /* Look at sections dropped from the final link.  */
8936       skip = NULL;
8937       relstart = NULL;
8938       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8939         {
8940           if (sec->reloc_count == 0
8941               || !discarded_section (sec)
8942               || get_opd_info (sec)
8943               || (sec->flags & SEC_ALLOC) == 0
8944               || (sec->flags & SEC_DEBUGGING) != 0)
8945             continue;
8946
8947           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8948           if (relstart == NULL)
8949             goto error_ret;
8950
8951           /* Run through the relocs to see which toc entries might be
8952              unused.  */
8953           for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8954             {
8955               enum elf_ppc64_reloc_type r_type;
8956               unsigned long r_symndx;
8957               asection *sym_sec;
8958               struct elf_link_hash_entry *h;
8959               Elf_Internal_Sym *sym;
8960               bfd_vma val;
8961
8962               r_type = ELF64_R_TYPE (rel->r_info);
8963               switch (r_type)
8964                 {
8965                 default:
8966                   continue;
8967
8968                 case R_PPC64_TOC16:
8969                 case R_PPC64_TOC16_LO:
8970                 case R_PPC64_TOC16_HI:
8971                 case R_PPC64_TOC16_HA:
8972                 case R_PPC64_TOC16_DS:
8973                 case R_PPC64_TOC16_LO_DS:
8974                   break;
8975                 }
8976
8977               r_symndx = ELF64_R_SYM (rel->r_info);
8978               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8979                               r_symndx, ibfd))
8980                 goto error_ret;
8981
8982               if (sym_sec != toc)
8983                 continue;
8984
8985               if (h != NULL)
8986                 val = h->root.u.def.value;
8987               else
8988                 val = sym->st_value;
8989               val += rel->r_addend;
8990
8991               if (val >= toc->size)
8992                 continue;
8993
8994               /* Anything in the toc ought to be aligned to 8 bytes.
8995                  If not, don't mark as unused.  */
8996               if (val & 7)
8997                 continue;
8998
8999               if (skip == NULL)
9000                 {
9001                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9002                   if (skip == NULL)
9003                     goto error_ret;
9004                 }
9005
9006               skip[val >> 3] = ref_from_discarded;
9007             }
9008
9009           if (elf_section_data (sec)->relocs != relstart)
9010             free (relstart);
9011         }
9012
9013       /* For largetoc loads of address constants, we can convert
9014          .  addis rx,2,addr@got@ha
9015          .  ld ry,addr@got@l(rx)
9016          to
9017          .  addis rx,2,addr@toc@ha
9018          .  addi ry,rx,addr@toc@l
9019          when addr is within 2G of the toc pointer.  This then means
9020          that the word storing "addr" in the toc is no longer needed.  */
9021
9022       if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
9023           && toc->output_section->rawsize < (bfd_vma) 1 << 31
9024           && toc->reloc_count != 0)
9025         {
9026           /* Read toc relocs.  */
9027           toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9028                                                   info->keep_memory);
9029           if (toc_relocs == NULL)
9030             goto error_ret;
9031
9032           for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9033             {
9034               enum elf_ppc64_reloc_type r_type;
9035               unsigned long r_symndx;
9036               asection *sym_sec;
9037               struct elf_link_hash_entry *h;
9038               Elf_Internal_Sym *sym;
9039               bfd_vma val, addr;
9040
9041               r_type = ELF64_R_TYPE (rel->r_info);
9042               if (r_type != R_PPC64_ADDR64)
9043                 continue;
9044
9045               r_symndx = ELF64_R_SYM (rel->r_info);
9046               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9047                               r_symndx, ibfd))
9048                 goto error_ret;
9049
9050               if (sym_sec == NULL
9051                   || sym_sec->output_section == NULL
9052                   || discarded_section (sym_sec))
9053                 continue;
9054
9055               if (!SYMBOL_REFERENCES_LOCAL (info, h))
9056                 continue;
9057
9058               if (h != NULL)
9059                 {
9060                   if (h->type == STT_GNU_IFUNC)
9061                     continue;
9062                   val = h->root.u.def.value;
9063                 }
9064               else
9065                 {
9066                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
9067                     continue;
9068                   val = sym->st_value;
9069                 }
9070               val += rel->r_addend;
9071               val += sym_sec->output_section->vma + sym_sec->output_offset;
9072
9073               /* We don't yet know the exact toc pointer value, but we
9074                  know it will be somewhere in the toc section.  Don't
9075                  optimize if the difference from any possible toc
9076                  pointer is outside [ff..f80008000, 7fff7fff].  */
9077               addr = toc->output_section->vma + TOC_BASE_OFF;
9078               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9079                 continue;
9080
9081               addr = toc->output_section->vma + toc->output_section->rawsize;
9082               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9083                 continue;
9084
9085               if (skip == NULL)
9086                 {
9087                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9088                   if (skip == NULL)
9089                     goto error_ret;
9090                 }
9091
9092               skip[rel->r_offset >> 3]
9093                 |= can_optimize | ((rel - toc_relocs) << 2);
9094             }
9095         }
9096
9097       if (skip == NULL)
9098         continue;
9099
9100       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
9101       if (used == NULL)
9102         {
9103         error_ret:
9104           if (local_syms != NULL
9105               && symtab_hdr->contents != (unsigned char *) local_syms)
9106             free (local_syms);
9107           if (sec != NULL
9108               && relstart != NULL
9109               && elf_section_data (sec)->relocs != relstart)
9110             free (relstart);
9111           if (toc_relocs != NULL
9112               && elf_section_data (toc)->relocs != toc_relocs)
9113             free (toc_relocs);
9114           if (skip != NULL)
9115             free (skip);
9116           return FALSE;
9117         }
9118
9119       /* Now check all kept sections that might reference the toc.
9120          Check the toc itself last.  */
9121       for (sec = (ibfd->sections == toc && toc->next ? toc->next
9122                   : ibfd->sections);
9123            sec != NULL;
9124            sec = (sec == toc ? NULL
9125                   : sec->next == NULL ? toc
9126                   : sec->next == toc && toc->next ? toc->next
9127                   : sec->next))
9128         {
9129           int repeat;
9130
9131           if (sec->reloc_count == 0
9132               || discarded_section (sec)
9133               || get_opd_info (sec)
9134               || (sec->flags & SEC_ALLOC) == 0
9135               || (sec->flags & SEC_DEBUGGING) != 0)
9136             continue;
9137
9138           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9139                                                 info->keep_memory);
9140           if (relstart == NULL)
9141             {
9142               free (used);
9143               goto error_ret;
9144             }
9145
9146           /* Mark toc entries referenced as used.  */
9147           do
9148             {
9149               repeat = 0;
9150               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9151                 {
9152                   enum elf_ppc64_reloc_type r_type;
9153                   unsigned long r_symndx;
9154                   asection *sym_sec;
9155                   struct elf_link_hash_entry *h;
9156                   Elf_Internal_Sym *sym;
9157                   bfd_vma val;
9158                   enum {no_check, check_lo, check_ha} insn_check;
9159
9160                   r_type = ELF64_R_TYPE (rel->r_info);
9161                   switch (r_type)
9162                     {
9163                     default:
9164                       insn_check = no_check;
9165                       break;
9166
9167                     case R_PPC64_GOT_TLSLD16_HA:
9168                     case R_PPC64_GOT_TLSGD16_HA:
9169                     case R_PPC64_GOT_TPREL16_HA:
9170                     case R_PPC64_GOT_DTPREL16_HA:
9171                     case R_PPC64_GOT16_HA:
9172                     case R_PPC64_TOC16_HA:
9173                       insn_check = check_ha;
9174                       break;
9175
9176                     case R_PPC64_GOT_TLSLD16_LO:
9177                     case R_PPC64_GOT_TLSGD16_LO:
9178                     case R_PPC64_GOT_TPREL16_LO_DS:
9179                     case R_PPC64_GOT_DTPREL16_LO_DS:
9180                     case R_PPC64_GOT16_LO:
9181                     case R_PPC64_GOT16_LO_DS:
9182                     case R_PPC64_TOC16_LO:
9183                     case R_PPC64_TOC16_LO_DS:
9184                       insn_check = check_lo;
9185                       break;
9186                     }
9187
9188                   if (insn_check != no_check)
9189                     {
9190                       bfd_vma off = rel->r_offset & ~3;
9191                       unsigned char buf[4];
9192                       unsigned int insn;
9193
9194                       if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
9195                         {
9196                           free (used);
9197                           goto error_ret;
9198                         }
9199                       insn = bfd_get_32 (ibfd, buf);
9200                       if (insn_check == check_lo
9201                           ? !ok_lo_toc_insn (insn)
9202                           : ((insn & ((0x3f << 26) | 0x1f << 16))
9203                              != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9204                         {
9205                           char str[12];
9206
9207                           ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
9208                           sprintf (str, "%#08x", insn);
9209                           info->callbacks->einfo
9210                             (_("%P: %H: toc optimization is not supported for"
9211                                " %s instruction.\n"),
9212                              ibfd, sec, rel->r_offset & ~3, str);
9213                         }
9214                     }
9215
9216                   switch (r_type)
9217                     {
9218                     case R_PPC64_TOC16:
9219                     case R_PPC64_TOC16_LO:
9220                     case R_PPC64_TOC16_HI:
9221                     case R_PPC64_TOC16_HA:
9222                     case R_PPC64_TOC16_DS:
9223                     case R_PPC64_TOC16_LO_DS:
9224                       /* In case we're taking addresses of toc entries.  */
9225                     case R_PPC64_ADDR64:
9226                       break;
9227
9228                     default:
9229                       continue;
9230                     }
9231
9232                   r_symndx = ELF64_R_SYM (rel->r_info);
9233                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9234                                   r_symndx, ibfd))
9235                     {
9236                       free (used);
9237                       goto error_ret;
9238                     }
9239
9240                   if (sym_sec != toc)
9241                     continue;
9242
9243                   if (h != NULL)
9244                     val = h->root.u.def.value;
9245                   else
9246                     val = sym->st_value;
9247                   val += rel->r_addend;
9248
9249                   if (val >= toc->size)
9250                     continue;
9251
9252                   if ((skip[val >> 3] & can_optimize) != 0)
9253                     {
9254                       bfd_vma off;
9255                       unsigned char opc;
9256
9257                       switch (r_type)
9258                         {
9259                         case R_PPC64_TOC16_HA:
9260                           break;
9261
9262                         case R_PPC64_TOC16_LO_DS:
9263                           off = rel->r_offset;
9264                           off += (bfd_big_endian (ibfd) ? -2 : 3);
9265                           if (!bfd_get_section_contents (ibfd, sec, &opc,
9266                                                          off, 1))
9267                             {
9268                               free (used);
9269                               goto error_ret;
9270                             }
9271                           if ((opc & (0x3f << 2)) == (58u << 2))
9272                             break;
9273                           /* Fall through.  */
9274
9275                         default:
9276                           /* Wrong sort of reloc, or not a ld.  We may
9277                              as well clear ref_from_discarded too.  */
9278                           skip[val >> 3] = 0;
9279                         }
9280                     }
9281
9282                   if (sec != toc)
9283                     used[val >> 3] = 1;
9284                   /* For the toc section, we only mark as used if this
9285                      entry itself isn't unused.  */
9286                   else if ((used[rel->r_offset >> 3]
9287                             || !(skip[rel->r_offset >> 3] & ref_from_discarded))
9288                            && !used[val >> 3])
9289                     {
9290                       /* Do all the relocs again, to catch reference
9291                          chains.  */
9292                       repeat = 1;
9293                       used[val >> 3] = 1;
9294                     }
9295                 }
9296             }
9297           while (repeat);
9298
9299           if (elf_section_data (sec)->relocs != relstart)
9300             free (relstart);
9301         }
9302
9303       /* Merge the used and skip arrays.  Assume that TOC
9304          doublewords not appearing as either used or unused belong
9305          to to an entry more than one doubleword in size.  */
9306       for (drop = skip, keep = used, last = 0, some_unused = 0;
9307            drop < skip + (toc->size + 7) / 8;
9308            ++drop, ++keep)
9309         {
9310           if (*keep)
9311             {
9312               *drop &= ~ref_from_discarded;
9313               if ((*drop & can_optimize) != 0)
9314                 some_unused = 1;
9315               last = 0;
9316             }
9317           else if ((*drop & ref_from_discarded) != 0)
9318             {
9319               some_unused = 1;
9320               last = ref_from_discarded;
9321             }
9322           else
9323             *drop = last;
9324         }
9325
9326       free (used);
9327
9328       if (some_unused)
9329         {
9330           bfd_byte *contents, *src;
9331           unsigned long off;
9332           Elf_Internal_Sym *sym;
9333           bfd_boolean local_toc_syms = FALSE;
9334
9335           /* Shuffle the toc contents, and at the same time convert the
9336              skip array from booleans into offsets.  */
9337           if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9338             goto error_ret;
9339
9340           elf_section_data (toc)->this_hdr.contents = contents;
9341
9342           for (src = contents, off = 0, drop = skip;
9343                src < contents + toc->size;
9344                src += 8, ++drop)
9345             {
9346               if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9347                 off += 8;
9348               else if (off != 0)
9349                 {
9350                   *drop = off;
9351                   memcpy (src - off, src, 8);
9352                 }
9353             }
9354           *drop = off;
9355           toc->rawsize = toc->size;
9356           toc->size = src - contents - off;
9357
9358           /* Adjust addends for relocs against the toc section sym,
9359              and optimize any accesses we can.  */
9360           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9361             {
9362               if (sec->reloc_count == 0
9363                   || discarded_section (sec))
9364                 continue;
9365
9366               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9367                                                     info->keep_memory);
9368               if (relstart == NULL)
9369                 goto error_ret;
9370
9371               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9372                 {
9373                   enum elf_ppc64_reloc_type r_type;
9374                   unsigned long r_symndx;
9375                   asection *sym_sec;
9376                   struct elf_link_hash_entry *h;
9377                   bfd_vma val;
9378
9379                   r_type = ELF64_R_TYPE (rel->r_info);
9380                   switch (r_type)
9381                     {
9382                     default:
9383                       continue;
9384
9385                     case R_PPC64_TOC16:
9386                     case R_PPC64_TOC16_LO:
9387                     case R_PPC64_TOC16_HI:
9388                     case R_PPC64_TOC16_HA:
9389                     case R_PPC64_TOC16_DS:
9390                     case R_PPC64_TOC16_LO_DS:
9391                     case R_PPC64_ADDR64:
9392                       break;
9393                     }
9394
9395                   r_symndx = ELF64_R_SYM (rel->r_info);
9396                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9397                                   r_symndx, ibfd))
9398                     goto error_ret;
9399
9400                   if (sym_sec != toc)
9401                     continue;
9402
9403                   if (h != NULL)
9404                     val = h->root.u.def.value;
9405                   else
9406                     {
9407                       val = sym->st_value;
9408                       if (val != 0)
9409                         local_toc_syms = TRUE;
9410                     }
9411
9412                   val += rel->r_addend;
9413
9414                   if (val > toc->rawsize)
9415                     val = toc->rawsize;
9416                   else if ((skip[val >> 3] & ref_from_discarded) != 0)
9417                     continue;
9418                   else if ((skip[val >> 3] & can_optimize) != 0)
9419                     {
9420                       Elf_Internal_Rela *tocrel
9421                         = toc_relocs + (skip[val >> 3] >> 2);
9422                       unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9423
9424                       switch (r_type)
9425                         {
9426                         case R_PPC64_TOC16_HA:
9427                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9428                           break;
9429
9430                         case R_PPC64_TOC16_LO_DS:
9431                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9432                           break;
9433
9434                         default:
9435                           if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9436                             ppc_howto_init ();
9437                           info->callbacks->einfo
9438                             (_("%P: %H: %s references "
9439                                "optimized away TOC entry\n"),
9440                              ibfd, sec, rel->r_offset,
9441                              ppc64_elf_howto_table[r_type]->name);
9442                           bfd_set_error (bfd_error_bad_value);
9443                           goto error_ret;
9444                         }
9445                       rel->r_addend = tocrel->r_addend;
9446                       elf_section_data (sec)->relocs = relstart;
9447                       continue;
9448                     }
9449
9450                   if (h != NULL || sym->st_value != 0)
9451                     continue;
9452
9453                   rel->r_addend -= skip[val >> 3];
9454                   elf_section_data (sec)->relocs = relstart;
9455                 }
9456
9457               if (elf_section_data (sec)->relocs != relstart)
9458                 free (relstart);
9459             }
9460
9461           /* We shouldn't have local or global symbols defined in the TOC,
9462              but handle them anyway.  */
9463           if (local_syms != NULL)
9464             for (sym = local_syms;
9465                  sym < local_syms + symtab_hdr->sh_info;
9466                  ++sym)
9467               if (sym->st_value != 0
9468                   && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9469                 {
9470                   unsigned long i;
9471
9472                   if (sym->st_value > toc->rawsize)
9473                     i = toc->rawsize >> 3;
9474                   else
9475                     i = sym->st_value >> 3;
9476
9477                   if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9478                     {
9479                       if (local_toc_syms)
9480                         _bfd_error_handler
9481                           (_("%s defined on removed toc entry"),
9482                            bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9483                       do
9484                         ++i;
9485                       while ((skip[i] & (ref_from_discarded | can_optimize)));
9486                       sym->st_value = (bfd_vma) i << 3;
9487                     }
9488
9489                   sym->st_value -= skip[i];
9490                   symtab_hdr->contents = (unsigned char *) local_syms;
9491                 }
9492
9493           /* Adjust any global syms defined in this toc input section.  */
9494           if (toc_inf.global_toc_syms)
9495             {
9496               toc_inf.toc = toc;
9497               toc_inf.skip = skip;
9498               toc_inf.global_toc_syms = FALSE;
9499               elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9500                                       &toc_inf);
9501             }
9502
9503           if (toc->reloc_count != 0)
9504             {
9505               Elf_Internal_Shdr *rel_hdr;
9506               Elf_Internal_Rela *wrel;
9507               bfd_size_type sz;
9508
9509               /* Remove unused toc relocs, and adjust those we keep.  */
9510               if (toc_relocs == NULL)
9511                 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9512                                                         info->keep_memory);
9513               if (toc_relocs == NULL)
9514                 goto error_ret;
9515
9516               wrel = toc_relocs;
9517               for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9518                 if ((skip[rel->r_offset >> 3]
9519                      & (ref_from_discarded | can_optimize)) == 0)
9520                   {
9521                     wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9522                     wrel->r_info = rel->r_info;
9523                     wrel->r_addend = rel->r_addend;
9524                     ++wrel;
9525                   }
9526                 else if (!dec_dynrel_count (rel->r_info, toc, info,
9527                                             &local_syms, NULL, NULL))
9528                   goto error_ret;
9529
9530               elf_section_data (toc)->relocs = toc_relocs;
9531               toc->reloc_count = wrel - toc_relocs;
9532               rel_hdr = _bfd_elf_single_rel_hdr (toc);
9533               sz = rel_hdr->sh_entsize;
9534               rel_hdr->sh_size = toc->reloc_count * sz;
9535             }
9536         }
9537       else if (toc_relocs != NULL
9538                && elf_section_data (toc)->relocs != toc_relocs)
9539         free (toc_relocs);
9540
9541       if (local_syms != NULL
9542           && symtab_hdr->contents != (unsigned char *) local_syms)
9543         {
9544           if (!info->keep_memory)
9545             free (local_syms);
9546           else
9547             symtab_hdr->contents = (unsigned char *) local_syms;
9548         }
9549       free (skip);
9550     }
9551
9552   return TRUE;
9553 }
9554
9555 /* Return true iff input section I references the TOC using
9556    instructions limited to +/-32k offsets.  */
9557
9558 bfd_boolean
9559 ppc64_elf_has_small_toc_reloc (asection *i)
9560 {
9561   return (is_ppc64_elf (i->owner)
9562           && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9563 }
9564
9565 /* Allocate space for one GOT entry.  */
9566
9567 static void
9568 allocate_got (struct elf_link_hash_entry *h,
9569               struct bfd_link_info *info,
9570               struct got_entry *gent)
9571 {
9572   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9573   bfd_boolean dyn;
9574   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9575   int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9576                  ? 16 : 8);
9577   int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9578                   ? 2 : 1) * sizeof (Elf64_External_Rela);
9579   asection *got = ppc64_elf_tdata (gent->owner)->got;
9580
9581   gent->got.offset = got->size;
9582   got->size += entsize;
9583
9584   dyn = htab->elf.dynamic_sections_created;
9585   if (h->type == STT_GNU_IFUNC)
9586     {
9587       htab->elf.irelplt->size += rentsize;
9588       htab->got_reli_size += rentsize;
9589     }
9590   else if ((bfd_link_pic (info)
9591             || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
9592            && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9593                || h->root.type != bfd_link_hash_undefweak))
9594     {
9595       asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9596       relgot->size += rentsize;
9597     }
9598 }
9599
9600 /* This function merges got entries in the same toc group.  */
9601
9602 static void
9603 merge_got_entries (struct got_entry **pent)
9604 {
9605   struct got_entry *ent, *ent2;
9606
9607   for (ent = *pent; ent != NULL; ent = ent->next)
9608     if (!ent->is_indirect)
9609       for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9610         if (!ent2->is_indirect
9611             && ent2->addend == ent->addend
9612             && ent2->tls_type == ent->tls_type
9613             && elf_gp (ent2->owner) == elf_gp (ent->owner))
9614           {
9615             ent2->is_indirect = TRUE;
9616             ent2->got.ent = ent;
9617           }
9618 }
9619
9620 /* Allocate space in .plt, .got and associated reloc sections for
9621    dynamic relocs.  */
9622
9623 static bfd_boolean
9624 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9625 {
9626   struct bfd_link_info *info;
9627   struct ppc_link_hash_table *htab;
9628   asection *s;
9629   struct ppc_link_hash_entry *eh;
9630   struct got_entry **pgent, *gent;
9631
9632   if (h->root.type == bfd_link_hash_indirect)
9633     return TRUE;
9634
9635   info = (struct bfd_link_info *) inf;
9636   htab = ppc_hash_table (info);
9637   if (htab == NULL)
9638     return FALSE;
9639
9640   eh = (struct ppc_link_hash_entry *) h;
9641   /* Run through the TLS GD got entries first if we're changing them
9642      to TPREL.  */
9643   if ((eh->tls_mask & TLS_TPRELGD) != 0)
9644     for (gent = h->got.glist; gent != NULL; gent = gent->next)
9645       if (gent->got.refcount > 0
9646           && (gent->tls_type & TLS_GD) != 0)
9647         {
9648           /* This was a GD entry that has been converted to TPREL.  If
9649              there happens to be a TPREL entry we can use that one.  */
9650           struct got_entry *ent;
9651           for (ent = h->got.glist; ent != NULL; ent = ent->next)
9652             if (ent->got.refcount > 0
9653                 && (ent->tls_type & TLS_TPREL) != 0
9654                 && ent->addend == gent->addend
9655                 && ent->owner == gent->owner)
9656               {
9657                 gent->got.refcount = 0;
9658                 break;
9659               }
9660
9661           /* If not, then we'll be using our own TPREL entry.  */
9662           if (gent->got.refcount != 0)
9663             gent->tls_type = TLS_TLS | TLS_TPREL;
9664         }
9665
9666   /* Remove any list entry that won't generate a word in the GOT before
9667      we call merge_got_entries.  Otherwise we risk merging to empty
9668      entries.  */
9669   pgent = &h->got.glist;
9670   while ((gent = *pgent) != NULL)
9671     if (gent->got.refcount > 0)
9672       {
9673         if ((gent->tls_type & TLS_LD) != 0
9674             && !h->def_dynamic)
9675           {
9676             ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9677             *pgent = gent->next;
9678           }
9679         else
9680           pgent = &gent->next;
9681       }
9682     else
9683       *pgent = gent->next;
9684
9685   if (!htab->do_multi_toc)
9686     merge_got_entries (&h->got.glist);
9687
9688   for (gent = h->got.glist; gent != NULL; gent = gent->next)
9689     if (!gent->is_indirect)
9690       {
9691         /* Make sure this symbol is output as a dynamic symbol.
9692            Undefined weak syms won't yet be marked as dynamic,
9693            nor will all TLS symbols.  */
9694         if (h->dynindx == -1
9695             && !h->forced_local
9696             && h->type != STT_GNU_IFUNC
9697             && htab->elf.dynamic_sections_created)
9698           {
9699             if (! bfd_elf_link_record_dynamic_symbol (info, h))
9700               return FALSE;
9701           }
9702
9703         if (!is_ppc64_elf (gent->owner))
9704           abort ();
9705
9706         allocate_got (h, info, gent);
9707       }
9708
9709   if (!htab->elf.dynamic_sections_created
9710       && h->type != STT_GNU_IFUNC)
9711     eh->dyn_relocs = NULL;
9712
9713   if (eh->dyn_relocs != NULL)
9714     {
9715       struct elf_dyn_relocs *p, **pp;
9716
9717       /* In the shared -Bsymbolic case, discard space allocated for
9718          dynamic pc-relative relocs against symbols which turn out to
9719          be defined in regular objects.  For the normal shared case,
9720          discard space for relocs that have become local due to symbol
9721          visibility changes.  */
9722
9723       if (bfd_link_pic (info))
9724         {
9725           /* Relocs that use pc_count are those that appear on a call
9726              insn, or certain REL relocs (see must_be_dyn_reloc) that
9727              can be generated via assembly.  We want calls to
9728              protected symbols to resolve directly to the function
9729              rather than going via the plt.  If people want function
9730              pointer comparisons to work as expected then they should
9731              avoid writing weird assembly.  */
9732           if (SYMBOL_CALLS_LOCAL (info, h))
9733             {
9734               for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9735                 {
9736                   p->count -= p->pc_count;
9737                   p->pc_count = 0;
9738                   if (p->count == 0)
9739                     *pp = p->next;
9740                   else
9741                     pp = &p->next;
9742                 }
9743             }
9744
9745           /* Also discard relocs on undefined weak syms with
9746              non-default visibility.  */
9747           if (eh->dyn_relocs != NULL
9748               && h->root.type == bfd_link_hash_undefweak)
9749             {
9750               if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9751                 eh->dyn_relocs = NULL;
9752
9753               /* Make sure this symbol is output as a dynamic symbol.
9754                  Undefined weak syms won't yet be marked as dynamic.  */
9755               else if (h->dynindx == -1
9756                        && !h->forced_local)
9757                 {
9758                   if (! bfd_elf_link_record_dynamic_symbol (info, h))
9759                     return FALSE;
9760                 }
9761             }
9762         }
9763       else if (h->type == STT_GNU_IFUNC)
9764         {
9765           /* A plt entry is always created when making direct calls to
9766              an ifunc, even when building a static executable, but
9767              that doesn't cover all cases.  We may have only an ifunc
9768              initialised function pointer for a given ifunc symbol.
9769
9770              For ELFv2, dynamic relocations are not required when
9771              generating a global entry PLT stub.  */
9772           if (abiversion (info->output_bfd) >= 2)
9773             {
9774               if (global_entry_stub (h))
9775                 eh->dyn_relocs = NULL;
9776             }
9777
9778           /* For ELFv1 we have function descriptors.  Descriptors need
9779              to be treated like PLT entries and thus have dynamic
9780              relocations.  One exception is when the function
9781              descriptor is copied into .dynbss (which should only
9782              happen with ancient versions of gcc).  */
9783           else if (h->needs_copy)
9784             eh->dyn_relocs = NULL;
9785         }
9786       else if (ELIMINATE_COPY_RELOCS)
9787         {
9788           /* For the non-pic case, discard space for relocs against
9789              symbols which turn out to need copy relocs or are not
9790              dynamic.  */
9791
9792           /* First make sure this symbol is output as a dynamic symbol.
9793              Undefined weak syms won't yet be marked as dynamic.  */
9794           if (h->root.type == bfd_link_hash_undefweak
9795               && !h->non_got_ref
9796               && !h->def_regular
9797               && h->dynindx == -1
9798               && !h->forced_local
9799               && !bfd_elf_link_record_dynamic_symbol (info, h))
9800             return FALSE;
9801
9802           if (h->non_got_ref
9803               || h->def_regular
9804               || h->dynindx == -1)
9805             eh->dyn_relocs = NULL;
9806         }
9807
9808       /* Finally, allocate space.  */
9809       for (p = eh->dyn_relocs; p != NULL; p = p->next)
9810         {
9811           asection *sreloc = elf_section_data (p->sec)->sreloc;
9812           if (eh->elf.type == STT_GNU_IFUNC)
9813             sreloc = htab->elf.irelplt;
9814           sreloc->size += p->count * sizeof (Elf64_External_Rela);
9815         }
9816     }
9817
9818   if ((htab->elf.dynamic_sections_created
9819        && h->dynindx != -1
9820        && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
9821       || h->type == STT_GNU_IFUNC)
9822     {
9823       struct plt_entry *pent;
9824       bfd_boolean doneone = FALSE;
9825       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9826         if (pent->plt.refcount > 0)
9827           {
9828             if (!htab->elf.dynamic_sections_created
9829                 || h->dynindx == -1)
9830               {
9831                 s = htab->elf.iplt;
9832                 pent->plt.offset = s->size;
9833                 s->size += PLT_ENTRY_SIZE (htab);
9834                 s = htab->elf.irelplt;
9835               }
9836             else
9837               {
9838                 /* If this is the first .plt entry, make room for the special
9839                    first entry.  */
9840                 s = htab->elf.splt;
9841                 if (s->size == 0)
9842                   s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9843
9844                 pent->plt.offset = s->size;
9845
9846                 /* Make room for this entry.  */
9847                 s->size += PLT_ENTRY_SIZE (htab);
9848
9849                 /* Make room for the .glink code.  */
9850                 s = htab->glink;
9851                 if (s->size == 0)
9852                   s->size += GLINK_CALL_STUB_SIZE;
9853                 if (htab->opd_abi)
9854                   {
9855                     /* We need bigger stubs past index 32767.  */
9856                     if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9857                       s->size += 4;
9858                     s->size += 2*4;
9859                   }
9860                 else
9861                   s->size += 4;
9862
9863                 /* We also need to make an entry in the .rela.plt section.  */
9864                 s = htab->elf.srelplt;
9865               }
9866             s->size += sizeof (Elf64_External_Rela);
9867             doneone = TRUE;
9868           }
9869         else
9870           pent->plt.offset = (bfd_vma) -1;
9871       if (!doneone)
9872         {
9873           h->plt.plist = NULL;
9874           h->needs_plt = 0;
9875         }
9876     }
9877   else
9878     {
9879       h->plt.plist = NULL;
9880       h->needs_plt = 0;
9881     }
9882
9883   return TRUE;
9884 }
9885
9886 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9887    to set up space for global entry stubs.  These are put in glink,
9888    after the branch table.  */
9889
9890 static bfd_boolean
9891 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
9892 {
9893   struct bfd_link_info *info;
9894   struct ppc_link_hash_table *htab;
9895   struct plt_entry *pent;
9896   asection *s;
9897
9898   if (h->root.type == bfd_link_hash_indirect)
9899     return TRUE;
9900
9901   if (!h->pointer_equality_needed)
9902     return TRUE;
9903
9904   if (h->def_regular)
9905     return TRUE;
9906
9907   info = inf;
9908   htab = ppc_hash_table (info);
9909   if (htab == NULL)
9910     return FALSE;
9911
9912   s = htab->glink;
9913   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9914     if (pent->plt.offset != (bfd_vma) -1
9915         && pent->addend == 0)
9916       {
9917         /* For ELFv2, if this symbol is not defined in a regular file
9918            and we are not generating a shared library or pie, then we
9919            need to define the symbol in the executable on a call stub.
9920            This is to avoid text relocations.  */
9921         s->size = (s->size + 15) & -16;
9922         h->root.type = bfd_link_hash_defined;
9923         h->root.u.def.section = s;
9924         h->root.u.def.value = s->size;
9925         s->size += 16;
9926         break;
9927       }
9928   return TRUE;
9929 }
9930
9931 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9932    read-only sections.  */
9933
9934 static bfd_boolean
9935 maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
9936 {
9937   if (h->root.type == bfd_link_hash_indirect)
9938     return TRUE;
9939
9940   if (readonly_dynrelocs (h))
9941     {
9942       ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
9943
9944       /* Not an error, just cut short the traversal.  */
9945       return FALSE;
9946     }
9947   return TRUE;
9948 }
9949
9950 /* Set the sizes of the dynamic sections.  */
9951
9952 static bfd_boolean
9953 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
9954                                  struct bfd_link_info *info)
9955 {
9956   struct ppc_link_hash_table *htab;
9957   bfd *dynobj;
9958   asection *s;
9959   bfd_boolean relocs;
9960   bfd *ibfd;
9961   struct got_entry *first_tlsld;
9962
9963   htab = ppc_hash_table (info);
9964   if (htab == NULL)
9965     return FALSE;
9966
9967   dynobj = htab->elf.dynobj;
9968   if (dynobj == NULL)
9969     abort ();
9970
9971   if (htab->elf.dynamic_sections_created)
9972     {
9973       /* Set the contents of the .interp section to the interpreter.  */
9974       if (bfd_link_executable (info) && !info->nointerp)
9975         {
9976           s = bfd_get_linker_section (dynobj, ".interp");
9977           if (s == NULL)
9978             abort ();
9979           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
9980           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
9981         }
9982     }
9983
9984   /* Set up .got offsets for local syms, and space for local dynamic
9985      relocs.  */
9986   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9987     {
9988       struct got_entry **lgot_ents;
9989       struct got_entry **end_lgot_ents;
9990       struct plt_entry **local_plt;
9991       struct plt_entry **end_local_plt;
9992       unsigned char *lgot_masks;
9993       bfd_size_type locsymcount;
9994       Elf_Internal_Shdr *symtab_hdr;
9995
9996       if (!is_ppc64_elf (ibfd))
9997         continue;
9998
9999       for (s = ibfd->sections; s != NULL; s = s->next)
10000         {
10001           struct ppc_dyn_relocs *p;
10002
10003           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
10004             {
10005               if (!bfd_is_abs_section (p->sec)
10006                   && bfd_is_abs_section (p->sec->output_section))
10007                 {
10008                   /* Input section has been discarded, either because
10009                      it is a copy of a linkonce section or due to
10010                      linker script /DISCARD/, so we'll be discarding
10011                      the relocs too.  */
10012                 }
10013               else if (p->count != 0)
10014                 {
10015                   asection *srel = elf_section_data (p->sec)->sreloc;
10016                   if (p->ifunc)
10017                     srel = htab->elf.irelplt;
10018                   srel->size += p->count * sizeof (Elf64_External_Rela);
10019                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
10020                     info->flags |= DF_TEXTREL;
10021                 }
10022             }
10023         }
10024
10025       lgot_ents = elf_local_got_ents (ibfd);
10026       if (!lgot_ents)
10027         continue;
10028
10029       symtab_hdr = &elf_symtab_hdr (ibfd);
10030       locsymcount = symtab_hdr->sh_info;
10031       end_lgot_ents = lgot_ents + locsymcount;
10032       local_plt = (struct plt_entry **) end_lgot_ents;
10033       end_local_plt = local_plt + locsymcount;
10034       lgot_masks = (unsigned char *) end_local_plt;
10035       s = ppc64_elf_tdata (ibfd)->got;
10036       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
10037         {
10038           struct got_entry **pent, *ent;
10039
10040           pent = lgot_ents;
10041           while ((ent = *pent) != NULL)
10042             if (ent->got.refcount > 0)
10043               {
10044                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
10045                   {
10046                     ppc64_tlsld_got (ibfd)->got.refcount += 1;
10047                     *pent = ent->next;
10048                   }
10049                 else
10050                   {
10051                     unsigned int ent_size = 8;
10052                     unsigned int rel_size = sizeof (Elf64_External_Rela);
10053
10054                     ent->got.offset = s->size;
10055                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
10056                       {
10057                         ent_size *= 2;
10058                         rel_size *= 2;
10059                       }
10060                     s->size += ent_size;
10061                     if ((*lgot_masks & PLT_IFUNC) != 0)
10062                       {
10063                         htab->elf.irelplt->size += rel_size;
10064                         htab->got_reli_size += rel_size;
10065                       }
10066                     else if (bfd_link_pic (info))
10067                       {
10068                         asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10069                         srel->size += rel_size;
10070                       }
10071                     pent = &ent->next;
10072                   }
10073               }
10074             else
10075               *pent = ent->next;
10076         }
10077
10078       /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt.  */
10079       for (; local_plt < end_local_plt; ++local_plt)
10080         {
10081           struct plt_entry *ent;
10082
10083           for (ent = *local_plt; ent != NULL; ent = ent->next)
10084             if (ent->plt.refcount > 0)
10085               {
10086                 s = htab->elf.iplt;
10087                 ent->plt.offset = s->size;
10088                 s->size += PLT_ENTRY_SIZE (htab);
10089
10090                 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
10091               }
10092             else
10093               ent->plt.offset = (bfd_vma) -1;
10094         }
10095     }
10096
10097   /* Allocate global sym .plt and .got entries, and space for global
10098      sym dynamic relocs.  */
10099   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
10100   /* Stash the end of glink branch table.  */
10101   if (htab->glink != NULL)
10102     htab->glink->rawsize = htab->glink->size;
10103
10104   if (!htab->opd_abi && !bfd_link_pic (info))
10105     elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
10106
10107   first_tlsld = NULL;
10108   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10109     {
10110       struct got_entry *ent;
10111
10112       if (!is_ppc64_elf (ibfd))
10113         continue;
10114
10115       ent = ppc64_tlsld_got (ibfd);
10116       if (ent->got.refcount > 0)
10117         {
10118           if (!htab->do_multi_toc && first_tlsld != NULL)
10119             {
10120               ent->is_indirect = TRUE;
10121               ent->got.ent = first_tlsld;
10122             }
10123           else
10124             {
10125               if (first_tlsld == NULL)
10126                 first_tlsld = ent;
10127               s = ppc64_elf_tdata (ibfd)->got;
10128               ent->got.offset = s->size;
10129               ent->owner = ibfd;
10130               s->size += 16;
10131               if (bfd_link_pic (info))
10132                 {
10133                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10134                   srel->size += sizeof (Elf64_External_Rela);
10135                 }
10136             }
10137         }
10138       else
10139         ent->got.offset = (bfd_vma) -1;
10140     }
10141
10142   /* We now have determined the sizes of the various dynamic sections.
10143      Allocate memory for them.  */
10144   relocs = FALSE;
10145   for (s = dynobj->sections; s != NULL; s = s->next)
10146     {
10147       if ((s->flags & SEC_LINKER_CREATED) == 0)
10148         continue;
10149
10150       if (s == htab->brlt || s == htab->relbrlt)
10151         /* These haven't been allocated yet;  don't strip.  */
10152         continue;
10153       else if (s == htab->elf.sgot
10154                || s == htab->elf.splt
10155                || s == htab->elf.iplt
10156                || s == htab->glink
10157                || s == htab->dynbss)
10158         {
10159           /* Strip this section if we don't need it; see the
10160              comment below.  */
10161         }
10162       else if (s == htab->glink_eh_frame)
10163         {
10164           if (!bfd_is_abs_section (s->output_section))
10165             /* Not sized yet.  */
10166             continue;
10167         }
10168       else if (CONST_STRNEQ (s->name, ".rela"))
10169         {
10170           if (s->size != 0)
10171             {
10172               if (s != htab->elf.srelplt)
10173                 relocs = TRUE;
10174
10175               /* We use the reloc_count field as a counter if we need
10176                  to copy relocs into the output file.  */
10177               s->reloc_count = 0;
10178             }
10179         }
10180       else
10181         {
10182           /* It's not one of our sections, so don't allocate space.  */
10183           continue;
10184         }
10185
10186       if (s->size == 0)
10187         {
10188           /* If we don't need this section, strip it from the
10189              output file.  This is mostly to handle .rela.bss and
10190              .rela.plt.  We must create both sections in
10191              create_dynamic_sections, because they must be created
10192              before the linker maps input sections to output
10193              sections.  The linker does that before
10194              adjust_dynamic_symbol is called, and it is that
10195              function which decides whether anything needs to go
10196              into these sections.  */
10197           s->flags |= SEC_EXCLUDE;
10198           continue;
10199         }
10200
10201       if ((s->flags & SEC_HAS_CONTENTS) == 0)
10202         continue;
10203
10204       /* Allocate memory for the section contents.  We use bfd_zalloc
10205          here in case unused entries are not reclaimed before the
10206          section's contents are written out.  This should not happen,
10207          but this way if it does we get a R_PPC64_NONE reloc in .rela
10208          sections instead of garbage.
10209          We also rely on the section contents being zero when writing
10210          the GOT.  */
10211       s->contents = bfd_zalloc (dynobj, s->size);
10212       if (s->contents == NULL)
10213         return FALSE;
10214     }
10215
10216   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10217     {
10218       if (!is_ppc64_elf (ibfd))
10219         continue;
10220
10221       s = ppc64_elf_tdata (ibfd)->got;
10222       if (s != NULL && s != htab->elf.sgot)
10223         {
10224           if (s->size == 0)
10225             s->flags |= SEC_EXCLUDE;
10226           else
10227             {
10228               s->contents = bfd_zalloc (ibfd, s->size);
10229               if (s->contents == NULL)
10230                 return FALSE;
10231             }
10232         }
10233       s = ppc64_elf_tdata (ibfd)->relgot;
10234       if (s != NULL)
10235         {
10236           if (s->size == 0)
10237             s->flags |= SEC_EXCLUDE;
10238           else
10239             {
10240               s->contents = bfd_zalloc (ibfd, s->size);
10241               if (s->contents == NULL)
10242                 return FALSE;
10243               relocs = TRUE;
10244               s->reloc_count = 0;
10245             }
10246         }
10247     }
10248
10249   if (htab->elf.dynamic_sections_created)
10250     {
10251       bfd_boolean tls_opt;
10252
10253       /* Add some entries to the .dynamic section.  We fill in the
10254          values later, in ppc64_elf_finish_dynamic_sections, but we
10255          must add the entries now so that we get the correct size for
10256          the .dynamic section.  The DT_DEBUG entry is filled in by the
10257          dynamic linker and used by the debugger.  */
10258 #define add_dynamic_entry(TAG, VAL) \
10259   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10260
10261       if (bfd_link_executable (info))
10262         {
10263           if (!add_dynamic_entry (DT_DEBUG, 0))
10264             return FALSE;
10265         }
10266
10267       if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
10268         {
10269           if (!add_dynamic_entry (DT_PLTGOT, 0)
10270               || !add_dynamic_entry (DT_PLTRELSZ, 0)
10271               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
10272               || !add_dynamic_entry (DT_JMPREL, 0)
10273               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
10274             return FALSE;
10275         }
10276
10277       if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
10278         {
10279           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
10280               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
10281             return FALSE;
10282         }
10283
10284       tls_opt = (htab->params->tls_get_addr_opt
10285                  && htab->tls_get_addr_fd != NULL
10286                  && htab->tls_get_addr_fd->elf.plt.plist != NULL);
10287       if (tls_opt || !htab->opd_abi)
10288         {
10289           if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
10290             return FALSE;
10291         }
10292
10293       if (relocs)
10294         {
10295           if (!add_dynamic_entry (DT_RELA, 0)
10296               || !add_dynamic_entry (DT_RELASZ, 0)
10297               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
10298             return FALSE;
10299
10300           /* If any dynamic relocs apply to a read-only section,
10301              then we need a DT_TEXTREL entry.  */
10302           if ((info->flags & DF_TEXTREL) == 0)
10303             elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
10304
10305           if ((info->flags & DF_TEXTREL) != 0)
10306             {
10307               if (!add_dynamic_entry (DT_TEXTREL, 0))
10308                 return FALSE;
10309             }
10310         }
10311     }
10312 #undef add_dynamic_entry
10313
10314   return TRUE;
10315 }
10316
10317 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
10318
10319 static bfd_boolean
10320 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
10321 {
10322   if (h->plt.plist != NULL
10323       && !h->def_regular
10324       && !h->pointer_equality_needed)
10325     return FALSE;
10326
10327   return _bfd_elf_hash_symbol (h);
10328 }
10329
10330 /* Determine the type of stub needed, if any, for a call.  */
10331
10332 static inline enum ppc_stub_type
10333 ppc_type_of_stub (asection *input_sec,
10334                   const Elf_Internal_Rela *rel,
10335                   struct ppc_link_hash_entry **hash,
10336                   struct plt_entry **plt_ent,
10337                   bfd_vma destination,
10338                   unsigned long local_off)
10339 {
10340   struct ppc_link_hash_entry *h = *hash;
10341   bfd_vma location;
10342   bfd_vma branch_offset;
10343   bfd_vma max_branch_offset;
10344   enum elf_ppc64_reloc_type r_type;
10345
10346   if (h != NULL)
10347     {
10348       struct plt_entry *ent;
10349       struct ppc_link_hash_entry *fdh = h;
10350       if (h->oh != NULL
10351           && h->oh->is_func_descriptor)
10352         {
10353           fdh = ppc_follow_link (h->oh);
10354           *hash = fdh;
10355         }
10356
10357       for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10358         if (ent->addend == rel->r_addend
10359             && ent->plt.offset != (bfd_vma) -1)
10360           {
10361             *plt_ent = ent;
10362             return ppc_stub_plt_call;
10363           }
10364
10365       /* Here, we know we don't have a plt entry.  If we don't have a
10366          either a defined function descriptor or a defined entry symbol
10367          in a regular object file, then it is pointless trying to make
10368          any other type of stub.  */
10369       if (!is_static_defined (&fdh->elf)
10370           && !is_static_defined (&h->elf))
10371         return ppc_stub_none;
10372     }
10373   else if (elf_local_got_ents (input_sec->owner) != NULL)
10374     {
10375       Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10376       struct plt_entry **local_plt = (struct plt_entry **)
10377         elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10378       unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10379
10380       if (local_plt[r_symndx] != NULL)
10381         {
10382           struct plt_entry *ent;
10383
10384           for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10385             if (ent->addend == rel->r_addend
10386                 && ent->plt.offset != (bfd_vma) -1)
10387               {
10388                 *plt_ent = ent;
10389                 return ppc_stub_plt_call;
10390               }
10391         }
10392     }
10393
10394   /* Determine where the call point is.  */
10395   location = (input_sec->output_offset
10396               + input_sec->output_section->vma
10397               + rel->r_offset);
10398
10399   branch_offset = destination - location;
10400   r_type = ELF64_R_TYPE (rel->r_info);
10401
10402   /* Determine if a long branch stub is needed.  */
10403   max_branch_offset = 1 << 25;
10404   if (r_type != R_PPC64_REL24)
10405     max_branch_offset = 1 << 15;
10406
10407   if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10408     /* We need a stub.  Figure out whether a long_branch or plt_branch
10409        is needed later.  */
10410     return ppc_stub_long_branch;
10411
10412   return ppc_stub_none;
10413 }
10414
10415 /* With power7 weakly ordered memory model, it is possible for ld.so
10416    to update a plt entry in one thread and have another thread see a
10417    stale zero toc entry.  To avoid this we need some sort of acquire
10418    barrier in the call stub.  One solution is to make the load of the
10419    toc word seem to appear to depend on the load of the function entry
10420    word.  Another solution is to test for r2 being zero, and branch to
10421    the appropriate glink entry if so.
10422
10423    .    fake dep barrier        compare
10424    .    ld 12,xxx(2)            ld 12,xxx(2)
10425    .    mtctr 12                mtctr 12
10426    .    xor 11,12,12            ld 2,xxx+8(2)
10427    .    add 2,2,11              cmpldi 2,0
10428    .    ld 2,xxx+8(2)           bnectr+
10429    .    bctr                    b <glink_entry>
10430
10431    The solution involving the compare turns out to be faster, so
10432    that's what we use unless the branch won't reach.  */
10433
10434 #define ALWAYS_USE_FAKE_DEP 0
10435 #define ALWAYS_EMIT_R2SAVE 0
10436
10437 #define PPC_LO(v) ((v) & 0xffff)
10438 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10439 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10440
10441 static inline unsigned int
10442 plt_stub_size (struct ppc_link_hash_table *htab,
10443                struct ppc_stub_hash_entry *stub_entry,
10444                bfd_vma off)
10445 {
10446   unsigned size = 12;
10447
10448   if (ALWAYS_EMIT_R2SAVE
10449       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10450     size += 4;
10451   if (PPC_HA (off) != 0)
10452     size += 4;
10453   if (htab->opd_abi)
10454     {
10455       size += 4;
10456       if (htab->params->plt_static_chain)
10457         size += 4;
10458       if (htab->params->plt_thread_safe
10459           && htab->elf.dynamic_sections_created
10460           && stub_entry->h != NULL
10461           && stub_entry->h->elf.dynindx != -1)
10462         size += 8;
10463       if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
10464         size += 4;
10465     }
10466   if (stub_entry->h != NULL
10467       && (stub_entry->h == htab->tls_get_addr_fd
10468           || stub_entry->h == htab->tls_get_addr)
10469       && htab->params->tls_get_addr_opt)
10470     size += 13 * 4;
10471   return size;
10472 }
10473
10474 /* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
10475    then return the padding needed to do so.  */
10476 static inline unsigned int
10477 plt_stub_pad (struct ppc_link_hash_table *htab,
10478               struct ppc_stub_hash_entry *stub_entry,
10479               bfd_vma plt_off)
10480 {
10481   int stub_align = 1 << htab->params->plt_stub_align;
10482   unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10483   bfd_vma stub_off = stub_entry->group->stub_sec->size;
10484
10485   if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10486       > ((stub_size - 1) & -stub_align))
10487     return stub_align - (stub_off & (stub_align - 1));
10488   return 0;
10489 }
10490
10491 /* Build a .plt call stub.  */
10492
10493 static inline bfd_byte *
10494 build_plt_stub (struct ppc_link_hash_table *htab,
10495                 struct ppc_stub_hash_entry *stub_entry,
10496                 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10497 {
10498   bfd *obfd = htab->params->stub_bfd;
10499   bfd_boolean plt_load_toc = htab->opd_abi;
10500   bfd_boolean plt_static_chain = htab->params->plt_static_chain;
10501   bfd_boolean plt_thread_safe = (htab->params->plt_thread_safe
10502                                  && htab->elf.dynamic_sections_created
10503                                  && stub_entry->h != NULL
10504                                  && stub_entry->h->elf.dynindx != -1);
10505   bfd_boolean use_fake_dep = plt_thread_safe;
10506   bfd_vma cmp_branch_off = 0;
10507
10508   if (!ALWAYS_USE_FAKE_DEP
10509       && plt_load_toc
10510       && plt_thread_safe
10511       && !((stub_entry->h == htab->tls_get_addr_fd
10512             || stub_entry->h == htab->tls_get_addr)
10513            && htab->params->tls_get_addr_opt))
10514     {
10515       bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10516       bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10517                           / PLT_ENTRY_SIZE (htab));
10518       bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10519       bfd_vma to, from;
10520
10521       if (pltindex > 32768)
10522         glinkoff += (pltindex - 32768) * 4;
10523       to = (glinkoff
10524             + htab->glink->output_offset
10525             + htab->glink->output_section->vma);
10526       from = (p - stub_entry->group->stub_sec->contents
10527               + 4 * (ALWAYS_EMIT_R2SAVE
10528                      || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10529               + 4 * (PPC_HA (offset) != 0)
10530               + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10531                      != PPC_HA (offset))
10532               + 4 * (plt_static_chain != 0)
10533               + 20
10534               + stub_entry->group->stub_sec->output_offset
10535               + stub_entry->group->stub_sec->output_section->vma);
10536       cmp_branch_off = to - from;
10537       use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10538     }
10539
10540   if (PPC_HA (offset) != 0)
10541     {
10542       if (r != NULL)
10543         {
10544           if (ALWAYS_EMIT_R2SAVE
10545               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10546             r[0].r_offset += 4;
10547           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10548           r[1].r_offset = r[0].r_offset + 4;
10549           r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10550           r[1].r_addend = r[0].r_addend;
10551           if (plt_load_toc)
10552             {
10553               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10554                 {
10555                   r[2].r_offset = r[1].r_offset + 4;
10556                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10557                   r[2].r_addend = r[0].r_addend;
10558                 }
10559               else
10560                 {
10561                   r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10562                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10563                   r[2].r_addend = r[0].r_addend + 8;
10564                   if (plt_static_chain)
10565                     {
10566                       r[3].r_offset = r[2].r_offset + 4;
10567                       r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10568                       r[3].r_addend = r[0].r_addend + 16;
10569                     }
10570                 }
10571             }
10572         }
10573       if (ALWAYS_EMIT_R2SAVE
10574           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10575         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10576       if (plt_load_toc)
10577         {
10578           bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10579           bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p),  p += 4;
10580         }
10581       else
10582         {
10583           bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
10584           bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p),  p += 4;
10585         }
10586       if (plt_load_toc
10587           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10588         {
10589           bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10590           offset = 0;
10591         }
10592       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10593       if (plt_load_toc)
10594         {
10595           if (use_fake_dep)
10596             {
10597               bfd_put_32 (obfd, XOR_R2_R12_R12, p),             p += 4;
10598               bfd_put_32 (obfd, ADD_R11_R11_R2, p),             p += 4;
10599             }
10600           bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10601           if (plt_static_chain)
10602             bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10603         }
10604     }
10605   else
10606     {
10607       if (r != NULL)
10608         {
10609           if (ALWAYS_EMIT_R2SAVE
10610               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10611             r[0].r_offset += 4;
10612           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10613           if (plt_load_toc)
10614             {
10615               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10616                 {
10617                   r[1].r_offset = r[0].r_offset + 4;
10618                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10619                   r[1].r_addend = r[0].r_addend;
10620                 }
10621               else
10622                 {
10623                   r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10624                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10625                   r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10626                   if (plt_static_chain)
10627                     {
10628                       r[2].r_offset = r[1].r_offset + 4;
10629                       r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10630                       r[2].r_addend = r[0].r_addend + 8;
10631                     }
10632                 }
10633             }
10634         }
10635       if (ALWAYS_EMIT_R2SAVE
10636           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10637         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10638       bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p),       p += 4;
10639       if (plt_load_toc
10640           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10641         {
10642           bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),   p += 4;
10643           offset = 0;
10644         }
10645       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10646       if (plt_load_toc)
10647         {
10648           if (use_fake_dep)
10649             {
10650               bfd_put_32 (obfd, XOR_R11_R12_R12, p),            p += 4;
10651               bfd_put_32 (obfd, ADD_R2_R2_R11, p),              p += 4;
10652             }
10653           if (plt_static_chain)
10654             bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10655           bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10656         }
10657     }
10658   if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10659     {
10660       bfd_put_32 (obfd, CMPLDI_R2_0, p),                        p += 4;
10661       bfd_put_32 (obfd, BNECTR_P4, p),                          p += 4;
10662       bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10663     }
10664   else
10665     bfd_put_32 (obfd, BCTR, p),                                 p += 4;
10666   return p;
10667 }
10668
10669 /* Build a special .plt call stub for __tls_get_addr.  */
10670
10671 #define LD_R11_0R3      0xe9630000
10672 #define LD_R12_0R3      0xe9830000
10673 #define MR_R0_R3        0x7c601b78
10674 #define CMPDI_R11_0     0x2c2b0000
10675 #define ADD_R3_R12_R13  0x7c6c6a14
10676 #define BEQLR           0x4d820020
10677 #define MR_R3_R0        0x7c030378
10678 #define STD_R11_0R1     0xf9610000
10679 #define BCTRL           0x4e800421
10680 #define LD_R11_0R1      0xe9610000
10681 #define MTLR_R11        0x7d6803a6
10682
10683 static inline bfd_byte *
10684 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10685                          struct ppc_stub_hash_entry *stub_entry,
10686                          bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10687 {
10688   bfd *obfd = htab->params->stub_bfd;
10689
10690   bfd_put_32 (obfd, LD_R11_0R3 + 0, p),         p += 4;
10691   bfd_put_32 (obfd, LD_R12_0R3 + 8, p),         p += 4;
10692   bfd_put_32 (obfd, MR_R0_R3, p),               p += 4;
10693   bfd_put_32 (obfd, CMPDI_R11_0, p),            p += 4;
10694   bfd_put_32 (obfd, ADD_R3_R12_R13, p),         p += 4;
10695   bfd_put_32 (obfd, BEQLR, p),                  p += 4;
10696   bfd_put_32 (obfd, MR_R3_R0, p),               p += 4;
10697   bfd_put_32 (obfd, MFLR_R11, p),               p += 4;
10698   bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10699
10700   if (r != NULL)
10701     r[0].r_offset += 9 * 4;
10702   p = build_plt_stub (htab, stub_entry, p, offset, r);
10703   bfd_put_32 (obfd, BCTRL, p - 4);
10704
10705   bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p),     p += 4;
10706   bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10707   bfd_put_32 (obfd, MTLR_R11, p),               p += 4;
10708   bfd_put_32 (obfd, BLR, p),                    p += 4;
10709
10710   return p;
10711 }
10712
10713 static Elf_Internal_Rela *
10714 get_relocs (asection *sec, int count)
10715 {
10716   Elf_Internal_Rela *relocs;
10717   struct bfd_elf_section_data *elfsec_data;
10718
10719   elfsec_data = elf_section_data (sec);
10720   relocs = elfsec_data->relocs;
10721   if (relocs == NULL)
10722     {
10723       bfd_size_type relsize;
10724       relsize = sec->reloc_count * sizeof (*relocs);
10725       relocs = bfd_alloc (sec->owner, relsize);
10726       if (relocs == NULL)
10727         return NULL;
10728       elfsec_data->relocs = relocs;
10729       elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10730                                           sizeof (Elf_Internal_Shdr));
10731       if (elfsec_data->rela.hdr == NULL)
10732         return NULL;
10733       elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10734                                         * sizeof (Elf64_External_Rela));
10735       elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10736       sec->reloc_count = 0;
10737     }
10738   relocs += sec->reloc_count;
10739   sec->reloc_count += count;
10740   return relocs;
10741 }
10742
10743 static bfd_vma
10744 get_r2off (struct bfd_link_info *info,
10745            struct ppc_stub_hash_entry *stub_entry)
10746 {
10747   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10748   bfd_vma r2off = htab->sec_info[stub_entry->target_section->id].toc_off;
10749
10750   if (r2off == 0)
10751     {
10752       /* Support linking -R objects.  Get the toc pointer from the
10753          opd entry.  */
10754       char buf[8];
10755       if (!htab->opd_abi)
10756         return r2off;
10757       asection *opd = stub_entry->h->elf.root.u.def.section;
10758       bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10759
10760       if (strcmp (opd->name, ".opd") != 0
10761           || opd->reloc_count != 0)
10762         {
10763           info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
10764                                   stub_entry->h->elf.root.root.string);
10765           bfd_set_error (bfd_error_bad_value);
10766           return (bfd_vma) -1;
10767         }
10768       if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10769         return (bfd_vma) -1;
10770       r2off = bfd_get_64 (opd->owner, buf);
10771       r2off -= elf_gp (info->output_bfd);
10772     }
10773   r2off -= htab->sec_info[stub_entry->group->link_sec->id].toc_off;
10774   return r2off;
10775 }
10776
10777 static bfd_boolean
10778 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10779 {
10780   struct ppc_stub_hash_entry *stub_entry;
10781   struct ppc_branch_hash_entry *br_entry;
10782   struct bfd_link_info *info;
10783   struct ppc_link_hash_table *htab;
10784   bfd_byte *loc;
10785   bfd_byte *p;
10786   bfd_vma dest, off;
10787   int size;
10788   Elf_Internal_Rela *r;
10789   asection *plt;
10790
10791   /* Massage our args to the form they really have.  */
10792   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10793   info = in_arg;
10794
10795   htab = ppc_hash_table (info);
10796   if (htab == NULL)
10797     return FALSE;
10798
10799   /* Make a note of the offset within the stubs for this entry.  */
10800   stub_entry->stub_offset = stub_entry->group->stub_sec->size;
10801   loc = stub_entry->group->stub_sec->contents + stub_entry->stub_offset;
10802
10803   htab->stub_count[stub_entry->stub_type - 1] += 1;
10804   switch (stub_entry->stub_type)
10805     {
10806     case ppc_stub_long_branch:
10807     case ppc_stub_long_branch_r2off:
10808       /* Branches are relative.  This is where we are going to.  */
10809       dest = (stub_entry->target_value
10810               + stub_entry->target_section->output_offset
10811               + stub_entry->target_section->output_section->vma);
10812       dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10813       off = dest;
10814
10815       /* And this is where we are coming from.  */
10816       off -= (stub_entry->stub_offset
10817               + stub_entry->group->stub_sec->output_offset
10818               + stub_entry->group->stub_sec->output_section->vma);
10819
10820       size = 4;
10821       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10822         {
10823           bfd_vma r2off = get_r2off (info, stub_entry);
10824
10825           if (r2off == (bfd_vma) -1)
10826             {
10827               htab->stub_error = TRUE;
10828               return FALSE;
10829             }
10830           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10831           loc += 4;
10832           size = 8;
10833           if (PPC_HA (r2off) != 0)
10834             {
10835               bfd_put_32 (htab->params->stub_bfd,
10836                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
10837               loc += 4;
10838               size += 4;
10839             }
10840           if (PPC_LO (r2off) != 0)
10841             {
10842               bfd_put_32 (htab->params->stub_bfd,
10843                           ADDI_R2_R2 | PPC_LO (r2off), loc);
10844               loc += 4;
10845               size += 4;
10846             }
10847           off -= size - 4;
10848         }
10849       bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10850
10851       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10852         {
10853           info->callbacks->einfo
10854             (_("%P: long branch stub `%s' offset overflow\n"),
10855              stub_entry->root.string);
10856           htab->stub_error = TRUE;
10857           return FALSE;
10858         }
10859
10860       if (info->emitrelocations)
10861         {
10862           r = get_relocs (stub_entry->group->stub_sec, 1);
10863           if (r == NULL)
10864             return FALSE;
10865           r->r_offset = loc - stub_entry->group->stub_sec->contents;
10866           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10867           r->r_addend = dest;
10868           if (stub_entry->h != NULL)
10869             {
10870               struct elf_link_hash_entry **hashes;
10871               unsigned long symndx;
10872               struct ppc_link_hash_entry *h;
10873
10874               hashes = elf_sym_hashes (htab->params->stub_bfd);
10875               if (hashes == NULL)
10876                 {
10877                   bfd_size_type hsize;
10878
10879                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10880                   hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
10881                   if (hashes == NULL)
10882                     return FALSE;
10883                   elf_sym_hashes (htab->params->stub_bfd) = hashes;
10884                   htab->stub_globals = 1;
10885                 }
10886               symndx = htab->stub_globals++;
10887               h = stub_entry->h;
10888               hashes[symndx] = &h->elf;
10889               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10890               if (h->oh != NULL && h->oh->is_func)
10891                 h = ppc_follow_link (h->oh);
10892               if (h->elf.root.u.def.section != stub_entry->target_section)
10893                 /* H is an opd symbol.  The addend must be zero.  */
10894                 r->r_addend = 0;
10895               else
10896                 {
10897                   off = (h->elf.root.u.def.value
10898                          + h->elf.root.u.def.section->output_offset
10899                          + h->elf.root.u.def.section->output_section->vma);
10900                   r->r_addend -= off;
10901                 }
10902             }
10903         }
10904       break;
10905
10906     case ppc_stub_plt_branch:
10907     case ppc_stub_plt_branch_r2off:
10908       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10909                                          stub_entry->root.string + 9,
10910                                          FALSE, FALSE);
10911       if (br_entry == NULL)
10912         {
10913           info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
10914                                   stub_entry->root.string);
10915           htab->stub_error = TRUE;
10916           return FALSE;
10917         }
10918
10919       dest = (stub_entry->target_value
10920               + stub_entry->target_section->output_offset
10921               + stub_entry->target_section->output_section->vma);
10922       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10923         dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10924
10925       bfd_put_64 (htab->brlt->owner, dest,
10926                   htab->brlt->contents + br_entry->offset);
10927
10928       if (br_entry->iter == htab->stub_iteration)
10929         {
10930           br_entry->iter = 0;
10931
10932           if (htab->relbrlt != NULL)
10933             {
10934               /* Create a reloc for the branch lookup table entry.  */
10935               Elf_Internal_Rela rela;
10936               bfd_byte *rl;
10937
10938               rela.r_offset = (br_entry->offset
10939                                + htab->brlt->output_offset
10940                                + htab->brlt->output_section->vma);
10941               rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10942               rela.r_addend = dest;
10943
10944               rl = htab->relbrlt->contents;
10945               rl += (htab->relbrlt->reloc_count++
10946                      * sizeof (Elf64_External_Rela));
10947               bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
10948             }
10949           else if (info->emitrelocations)
10950             {
10951               r = get_relocs (htab->brlt, 1);
10952               if (r == NULL)
10953                 return FALSE;
10954               /* brlt, being SEC_LINKER_CREATED does not go through the
10955                  normal reloc processing.  Symbols and offsets are not
10956                  translated from input file to output file form, so
10957                  set up the offset per the output file.  */
10958               r->r_offset = (br_entry->offset
10959                              + htab->brlt->output_offset
10960                              + htab->brlt->output_section->vma);
10961               r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10962               r->r_addend = dest;
10963             }
10964         }
10965
10966       dest = (br_entry->offset
10967               + htab->brlt->output_offset
10968               + htab->brlt->output_section->vma);
10969
10970       off = (dest
10971              - elf_gp (htab->brlt->output_section->owner)
10972              - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
10973
10974       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10975         {
10976           info->callbacks->einfo
10977             (_("%P: linkage table error against `%T'\n"),
10978              stub_entry->root.string);
10979           bfd_set_error (bfd_error_bad_value);
10980           htab->stub_error = TRUE;
10981           return FALSE;
10982         }
10983
10984       if (info->emitrelocations)
10985         {
10986           r = get_relocs (stub_entry->group->stub_sec, 1 + (PPC_HA (off) != 0));
10987           if (r == NULL)
10988             return FALSE;
10989           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
10990           if (bfd_big_endian (info->output_bfd))
10991             r[0].r_offset += 2;
10992           if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
10993             r[0].r_offset += 4;
10994           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10995           r[0].r_addend = dest;
10996           if (PPC_HA (off) != 0)
10997             {
10998               r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10999               r[1].r_offset = r[0].r_offset + 4;
11000               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
11001               r[1].r_addend = r[0].r_addend;
11002             }
11003         }
11004
11005       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11006         {
11007           if (PPC_HA (off) != 0)
11008             {
11009               size = 16;
11010               bfd_put_32 (htab->params->stub_bfd,
11011                           ADDIS_R12_R2 | PPC_HA (off), loc);
11012               loc += 4;
11013               bfd_put_32 (htab->params->stub_bfd,
11014                           LD_R12_0R12 | PPC_LO (off), loc);
11015             }
11016           else
11017             {
11018               size = 12;
11019               bfd_put_32 (htab->params->stub_bfd,
11020                           LD_R12_0R2 | PPC_LO (off), loc);
11021             }
11022         }
11023       else
11024         {
11025           bfd_vma r2off = get_r2off (info, stub_entry);
11026
11027           if (r2off == (bfd_vma) -1)
11028             {
11029               htab->stub_error = TRUE;
11030               return FALSE;
11031             }
11032
11033           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
11034           loc += 4;
11035           size = 16;
11036           if (PPC_HA (off) != 0)
11037             {
11038               size += 4;
11039               bfd_put_32 (htab->params->stub_bfd,
11040                           ADDIS_R12_R2 | PPC_HA (off), loc);
11041               loc += 4;
11042               bfd_put_32 (htab->params->stub_bfd,
11043                           LD_R12_0R12 | PPC_LO (off), loc);
11044             }
11045           else
11046             bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
11047
11048           if (PPC_HA (r2off) != 0)
11049             {
11050               size += 4;
11051               loc += 4;
11052               bfd_put_32 (htab->params->stub_bfd,
11053                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
11054             }
11055           if (PPC_LO (r2off) != 0)
11056             {
11057               size += 4;
11058               loc += 4;
11059               bfd_put_32 (htab->params->stub_bfd,
11060                           ADDI_R2_R2 | PPC_LO (r2off), loc);
11061             }
11062         }
11063       loc += 4;
11064       bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, loc);
11065       loc += 4;
11066       bfd_put_32 (htab->params->stub_bfd, BCTR, loc);
11067       break;
11068
11069     case ppc_stub_plt_call:
11070     case ppc_stub_plt_call_r2save:
11071       if (stub_entry->h != NULL
11072           && stub_entry->h->is_func_descriptor
11073           && stub_entry->h->oh != NULL)
11074         {
11075           struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
11076
11077           /* If the old-ABI "dot-symbol" is undefined make it weak so
11078              we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.  */
11079           if (fh->elf.root.type == bfd_link_hash_undefined)
11080             fh->elf.root.type = bfd_link_hash_undefweak;
11081           /* Stop undo_symbol_twiddle changing it back to undefined.  */
11082           fh->was_undefined = 0;
11083         }
11084
11085       /* Now build the stub.  */
11086       dest = stub_entry->plt_ent->plt.offset & ~1;
11087       if (dest >= (bfd_vma) -2)
11088         abort ();
11089
11090       plt = htab->elf.splt;
11091       if (!htab->elf.dynamic_sections_created
11092           || stub_entry->h == NULL
11093           || stub_entry->h->elf.dynindx == -1)
11094         plt = htab->elf.iplt;
11095
11096       dest += plt->output_offset + plt->output_section->vma;
11097
11098       if (stub_entry->h == NULL
11099           && (stub_entry->plt_ent->plt.offset & 1) == 0)
11100         {
11101           Elf_Internal_Rela rela;
11102           bfd_byte *rl;
11103
11104           rela.r_offset = dest;
11105           if (htab->opd_abi)
11106             rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
11107           else
11108             rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
11109           rela.r_addend = (stub_entry->target_value
11110                            + stub_entry->target_section->output_offset
11111                            + stub_entry->target_section->output_section->vma);
11112
11113           rl = (htab->elf.irelplt->contents
11114                 + (htab->elf.irelplt->reloc_count++
11115                    * sizeof (Elf64_External_Rela)));
11116           bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
11117           stub_entry->plt_ent->plt.offset |= 1;
11118         }
11119
11120       off = (dest
11121              - elf_gp (plt->output_section->owner)
11122              - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11123
11124       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11125         {
11126           info->callbacks->einfo
11127             (_("%P: linkage table error against `%T'\n"),
11128              stub_entry->h != NULL
11129              ? stub_entry->h->elf.root.root.string
11130              : "<local sym>");
11131           bfd_set_error (bfd_error_bad_value);
11132           htab->stub_error = TRUE;
11133           return FALSE;
11134         }
11135
11136       if (htab->params->plt_stub_align != 0)
11137         {
11138           unsigned pad = plt_stub_pad (htab, stub_entry, off);
11139
11140           stub_entry->group->stub_sec->size += pad;
11141           stub_entry->stub_offset = stub_entry->group->stub_sec->size;
11142           loc += pad;
11143         }
11144
11145       r = NULL;
11146       if (info->emitrelocations)
11147         {
11148           r = get_relocs (stub_entry->group->stub_sec,
11149                           ((PPC_HA (off) != 0)
11150                            + (htab->opd_abi
11151                               ? 2 + (htab->params->plt_static_chain
11152                                      && PPC_HA (off + 16) == PPC_HA (off))
11153                               : 1)));
11154           if (r == NULL)
11155             return FALSE;
11156           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11157           if (bfd_big_endian (info->output_bfd))
11158             r[0].r_offset += 2;
11159           r[0].r_addend = dest;
11160         }
11161       if (stub_entry->h != NULL
11162           && (stub_entry->h == htab->tls_get_addr_fd
11163               || stub_entry->h == htab->tls_get_addr)
11164           && htab->params->tls_get_addr_opt)
11165         p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
11166       else
11167         p = build_plt_stub (htab, stub_entry, loc, off, r);
11168       size = p - loc;
11169       break;
11170
11171     case ppc_stub_save_res:
11172       return TRUE;
11173
11174     default:
11175       BFD_FAIL ();
11176       return FALSE;
11177     }
11178
11179   stub_entry->group->stub_sec->size += size;
11180
11181   if (htab->params->emit_stub_syms)
11182     {
11183       struct elf_link_hash_entry *h;
11184       size_t len1, len2;
11185       char *name;
11186       const char *const stub_str[] = { "long_branch",
11187                                        "long_branch_r2off",
11188                                        "plt_branch",
11189                                        "plt_branch_r2off",
11190                                        "plt_call",
11191                                        "plt_call" };
11192
11193       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
11194       len2 = strlen (stub_entry->root.string);
11195       name = bfd_malloc (len1 + len2 + 2);
11196       if (name == NULL)
11197         return FALSE;
11198       memcpy (name, stub_entry->root.string, 9);
11199       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
11200       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
11201       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
11202       if (h == NULL)
11203         return FALSE;
11204       if (h->root.type == bfd_link_hash_new)
11205         {
11206           h->root.type = bfd_link_hash_defined;
11207           h->root.u.def.section = stub_entry->group->stub_sec;
11208           h->root.u.def.value = stub_entry->stub_offset;
11209           h->ref_regular = 1;
11210           h->def_regular = 1;
11211           h->ref_regular_nonweak = 1;
11212           h->forced_local = 1;
11213           h->non_elf = 0;
11214           h->root.linker_def = 1;
11215         }
11216     }
11217
11218   return TRUE;
11219 }
11220
11221 /* As above, but don't actually build the stub.  Just bump offset so
11222    we know stub section sizes, and select plt_branch stubs where
11223    long_branch stubs won't do.  */
11224
11225 static bfd_boolean
11226 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11227 {
11228   struct ppc_stub_hash_entry *stub_entry;
11229   struct bfd_link_info *info;
11230   struct ppc_link_hash_table *htab;
11231   bfd_vma off;
11232   int size;
11233
11234   /* Massage our args to the form they really have.  */
11235   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11236   info = in_arg;
11237
11238   htab = ppc_hash_table (info);
11239   if (htab == NULL)
11240     return FALSE;
11241
11242   if (stub_entry->h != NULL
11243       && stub_entry->h->save_res
11244       && stub_entry->h->elf.root.type == bfd_link_hash_defined
11245       && stub_entry->h->elf.root.u.def.section == htab->sfpr)
11246     {
11247       /* Don't make stubs to out-of-line register save/restore
11248          functions.  Instead, emit copies of the functions.  */
11249       stub_entry->group->needs_save_res = 1;
11250       stub_entry->stub_type = ppc_stub_save_res;
11251       return TRUE;
11252     }
11253
11254   if (stub_entry->stub_type == ppc_stub_plt_call
11255       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11256     {
11257       asection *plt;
11258       off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
11259       if (off >= (bfd_vma) -2)
11260         abort ();
11261       plt = htab->elf.splt;
11262       if (!htab->elf.dynamic_sections_created
11263           || stub_entry->h == NULL
11264           || stub_entry->h->elf.dynindx == -1)
11265         plt = htab->elf.iplt;
11266       off += (plt->output_offset
11267               + plt->output_section->vma
11268               - elf_gp (plt->output_section->owner)
11269               - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11270
11271       size = plt_stub_size (htab, stub_entry, off);
11272       if (htab->params->plt_stub_align)
11273         size += plt_stub_pad (htab, stub_entry, off);
11274       if (info->emitrelocations)
11275         {
11276           stub_entry->group->stub_sec->reloc_count
11277             += ((PPC_HA (off) != 0)
11278                 + (htab->opd_abi
11279                    ? 2 + (htab->params->plt_static_chain
11280                           && PPC_HA (off + 16) == PPC_HA (off))
11281                    : 1));
11282           stub_entry->group->stub_sec->flags |= SEC_RELOC;
11283         }
11284     }
11285   else
11286     {
11287       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
11288          variants.  */
11289       bfd_vma r2off = 0;
11290       bfd_vma local_off = 0;
11291
11292       off = (stub_entry->target_value
11293              + stub_entry->target_section->output_offset
11294              + stub_entry->target_section->output_section->vma);
11295       off -= (stub_entry->group->stub_sec->size
11296               + stub_entry->group->stub_sec->output_offset
11297               + stub_entry->group->stub_sec->output_section->vma);
11298
11299       /* Reset the stub type from the plt variant in case we now
11300          can reach with a shorter stub.  */
11301       if (stub_entry->stub_type >= ppc_stub_plt_branch)
11302         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
11303
11304       size = 4;
11305       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11306         {
11307           r2off = get_r2off (info, stub_entry);
11308           if (r2off == (bfd_vma) -1)
11309             {
11310               htab->stub_error = TRUE;
11311               return FALSE;
11312             }
11313           size = 8;
11314           if (PPC_HA (r2off) != 0)
11315             size += 4;
11316           if (PPC_LO (r2off) != 0)
11317             size += 4;
11318           off -= size - 4;
11319         }
11320
11321       local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11322
11323       /* If the branch offset if too big, use a ppc_stub_plt_branch.
11324          Do the same for -R objects without function descriptors.  */
11325       if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
11326           || (stub_entry->stub_type == ppc_stub_long_branch_r2off
11327               && r2off == 0
11328               && htab->sec_info[stub_entry->target_section->id].toc_off == 0))
11329         {
11330           struct ppc_branch_hash_entry *br_entry;
11331
11332           br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11333                                              stub_entry->root.string + 9,
11334                                              TRUE, FALSE);
11335           if (br_entry == NULL)
11336             {
11337               info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
11338                                       stub_entry->root.string);
11339               htab->stub_error = TRUE;
11340               return FALSE;
11341             }
11342
11343           if (br_entry->iter != htab->stub_iteration)
11344             {
11345               br_entry->iter = htab->stub_iteration;
11346               br_entry->offset = htab->brlt->size;
11347               htab->brlt->size += 8;
11348
11349               if (htab->relbrlt != NULL)
11350                 htab->relbrlt->size += sizeof (Elf64_External_Rela);
11351               else if (info->emitrelocations)
11352                 {
11353                   htab->brlt->reloc_count += 1;
11354                   htab->brlt->flags |= SEC_RELOC;
11355                 }
11356             }
11357
11358           stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
11359           off = (br_entry->offset
11360                  + htab->brlt->output_offset
11361                  + htab->brlt->output_section->vma
11362                  - elf_gp (htab->brlt->output_section->owner)
11363                  - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11364
11365           if (info->emitrelocations)
11366             {
11367               stub_entry->group->stub_sec->reloc_count
11368                 += 1 + (PPC_HA (off) != 0);
11369               stub_entry->group->stub_sec->flags |= SEC_RELOC;
11370             }
11371
11372           if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11373             {
11374               size = 12;
11375               if (PPC_HA (off) != 0)
11376                 size = 16;
11377             }
11378           else
11379             {
11380               size = 16;
11381               if (PPC_HA (off) != 0)
11382                 size += 4;
11383
11384               if (PPC_HA (r2off) != 0)
11385                 size += 4;
11386               if (PPC_LO (r2off) != 0)
11387                 size += 4;
11388             }
11389         }
11390       else if (info->emitrelocations)
11391         {
11392           stub_entry->group->stub_sec->reloc_count += 1;
11393           stub_entry->group->stub_sec->flags |= SEC_RELOC;
11394         }
11395     }
11396
11397   stub_entry->group->stub_sec->size += size;
11398   return TRUE;
11399 }
11400
11401 /* Set up various things so that we can make a list of input sections
11402    for each output section included in the link.  Returns -1 on error,
11403    0 when no stubs will be needed, and 1 on success.  */
11404
11405 int
11406 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
11407 {
11408   unsigned int id;
11409   bfd_size_type amt;
11410   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11411
11412   if (htab == NULL)
11413     return -1;
11414
11415   htab->sec_info_arr_size = bfd_get_next_section_id ();
11416   amt = sizeof (*htab->sec_info) * (htab->sec_info_arr_size);
11417   htab->sec_info = bfd_zmalloc (amt);
11418   if (htab->sec_info == NULL)
11419     return -1;
11420
11421   /* Set toc_off for com, und, abs and ind sections.  */
11422   for (id = 0; id < 3; id++)
11423     htab->sec_info[id].toc_off = TOC_BASE_OFF;
11424
11425   return 1;
11426 }
11427
11428 /* Set up for first pass at multitoc partitioning.  */
11429
11430 void
11431 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11432 {
11433   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11434
11435   htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11436   htab->toc_bfd = NULL;
11437   htab->toc_first_sec = NULL;
11438 }
11439
11440 /* The linker repeatedly calls this function for each TOC input section
11441    and linker generated GOT section.  Group input bfds such that the toc
11442    within a group is less than 64k in size.  */
11443
11444 bfd_boolean
11445 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11446 {
11447   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11448   bfd_vma addr, off, limit;
11449
11450   if (htab == NULL)
11451     return FALSE;
11452
11453   if (!htab->second_toc_pass)
11454     {
11455       /* Keep track of the first .toc or .got section for this input bfd.  */
11456       bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11457
11458       if (new_bfd)
11459         {
11460           htab->toc_bfd = isec->owner;
11461           htab->toc_first_sec = isec;
11462         }
11463
11464       addr = isec->output_offset + isec->output_section->vma;
11465       off = addr - htab->toc_curr;
11466       limit = 0x80008000;
11467       if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11468         limit = 0x10000;
11469       if (off + isec->size > limit)
11470         {
11471           addr = (htab->toc_first_sec->output_offset
11472                   + htab->toc_first_sec->output_section->vma);
11473           htab->toc_curr = addr;
11474           htab->toc_curr &= -TOC_BASE_ALIGN;
11475         }
11476
11477       /* toc_curr is the base address of this toc group.  Set elf_gp
11478          for the input section to be the offset relative to the
11479          output toc base plus 0x8000.  Making the input elf_gp an
11480          offset allows us to move the toc as a whole without
11481          recalculating input elf_gp.  */
11482       off = htab->toc_curr - elf_gp (isec->output_section->owner);
11483       off += TOC_BASE_OFF;
11484
11485       /* Die if someone uses a linker script that doesn't keep input
11486          file .toc and .got together.  */
11487       if (new_bfd
11488           && elf_gp (isec->owner) != 0
11489           && elf_gp (isec->owner) != off)
11490         return FALSE;
11491
11492       elf_gp (isec->owner) = off;
11493       return TRUE;
11494     }
11495
11496   /* During the second pass toc_first_sec points to the start of
11497      a toc group, and toc_curr is used to track the old elf_gp.
11498      We use toc_bfd to ensure we only look at each bfd once.  */
11499   if (htab->toc_bfd == isec->owner)
11500     return TRUE;
11501   htab->toc_bfd = isec->owner;
11502
11503   if (htab->toc_first_sec == NULL
11504       || htab->toc_curr != elf_gp (isec->owner))
11505     {
11506       htab->toc_curr = elf_gp (isec->owner);
11507       htab->toc_first_sec = isec;
11508     }
11509   addr = (htab->toc_first_sec->output_offset
11510           + htab->toc_first_sec->output_section->vma);
11511   off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
11512   elf_gp (isec->owner) = off;
11513
11514   return TRUE;
11515 }
11516
11517 /* Called via elf_link_hash_traverse to merge GOT entries for global
11518    symbol H.  */
11519
11520 static bfd_boolean
11521 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11522 {
11523   if (h->root.type == bfd_link_hash_indirect)
11524     return TRUE;
11525
11526   merge_got_entries (&h->got.glist);
11527
11528   return TRUE;
11529 }
11530
11531 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11532    symbol H.  */
11533
11534 static bfd_boolean
11535 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11536 {
11537   struct got_entry *gent;
11538
11539   if (h->root.type == bfd_link_hash_indirect)
11540     return TRUE;
11541
11542   for (gent = h->got.glist; gent != NULL; gent = gent->next)
11543     if (!gent->is_indirect)
11544       allocate_got (h, (struct bfd_link_info *) inf, gent);
11545   return TRUE;
11546 }
11547
11548 /* Called on the first multitoc pass after the last call to
11549    ppc64_elf_next_toc_section.  This function removes duplicate GOT
11550    entries.  */
11551
11552 bfd_boolean
11553 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11554 {
11555   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11556   struct bfd *ibfd, *ibfd2;
11557   bfd_boolean done_something;
11558
11559   htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11560
11561   if (!htab->do_multi_toc)
11562     return FALSE;
11563
11564   /* Merge global sym got entries within a toc group.  */
11565   elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11566
11567   /* And tlsld_got.  */
11568   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11569     {
11570       struct got_entry *ent, *ent2;
11571
11572       if (!is_ppc64_elf (ibfd))
11573         continue;
11574
11575       ent = ppc64_tlsld_got (ibfd);
11576       if (!ent->is_indirect
11577           && ent->got.offset != (bfd_vma) -1)
11578         {
11579           for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
11580             {
11581               if (!is_ppc64_elf (ibfd2))
11582                 continue;
11583
11584               ent2 = ppc64_tlsld_got (ibfd2);
11585               if (!ent2->is_indirect
11586                   && ent2->got.offset != (bfd_vma) -1
11587                   && elf_gp (ibfd2) == elf_gp (ibfd))
11588                 {
11589                   ent2->is_indirect = TRUE;
11590                   ent2->got.ent = ent;
11591                 }
11592             }
11593         }
11594     }
11595
11596   /* Zap sizes of got sections.  */
11597   htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11598   htab->elf.irelplt->size -= htab->got_reli_size;
11599   htab->got_reli_size = 0;
11600
11601   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11602     {
11603       asection *got, *relgot;
11604
11605       if (!is_ppc64_elf (ibfd))
11606         continue;
11607
11608       got = ppc64_elf_tdata (ibfd)->got;
11609       if (got != NULL)
11610         {
11611           got->rawsize = got->size;
11612           got->size = 0;
11613           relgot = ppc64_elf_tdata (ibfd)->relgot;
11614           relgot->rawsize = relgot->size;
11615           relgot->size = 0;
11616         }
11617     }
11618
11619   /* Now reallocate the got, local syms first.  We don't need to
11620      allocate section contents again since we never increase size.  */
11621   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11622     {
11623       struct got_entry **lgot_ents;
11624       struct got_entry **end_lgot_ents;
11625       struct plt_entry **local_plt;
11626       struct plt_entry **end_local_plt;
11627       unsigned char *lgot_masks;
11628       bfd_size_type locsymcount;
11629       Elf_Internal_Shdr *symtab_hdr;
11630       asection *s;
11631
11632       if (!is_ppc64_elf (ibfd))
11633         continue;
11634
11635       lgot_ents = elf_local_got_ents (ibfd);
11636       if (!lgot_ents)
11637         continue;
11638
11639       symtab_hdr = &elf_symtab_hdr (ibfd);
11640       locsymcount = symtab_hdr->sh_info;
11641       end_lgot_ents = lgot_ents + locsymcount;
11642       local_plt = (struct plt_entry **) end_lgot_ents;
11643       end_local_plt = local_plt + locsymcount;
11644       lgot_masks = (unsigned char *) end_local_plt;
11645       s = ppc64_elf_tdata (ibfd)->got;
11646       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11647         {
11648           struct got_entry *ent;
11649
11650           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11651             {
11652               unsigned int ent_size = 8;
11653               unsigned int rel_size = sizeof (Elf64_External_Rela);
11654
11655               ent->got.offset = s->size;
11656               if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11657                 {
11658                   ent_size *= 2;
11659                   rel_size *= 2;
11660                 }
11661               s->size += ent_size;
11662               if ((*lgot_masks & PLT_IFUNC) != 0)
11663                 {
11664                   htab->elf.irelplt->size += rel_size;
11665                   htab->got_reli_size += rel_size;
11666                 }
11667               else if (bfd_link_pic (info))
11668                 {
11669                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11670                   srel->size += rel_size;
11671                 }
11672             }
11673         }
11674     }
11675
11676   elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11677
11678   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11679     {
11680       struct got_entry *ent;
11681
11682       if (!is_ppc64_elf (ibfd))
11683         continue;
11684
11685       ent = ppc64_tlsld_got (ibfd);
11686       if (!ent->is_indirect
11687           && ent->got.offset != (bfd_vma) -1)
11688         {
11689           asection *s = ppc64_elf_tdata (ibfd)->got;
11690           ent->got.offset = s->size;
11691           s->size += 16;
11692           if (bfd_link_pic (info))
11693             {
11694               asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11695               srel->size += sizeof (Elf64_External_Rela);
11696             }
11697         }
11698     }
11699
11700   done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11701   if (!done_something)
11702     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11703       {
11704         asection *got;
11705
11706         if (!is_ppc64_elf (ibfd))
11707           continue;
11708
11709         got = ppc64_elf_tdata (ibfd)->got;
11710         if (got != NULL)
11711           {
11712             done_something = got->rawsize != got->size;
11713             if (done_something)
11714               break;
11715           }
11716       }
11717
11718   if (done_something)
11719     (*htab->params->layout_sections_again) ();
11720
11721   /* Set up for second pass over toc sections to recalculate elf_gp
11722      on input sections.  */
11723   htab->toc_bfd = NULL;
11724   htab->toc_first_sec = NULL;
11725   htab->second_toc_pass = TRUE;
11726   return done_something;
11727 }
11728
11729 /* Called after second pass of multitoc partitioning.  */
11730
11731 void
11732 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11733 {
11734   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11735
11736   /* After the second pass, toc_curr tracks the TOC offset used
11737      for code sections below in ppc64_elf_next_input_section.  */
11738   htab->toc_curr = TOC_BASE_OFF;
11739 }
11740
11741 /* No toc references were found in ISEC.  If the code in ISEC makes no
11742    calls, then there's no need to use toc adjusting stubs when branching
11743    into ISEC.  Actually, indirect calls from ISEC are OK as they will
11744    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
11745    needed, and 2 if a cyclical call-graph was found but no other reason
11746    for a stub was detected.  If called from the top level, a return of
11747    2 means the same as a return of 0.  */
11748
11749 static int
11750 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11751 {
11752   int ret;
11753
11754   /* Mark this section as checked.  */
11755   isec->call_check_done = 1;
11756
11757   /* We know none of our code bearing sections will need toc stubs.  */
11758   if ((isec->flags & SEC_LINKER_CREATED) != 0)
11759     return 0;
11760
11761   if (isec->size == 0)
11762     return 0;
11763
11764   if (isec->output_section == NULL)
11765     return 0;
11766
11767   ret = 0;
11768   if (isec->reloc_count != 0)
11769     {
11770       Elf_Internal_Rela *relstart, *rel;
11771       Elf_Internal_Sym *local_syms;
11772       struct ppc_link_hash_table *htab;
11773
11774       relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11775                                             info->keep_memory);
11776       if (relstart == NULL)
11777         return -1;
11778
11779       /* Look for branches to outside of this section.  */
11780       local_syms = NULL;
11781       htab = ppc_hash_table (info);
11782       if (htab == NULL)
11783         return -1;
11784
11785       for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11786         {
11787           enum elf_ppc64_reloc_type r_type;
11788           unsigned long r_symndx;
11789           struct elf_link_hash_entry *h;
11790           struct ppc_link_hash_entry *eh;
11791           Elf_Internal_Sym *sym;
11792           asection *sym_sec;
11793           struct _opd_sec_data *opd;
11794           bfd_vma sym_value;
11795           bfd_vma dest;
11796
11797           r_type = ELF64_R_TYPE (rel->r_info);
11798           if (r_type != R_PPC64_REL24
11799               && r_type != R_PPC64_REL14
11800               && r_type != R_PPC64_REL14_BRTAKEN
11801               && r_type != R_PPC64_REL14_BRNTAKEN)
11802             continue;
11803
11804           r_symndx = ELF64_R_SYM (rel->r_info);
11805           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11806                           isec->owner))
11807             {
11808               ret = -1;
11809               break;
11810             }
11811
11812           /* Calls to dynamic lib functions go through a plt call stub
11813              that uses r2.  */
11814           eh = (struct ppc_link_hash_entry *) h;
11815           if (eh != NULL
11816               && (eh->elf.plt.plist != NULL
11817                   || (eh->oh != NULL
11818                       && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11819             {
11820               ret = 1;
11821               break;
11822             }
11823
11824           if (sym_sec == NULL)
11825             /* Ignore other undefined symbols.  */
11826             continue;
11827
11828           /* Assume branches to other sections not included in the
11829              link need stubs too, to cover -R and absolute syms.  */
11830           if (sym_sec->output_section == NULL)
11831             {
11832               ret = 1;
11833               break;
11834             }
11835
11836           if (h == NULL)
11837             sym_value = sym->st_value;
11838           else
11839             {
11840               if (h->root.type != bfd_link_hash_defined
11841                   && h->root.type != bfd_link_hash_defweak)
11842                 abort ();
11843               sym_value = h->root.u.def.value;
11844             }
11845           sym_value += rel->r_addend;
11846
11847           /* If this branch reloc uses an opd sym, find the code section.  */
11848           opd = get_opd_info (sym_sec);
11849           if (opd != NULL)
11850             {
11851               if (h == NULL && opd->adjust != NULL)
11852                 {
11853                   long adjust;
11854
11855                   adjust = opd->adjust[OPD_NDX (sym_value)];
11856                   if (adjust == -1)
11857                     /* Assume deleted functions won't ever be called.  */
11858                     continue;
11859                   sym_value += adjust;
11860                 }
11861
11862               dest = opd_entry_value (sym_sec, sym_value,
11863                                       &sym_sec, NULL, FALSE);
11864               if (dest == (bfd_vma) -1)
11865                 continue;
11866             }
11867           else
11868             dest = (sym_value
11869                     + sym_sec->output_offset
11870                     + sym_sec->output_section->vma);
11871
11872           /* Ignore branch to self.  */
11873           if (sym_sec == isec)
11874             continue;
11875
11876           /* If the called function uses the toc, we need a stub.  */
11877           if (sym_sec->has_toc_reloc
11878               || sym_sec->makes_toc_func_call)
11879             {
11880               ret = 1;
11881               break;
11882             }
11883
11884           /* Assume any branch that needs a long branch stub might in fact
11885              need a plt_branch stub.  A plt_branch stub uses r2.  */
11886           else if (dest - (isec->output_offset
11887                            + isec->output_section->vma
11888                            + rel->r_offset) + (1 << 25)
11889                    >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
11890                                                              ? h->other
11891                                                              : sym->st_other))
11892             {
11893               ret = 1;
11894               break;
11895             }
11896
11897           /* If calling back to a section in the process of being
11898              tested, we can't say for sure that no toc adjusting stubs
11899              are needed, so don't return zero.  */
11900           else if (sym_sec->call_check_in_progress)
11901             ret = 2;
11902
11903           /* Branches to another section that itself doesn't have any TOC
11904              references are OK.  Recursively call ourselves to check.  */
11905           else if (!sym_sec->call_check_done)
11906             {
11907               int recur;
11908
11909               /* Mark current section as indeterminate, so that other
11910                  sections that call back to current won't be marked as
11911                  known.  */
11912               isec->call_check_in_progress = 1;
11913               recur = toc_adjusting_stub_needed (info, sym_sec);
11914               isec->call_check_in_progress = 0;
11915
11916               if (recur != 0)
11917                 {
11918                   ret = recur;
11919                   if (recur != 2)
11920                     break;
11921                 }
11922             }
11923         }
11924
11925       if (local_syms != NULL
11926           && (elf_symtab_hdr (isec->owner).contents
11927               != (unsigned char *) local_syms))
11928         free (local_syms);
11929       if (elf_section_data (isec)->relocs != relstart)
11930         free (relstart);
11931     }
11932
11933   if ((ret & 1) == 0
11934       && isec->map_head.s != NULL
11935       && (strcmp (isec->output_section->name, ".init") == 0
11936           || strcmp (isec->output_section->name, ".fini") == 0))
11937     {
11938       if (isec->map_head.s->has_toc_reloc
11939           || isec->map_head.s->makes_toc_func_call)
11940         ret = 1;
11941       else if (!isec->map_head.s->call_check_done)
11942         {
11943           int recur;
11944           isec->call_check_in_progress = 1;
11945           recur = toc_adjusting_stub_needed (info, isec->map_head.s);
11946           isec->call_check_in_progress = 0;
11947           if (recur != 0)
11948             ret = recur;
11949         }
11950     }
11951
11952   if (ret == 1)
11953     isec->makes_toc_func_call = 1;
11954
11955   return ret;
11956 }
11957
11958 /* The linker repeatedly calls this function for each input section,
11959    in the order that input sections are linked into output sections.
11960    Build lists of input sections to determine groupings between which
11961    we may insert linker stubs.  */
11962
11963 bfd_boolean
11964 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
11965 {
11966   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11967
11968   if (htab == NULL)
11969     return FALSE;
11970
11971   if ((isec->output_section->flags & SEC_CODE) != 0
11972       && isec->output_section->id < htab->sec_info_arr_size)
11973     {
11974       /* This happens to make the list in reverse order,
11975          which is what we want.  */
11976       htab->sec_info[isec->id].u.list
11977         = htab->sec_info[isec->output_section->id].u.list;
11978       htab->sec_info[isec->output_section->id].u.list = isec;
11979     }
11980
11981   if (htab->multi_toc_needed)
11982     {
11983       /* Analyse sections that aren't already flagged as needing a
11984          valid toc pointer.  Exclude .fixup for the linux kernel.
11985          .fixup contains branches, but only back to the function that
11986          hit an exception.  */
11987       if (!(isec->has_toc_reloc
11988             || (isec->flags & SEC_CODE) == 0
11989             || strcmp (isec->name, ".fixup") == 0
11990             || isec->call_check_done))
11991         {
11992           if (toc_adjusting_stub_needed (info, isec) < 0)
11993             return FALSE;
11994         }
11995       /* Make all sections use the TOC assigned for this object file.
11996          This will be wrong for pasted sections;  We fix that in
11997          check_pasted_section().  */
11998       if (elf_gp (isec->owner) != 0)
11999         htab->toc_curr = elf_gp (isec->owner);
12000     }
12001
12002   htab->sec_info[isec->id].toc_off = htab->toc_curr;
12003   return TRUE;
12004 }
12005
12006 /* Check that all .init and .fini sections use the same toc, if they
12007    have toc relocs.  */
12008
12009 static bfd_boolean
12010 check_pasted_section (struct bfd_link_info *info, const char *name)
12011 {
12012   asection *o = bfd_get_section_by_name (info->output_bfd, name);
12013
12014   if (o != NULL)
12015     {
12016       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12017       bfd_vma toc_off = 0;
12018       asection *i;
12019
12020       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12021         if (i->has_toc_reloc)
12022           {
12023             if (toc_off == 0)
12024               toc_off = htab->sec_info[i->id].toc_off;
12025             else if (toc_off != htab->sec_info[i->id].toc_off)
12026               return FALSE;
12027           }
12028
12029       if (toc_off == 0)
12030         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12031           if (i->makes_toc_func_call)
12032             {
12033               toc_off = htab->sec_info[i->id].toc_off;
12034               break;
12035             }
12036
12037       /* Make sure the whole pasted function uses the same toc offset.  */
12038       if (toc_off != 0)
12039         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12040           htab->sec_info[i->id].toc_off = toc_off;
12041     }
12042   return TRUE;
12043 }
12044
12045 bfd_boolean
12046 ppc64_elf_check_init_fini (struct bfd_link_info *info)
12047 {
12048   return (check_pasted_section (info, ".init")
12049           & check_pasted_section (info, ".fini"));
12050 }
12051
12052 /* See whether we can group stub sections together.  Grouping stub
12053    sections may result in fewer stubs.  More importantly, we need to
12054    put all .init* and .fini* stubs at the beginning of the .init or
12055    .fini output sections respectively, because glibc splits the
12056    _init and _fini functions into multiple parts.  Putting a stub in
12057    the middle of a function is not a good idea.  */
12058
12059 static bfd_boolean
12060 group_sections (struct bfd_link_info *info,
12061                 bfd_size_type stub_group_size,
12062                 bfd_boolean stubs_always_before_branch)
12063 {
12064   struct ppc_link_hash_table *htab;
12065   asection *osec;
12066   bfd_boolean suppress_size_errors;
12067
12068   htab = ppc_hash_table (info);
12069   if (htab == NULL)
12070     return FALSE;
12071
12072   suppress_size_errors = FALSE;
12073   if (stub_group_size == 1)
12074     {
12075       /* Default values.  */
12076       if (stubs_always_before_branch)
12077         stub_group_size = 0x1e00000;
12078       else
12079         stub_group_size = 0x1c00000;
12080       suppress_size_errors = TRUE;
12081     }
12082
12083   for (osec = info->output_bfd->sections; osec != NULL; osec = osec->next)
12084     {
12085       asection *tail;
12086
12087       if (osec->id >= htab->sec_info_arr_size)
12088         continue;
12089
12090       tail = htab->sec_info[osec->id].u.list;
12091       while (tail != NULL)
12092         {
12093           asection *curr;
12094           asection *prev;
12095           bfd_size_type total;
12096           bfd_boolean big_sec;
12097           bfd_vma curr_toc;
12098           struct map_stub *group;
12099           bfd_size_type group_size;
12100
12101           curr = tail;
12102           total = tail->size;
12103           group_size = (ppc64_elf_section_data (tail) != NULL
12104                         && ppc64_elf_section_data (tail)->has_14bit_branch
12105                         ? stub_group_size >> 10 : stub_group_size);
12106
12107           big_sec = total > group_size;
12108           if (big_sec && !suppress_size_errors)
12109             _bfd_error_handler (_("%B section %A exceeds stub group size"),
12110                                 tail->owner, tail);
12111           curr_toc = htab->sec_info[tail->id].toc_off;
12112
12113           while ((prev = htab->sec_info[curr->id].u.list) != NULL
12114                  && ((total += curr->output_offset - prev->output_offset)
12115                      < (ppc64_elf_section_data (prev) != NULL
12116                         && ppc64_elf_section_data (prev)->has_14bit_branch
12117                         ? (group_size = stub_group_size >> 10) : group_size))
12118                  && htab->sec_info[prev->id].toc_off == curr_toc)
12119             curr = prev;
12120
12121           /* OK, the size from the start of CURR to the end is less
12122              than group_size and thus can be handled by one stub
12123              section.  (or the tail section is itself larger than
12124              group_size, in which case we may be toast.)  We should
12125              really be keeping track of the total size of stubs added
12126              here, as stubs contribute to the final output section
12127              size.  That's a little tricky, and this way will only
12128              break if stubs added make the total size more than 2^25,
12129              ie. for the default stub_group_size, if stubs total more
12130              than 2097152 bytes, or nearly 75000 plt call stubs.  */
12131           group = bfd_alloc (curr->owner, sizeof (*group));
12132           if (group == NULL)
12133             return FALSE;
12134           group->link_sec = curr;
12135           group->stub_sec = NULL;
12136           group->needs_save_res = 0;
12137           group->next = htab->group;
12138           htab->group = group;
12139           do
12140             {
12141               prev = htab->sec_info[tail->id].u.list;
12142               /* Set up this stub group.  */
12143               htab->sec_info[tail->id].u.group = group;
12144             }
12145           while (tail != curr && (tail = prev) != NULL);
12146
12147           /* But wait, there's more!  Input sections up to group_size
12148              bytes before the stub section can be handled by it too.
12149              Don't do this if we have a really large section after the
12150              stubs, as adding more stubs increases the chance that
12151              branches may not reach into the stub section.  */
12152           if (!stubs_always_before_branch && !big_sec)
12153             {
12154               total = 0;
12155               while (prev != NULL
12156                      && ((total += tail->output_offset - prev->output_offset)
12157                          < (ppc64_elf_section_data (prev) != NULL
12158                             && ppc64_elf_section_data (prev)->has_14bit_branch
12159                             ? (group_size = stub_group_size >> 10) : group_size))
12160                      && htab->sec_info[prev->id].toc_off == curr_toc)
12161                 {
12162                   tail = prev;
12163                   prev = htab->sec_info[tail->id].u.list;
12164                   htab->sec_info[tail->id].u.group = group;
12165                 }
12166             }
12167           tail = prev;
12168         }
12169     }
12170   return TRUE;
12171 }
12172
12173 static const unsigned char glink_eh_frame_cie[] =
12174 {
12175   0, 0, 0, 16,                          /* length.  */
12176   0, 0, 0, 0,                           /* id.  */
12177   1,                                    /* CIE version.  */
12178   'z', 'R', 0,                          /* Augmentation string.  */
12179   4,                                    /* Code alignment.  */
12180   0x78,                                 /* Data alignment.  */
12181   65,                                   /* RA reg.  */
12182   1,                                    /* Augmentation size.  */
12183   DW_EH_PE_pcrel | DW_EH_PE_sdata4,     /* FDE encoding.  */
12184   DW_CFA_def_cfa, 1, 0,                 /* def_cfa: r1 offset 0.  */
12185   0, 0, 0, 0
12186 };
12187
12188 /* Stripping output sections is normally done before dynamic section
12189    symbols have been allocated.  This function is called later, and
12190    handles cases like htab->brlt which is mapped to its own output
12191    section.  */
12192
12193 static void
12194 maybe_strip_output (struct bfd_link_info *info, asection *isec)
12195 {
12196   if (isec->size == 0
12197       && isec->output_section->size == 0
12198       && !(isec->output_section->flags & SEC_KEEP)
12199       && !bfd_section_removed_from_list (info->output_bfd,
12200                                          isec->output_section)
12201       && elf_section_data (isec->output_section)->dynindx == 0)
12202     {
12203       isec->output_section->flags |= SEC_EXCLUDE;
12204       bfd_section_list_remove (info->output_bfd, isec->output_section);
12205       info->output_bfd->section_count--;
12206     }
12207 }
12208
12209 /* Determine and set the size of the stub section for a final link.
12210
12211    The basic idea here is to examine all the relocations looking for
12212    PC-relative calls to a target that is unreachable with a "bl"
12213    instruction.  */
12214
12215 bfd_boolean
12216 ppc64_elf_size_stubs (struct bfd_link_info *info)
12217 {
12218   bfd_size_type stub_group_size;
12219   bfd_boolean stubs_always_before_branch;
12220   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12221
12222   if (htab == NULL)
12223     return FALSE;
12224
12225   if (htab->params->plt_thread_safe == -1 && !bfd_link_executable (info))
12226     htab->params->plt_thread_safe = 1;
12227   if (!htab->opd_abi)
12228     htab->params->plt_thread_safe = 0;
12229   else if (htab->params->plt_thread_safe == -1)
12230     {
12231       static const char *const thread_starter[] =
12232         {
12233           "pthread_create",
12234           /* libstdc++ */
12235           "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
12236           /* librt */
12237           "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
12238           "mq_notify", "create_timer",
12239           /* libanl */
12240           "getaddrinfo_a",
12241           /* libgomp */
12242           "GOMP_parallel",
12243           "GOMP_parallel_start",
12244           "GOMP_parallel_loop_static",
12245           "GOMP_parallel_loop_static_start",
12246           "GOMP_parallel_loop_dynamic",
12247           "GOMP_parallel_loop_dynamic_start",
12248           "GOMP_parallel_loop_guided",
12249           "GOMP_parallel_loop_guided_start",
12250           "GOMP_parallel_loop_runtime",
12251           "GOMP_parallel_loop_runtime_start",
12252           "GOMP_parallel_sections",
12253           "GOMP_parallel_sections_start",
12254           /* libgo */
12255           "__go_go",
12256         };
12257       unsigned i;
12258
12259       for (i = 0; i < ARRAY_SIZE (thread_starter); i++)
12260         {
12261           struct elf_link_hash_entry *h;
12262           h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
12263                                     FALSE, FALSE, TRUE);
12264           htab->params->plt_thread_safe = h != NULL && h->ref_regular;
12265           if (htab->params->plt_thread_safe)
12266             break;
12267         }
12268     }
12269   stubs_always_before_branch = htab->params->group_size < 0;
12270   if (htab->params->group_size < 0)
12271     stub_group_size = -htab->params->group_size;
12272   else
12273     stub_group_size = htab->params->group_size;
12274
12275   if (!group_sections (info, stub_group_size, stubs_always_before_branch))
12276     return FALSE;
12277
12278 #define STUB_SHRINK_ITER 20
12279   /* Loop until no stubs added.  After iteration 20 of this loop we may
12280      exit on a stub section shrinking.  This is to break out of a
12281      pathological case where adding stubs on one iteration decreases
12282      section gaps (perhaps due to alignment), which then requires
12283      fewer or smaller stubs on the next iteration.  */
12284
12285   while (1)
12286     {
12287       bfd *input_bfd;
12288       unsigned int bfd_indx;
12289       struct map_stub *group;
12290       asection *stub_sec;
12291
12292       htab->stub_iteration += 1;
12293
12294       for (input_bfd = info->input_bfds, bfd_indx = 0;
12295            input_bfd != NULL;
12296            input_bfd = input_bfd->link.next, bfd_indx++)
12297         {
12298           Elf_Internal_Shdr *symtab_hdr;
12299           asection *section;
12300           Elf_Internal_Sym *local_syms = NULL;
12301
12302           if (!is_ppc64_elf (input_bfd))
12303             continue;
12304
12305           /* We'll need the symbol table in a second.  */
12306           symtab_hdr = &elf_symtab_hdr (input_bfd);
12307           if (symtab_hdr->sh_info == 0)
12308             continue;
12309
12310           /* Walk over each section attached to the input bfd.  */
12311           for (section = input_bfd->sections;
12312                section != NULL;
12313                section = section->next)
12314             {
12315               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
12316
12317               /* If there aren't any relocs, then there's nothing more
12318                  to do.  */
12319               if ((section->flags & SEC_RELOC) == 0
12320                   || (section->flags & SEC_ALLOC) == 0
12321                   || (section->flags & SEC_LOAD) == 0
12322                   || (section->flags & SEC_CODE) == 0
12323                   || section->reloc_count == 0)
12324                 continue;
12325
12326               /* If this section is a link-once section that will be
12327                  discarded, then don't create any stubs.  */
12328               if (section->output_section == NULL
12329                   || section->output_section->owner != info->output_bfd)
12330                 continue;
12331
12332               /* Get the relocs.  */
12333               internal_relocs
12334                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
12335                                              info->keep_memory);
12336               if (internal_relocs == NULL)
12337                 goto error_ret_free_local;
12338
12339               /* Now examine each relocation.  */
12340               irela = internal_relocs;
12341               irelaend = irela + section->reloc_count;
12342               for (; irela < irelaend; irela++)
12343                 {
12344                   enum elf_ppc64_reloc_type r_type;
12345                   unsigned int r_indx;
12346                   enum ppc_stub_type stub_type;
12347                   struct ppc_stub_hash_entry *stub_entry;
12348                   asection *sym_sec, *code_sec;
12349                   bfd_vma sym_value, code_value;
12350                   bfd_vma destination;
12351                   unsigned long local_off;
12352                   bfd_boolean ok_dest;
12353                   struct ppc_link_hash_entry *hash;
12354                   struct ppc_link_hash_entry *fdh;
12355                   struct elf_link_hash_entry *h;
12356                   Elf_Internal_Sym *sym;
12357                   char *stub_name;
12358                   const asection *id_sec;
12359                   struct _opd_sec_data *opd;
12360                   struct plt_entry *plt_ent;
12361
12362                   r_type = ELF64_R_TYPE (irela->r_info);
12363                   r_indx = ELF64_R_SYM (irela->r_info);
12364
12365                   if (r_type >= R_PPC64_max)
12366                     {
12367                       bfd_set_error (bfd_error_bad_value);
12368                       goto error_ret_free_internal;
12369                     }
12370
12371                   /* Only look for stubs on branch instructions.  */
12372                   if (r_type != R_PPC64_REL24
12373                       && r_type != R_PPC64_REL14
12374                       && r_type != R_PPC64_REL14_BRTAKEN
12375                       && r_type != R_PPC64_REL14_BRNTAKEN)
12376                     continue;
12377
12378                   /* Now determine the call target, its name, value,
12379                      section.  */
12380                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12381                                   r_indx, input_bfd))
12382                     goto error_ret_free_internal;
12383                   hash = (struct ppc_link_hash_entry *) h;
12384
12385                   ok_dest = FALSE;
12386                   fdh = NULL;
12387                   sym_value = 0;
12388                   if (hash == NULL)
12389                     {
12390                       sym_value = sym->st_value;
12391                       if (sym_sec != NULL
12392                           && sym_sec->output_section != NULL)
12393                         ok_dest = TRUE;
12394                     }
12395                   else if (hash->elf.root.type == bfd_link_hash_defined
12396                            || hash->elf.root.type == bfd_link_hash_defweak)
12397                     {
12398                       sym_value = hash->elf.root.u.def.value;
12399                       if (sym_sec->output_section != NULL)
12400                         ok_dest = TRUE;
12401                     }
12402                   else if (hash->elf.root.type == bfd_link_hash_undefweak
12403                            || hash->elf.root.type == bfd_link_hash_undefined)
12404                     {
12405                       /* Recognise an old ABI func code entry sym, and
12406                          use the func descriptor sym instead if it is
12407                          defined.  */
12408                       if (hash->elf.root.root.string[0] == '.'
12409                           && (fdh = lookup_fdh (hash, htab)) != NULL)
12410                         {
12411                           if (fdh->elf.root.type == bfd_link_hash_defined
12412                               || fdh->elf.root.type == bfd_link_hash_defweak)
12413                             {
12414                               sym_sec = fdh->elf.root.u.def.section;
12415                               sym_value = fdh->elf.root.u.def.value;
12416                               if (sym_sec->output_section != NULL)
12417                                 ok_dest = TRUE;
12418                             }
12419                           else
12420                             fdh = NULL;
12421                         }
12422                     }
12423                   else
12424                     {
12425                       bfd_set_error (bfd_error_bad_value);
12426                       goto error_ret_free_internal;
12427                     }
12428
12429                   destination = 0;
12430                   local_off = 0;
12431                   if (ok_dest)
12432                     {
12433                       sym_value += irela->r_addend;
12434                       destination = (sym_value
12435                                      + sym_sec->output_offset
12436                                      + sym_sec->output_section->vma);
12437                       local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12438                                                             ? hash->elf.other
12439                                                             : sym->st_other);
12440                     }
12441
12442                   code_sec = sym_sec;
12443                   code_value = sym_value;
12444                   opd = get_opd_info (sym_sec);
12445                   if (opd != NULL)
12446                     {
12447                       bfd_vma dest;
12448
12449                       if (hash == NULL && opd->adjust != NULL)
12450                         {
12451                           long adjust = opd->adjust[OPD_NDX (sym_value)];
12452                           if (adjust == -1)
12453                             continue;
12454                           code_value += adjust;
12455                           sym_value += adjust;
12456                         }
12457                       dest = opd_entry_value (sym_sec, sym_value,
12458                                               &code_sec, &code_value, FALSE);
12459                       if (dest != (bfd_vma) -1)
12460                         {
12461                           destination = dest;
12462                           if (fdh != NULL)
12463                             {
12464                               /* Fixup old ABI sym to point at code
12465                                  entry.  */
12466                               hash->elf.root.type = bfd_link_hash_defweak;
12467                               hash->elf.root.u.def.section = code_sec;
12468                               hash->elf.root.u.def.value = code_value;
12469                             }
12470                         }
12471                     }
12472
12473                   /* Determine what (if any) linker stub is needed.  */
12474                   plt_ent = NULL;
12475                   stub_type = ppc_type_of_stub (section, irela, &hash,
12476                                                 &plt_ent, destination,
12477                                                 local_off);
12478
12479                   if (stub_type != ppc_stub_plt_call)
12480                     {
12481                       /* Check whether we need a TOC adjusting stub.
12482                          Since the linker pastes together pieces from
12483                          different object files when creating the
12484                          _init and _fini functions, it may be that a
12485                          call to what looks like a local sym is in
12486                          fact a call needing a TOC adjustment.  */
12487                       if (code_sec != NULL
12488                           && code_sec->output_section != NULL
12489                           && (htab->sec_info[code_sec->id].toc_off
12490                               != htab->sec_info[section->id].toc_off)
12491                           && (code_sec->has_toc_reloc
12492                               || code_sec->makes_toc_func_call))
12493                         stub_type = ppc_stub_long_branch_r2off;
12494                     }
12495
12496                   if (stub_type == ppc_stub_none)
12497                     continue;
12498
12499                   /* __tls_get_addr calls might be eliminated.  */
12500                   if (stub_type != ppc_stub_plt_call
12501                       && hash != NULL
12502                       && (hash == htab->tls_get_addr
12503                           || hash == htab->tls_get_addr_fd)
12504                       && section->has_tls_reloc
12505                       && irela != internal_relocs)
12506                     {
12507                       /* Get tls info.  */
12508                       unsigned char *tls_mask;
12509
12510                       if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12511                                          irela - 1, input_bfd))
12512                         goto error_ret_free_internal;
12513                       if (*tls_mask != 0)
12514                         continue;
12515                     }
12516
12517                   if (stub_type == ppc_stub_plt_call
12518                       && irela + 1 < irelaend
12519                       && irela[1].r_offset == irela->r_offset + 4
12520                       && ELF64_R_TYPE (irela[1].r_info) == R_PPC64_TOCSAVE)
12521                     {
12522                       if (!tocsave_find (htab, INSERT,
12523                                          &local_syms, irela + 1, input_bfd))
12524                         goto error_ret_free_internal;
12525                     }
12526                   else if (stub_type == ppc_stub_plt_call)
12527                     stub_type = ppc_stub_plt_call_r2save;
12528
12529                   /* Support for grouping stub sections.  */
12530                   id_sec = htab->sec_info[section->id].u.group->link_sec;
12531
12532                   /* Get the name of this stub.  */
12533                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12534                   if (!stub_name)
12535                     goto error_ret_free_internal;
12536
12537                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12538                                                      stub_name, FALSE, FALSE);
12539                   if (stub_entry != NULL)
12540                     {
12541                       /* The proper stub has already been created.  */
12542                       free (stub_name);
12543                       if (stub_type == ppc_stub_plt_call_r2save)
12544                         stub_entry->stub_type = stub_type;
12545                       continue;
12546                     }
12547
12548                   stub_entry = ppc_add_stub (stub_name, section, info);
12549                   if (stub_entry == NULL)
12550                     {
12551                       free (stub_name);
12552                     error_ret_free_internal:
12553                       if (elf_section_data (section)->relocs == NULL)
12554                         free (internal_relocs);
12555                     error_ret_free_local:
12556                       if (local_syms != NULL
12557                           && (symtab_hdr->contents
12558                               != (unsigned char *) local_syms))
12559                         free (local_syms);
12560                       return FALSE;
12561                     }
12562
12563                   stub_entry->stub_type = stub_type;
12564                   if (stub_type != ppc_stub_plt_call
12565                       && stub_type != ppc_stub_plt_call_r2save)
12566                     {
12567                       stub_entry->target_value = code_value;
12568                       stub_entry->target_section = code_sec;
12569                     }
12570                   else
12571                     {
12572                       stub_entry->target_value = sym_value;
12573                       stub_entry->target_section = sym_sec;
12574                     }
12575                   stub_entry->h = hash;
12576                   stub_entry->plt_ent = plt_ent;
12577                   stub_entry->other = hash ? hash->elf.other : sym->st_other;
12578
12579                   if (stub_entry->h != NULL)
12580                     htab->stub_globals += 1;
12581                 }
12582
12583               /* We're done with the internal relocs, free them.  */
12584               if (elf_section_data (section)->relocs != internal_relocs)
12585                 free (internal_relocs);
12586             }
12587
12588           if (local_syms != NULL
12589               && symtab_hdr->contents != (unsigned char *) local_syms)
12590             {
12591               if (!info->keep_memory)
12592                 free (local_syms);
12593               else
12594                 symtab_hdr->contents = (unsigned char *) local_syms;
12595             }
12596         }
12597
12598       /* We may have added some stubs.  Find out the new size of the
12599          stub sections.  */
12600       for (stub_sec = htab->params->stub_bfd->sections;
12601            stub_sec != NULL;
12602            stub_sec = stub_sec->next)
12603         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12604           {
12605             stub_sec->rawsize = stub_sec->size;
12606             stub_sec->size = 0;
12607             stub_sec->reloc_count = 0;
12608             stub_sec->flags &= ~SEC_RELOC;
12609           }
12610
12611       htab->brlt->size = 0;
12612       htab->brlt->reloc_count = 0;
12613       htab->brlt->flags &= ~SEC_RELOC;
12614       if (htab->relbrlt != NULL)
12615         htab->relbrlt->size = 0;
12616
12617       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12618
12619       for (group = htab->group; group != NULL; group = group->next)
12620         if (group->needs_save_res)
12621           group->stub_sec->size += htab->sfpr->size;
12622
12623       if (info->emitrelocations
12624           && htab->glink != NULL && htab->glink->size != 0)
12625         {
12626           htab->glink->reloc_count = 1;
12627           htab->glink->flags |= SEC_RELOC;
12628         }
12629
12630       if (htab->glink_eh_frame != NULL
12631           && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12632           && htab->glink_eh_frame->output_section->size != 0)
12633         {
12634           size_t size = 0, align;
12635
12636           for (stub_sec = htab->params->stub_bfd->sections;
12637                stub_sec != NULL;
12638                stub_sec = stub_sec->next)
12639             if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12640               size += 24;
12641           if (htab->glink != NULL && htab->glink->size != 0)
12642             size += 24;
12643           if (size != 0)
12644             size += sizeof (glink_eh_frame_cie);
12645           align = 1;
12646           align <<= htab->glink_eh_frame->output_section->alignment_power;
12647           align -= 1;
12648           size = (size + align) & ~align;
12649           htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12650           htab->glink_eh_frame->size = size;
12651         }
12652
12653       if (htab->params->plt_stub_align != 0)
12654         for (stub_sec = htab->params->stub_bfd->sections;
12655              stub_sec != NULL;
12656              stub_sec = stub_sec->next)
12657           if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12658             stub_sec->size = ((stub_sec->size
12659                                + (1 << htab->params->plt_stub_align) - 1)
12660                               & -(1 << htab->params->plt_stub_align));
12661
12662       for (stub_sec = htab->params->stub_bfd->sections;
12663            stub_sec != NULL;
12664            stub_sec = stub_sec->next)
12665         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12666             && stub_sec->rawsize != stub_sec->size
12667             && (htab->stub_iteration <= STUB_SHRINK_ITER
12668                 || stub_sec->rawsize < stub_sec->size))
12669           break;
12670
12671       if (stub_sec == NULL
12672           && (htab->glink_eh_frame == NULL
12673               || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12674         break;
12675
12676       /* Ask the linker to do its stuff.  */
12677       (*htab->params->layout_sections_again) ();
12678     }
12679
12680   if (htab->glink_eh_frame != NULL
12681       && htab->glink_eh_frame->size != 0)
12682     {
12683       bfd_vma val;
12684       bfd_byte *p, *last_fde;
12685       size_t last_fde_len, size, align, pad;
12686       asection *stub_sec;
12687
12688       p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12689       if (p == NULL)
12690         return FALSE;
12691       htab->glink_eh_frame->contents = p;
12692       last_fde = p;
12693
12694       memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12695       /* CIE length (rewrite in case little-endian).  */
12696       last_fde_len = sizeof (glink_eh_frame_cie) - 4;
12697       bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12698       p += sizeof (glink_eh_frame_cie);
12699
12700       for (stub_sec = htab->params->stub_bfd->sections;
12701            stub_sec != NULL;
12702            stub_sec = stub_sec->next)
12703         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12704           {
12705             last_fde = p;
12706             last_fde_len = 20;
12707             /* FDE length.  */
12708             bfd_put_32 (htab->elf.dynobj, 20, p);
12709             p += 4;
12710             /* CIE pointer.  */
12711             val = p - htab->glink_eh_frame->contents;
12712             bfd_put_32 (htab->elf.dynobj, val, p);
12713             p += 4;
12714             /* Offset to stub section, written later.  */
12715             p += 4;
12716             /* stub section size.  */
12717             bfd_put_32 (htab->elf.dynobj, stub_sec->size, p);
12718             p += 4;
12719             /* Augmentation.  */
12720             p += 1;
12721             /* Pad.  */
12722             p += 7;
12723           }
12724       if (htab->glink != NULL && htab->glink->size != 0)
12725         {
12726           last_fde = p;
12727           last_fde_len = 20;
12728           /* FDE length.  */
12729           bfd_put_32 (htab->elf.dynobj, 20, p);
12730           p += 4;
12731           /* CIE pointer.  */
12732           val = p - htab->glink_eh_frame->contents;
12733           bfd_put_32 (htab->elf.dynobj, val, p);
12734           p += 4;
12735           /* Offset to .glink, written later.  */
12736           p += 4;
12737           /* .glink size.  */
12738           bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12739           p += 4;
12740           /* Augmentation.  */
12741           p += 1;
12742
12743           *p++ = DW_CFA_advance_loc + 1;
12744           *p++ = DW_CFA_register;
12745           *p++ = 65;
12746           *p++ = htab->opd_abi ? 12 : 0;
12747           *p++ = DW_CFA_advance_loc + 4;
12748           *p++ = DW_CFA_restore_extended;
12749           *p++ = 65;
12750         }
12751       /* Subsume any padding into the last FDE if user .eh_frame
12752          sections are aligned more than glink_eh_frame.  Otherwise any
12753          zero padding will be seen as a terminator.  */
12754       size = p - htab->glink_eh_frame->contents;
12755       align = 1;
12756       align <<= htab->glink_eh_frame->output_section->alignment_power;
12757       align -= 1;
12758       pad = ((size + align) & ~align) - size;
12759       htab->glink_eh_frame->size = size + pad;
12760       bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12761     }
12762
12763   maybe_strip_output (info, htab->brlt);
12764   if (htab->glink_eh_frame != NULL)
12765     maybe_strip_output (info, htab->glink_eh_frame);
12766
12767   return TRUE;
12768 }
12769
12770 /* Called after we have determined section placement.  If sections
12771    move, we'll be called again.  Provide a value for TOCstart.  */
12772
12773 bfd_vma
12774 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12775 {
12776   asection *s;
12777   bfd_vma TOCstart, adjust;
12778
12779   if (info != NULL)
12780     {
12781       struct elf_link_hash_entry *h;
12782       struct elf_link_hash_table *htab = elf_hash_table (info);
12783
12784       if (is_elf_hash_table (htab)
12785           && htab->hgot != NULL)
12786         h = htab->hgot;
12787       else
12788         {
12789           h = elf_link_hash_lookup (htab, ".TOC.", FALSE, FALSE, TRUE);
12790           if (is_elf_hash_table (htab))
12791             htab->hgot = h;
12792         }
12793       if (h != NULL
12794           && h->root.type == bfd_link_hash_defined
12795           && !h->root.linker_def
12796           && (!is_elf_hash_table (htab)
12797               || h->def_regular))
12798         {
12799           TOCstart = (h->root.u.def.value - TOC_BASE_OFF
12800                       + h->root.u.def.section->output_offset
12801                       + h->root.u.def.section->output_section->vma);
12802           _bfd_set_gp_value (obfd, TOCstart);
12803           return TOCstart;
12804         }
12805     }
12806
12807   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12808      order.  The TOC starts where the first of these sections starts.  */
12809   s = bfd_get_section_by_name (obfd, ".got");
12810   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12811     s = bfd_get_section_by_name (obfd, ".toc");
12812   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12813     s = bfd_get_section_by_name (obfd, ".tocbss");
12814   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12815     s = bfd_get_section_by_name (obfd, ".plt");
12816   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12817     {
12818       /* This may happen for
12819          o  references to TOC base (SYM@toc / TOC[tc0]) without a
12820          .toc directive
12821          o  bad linker script
12822          o --gc-sections and empty TOC sections
12823
12824          FIXME: Warn user?  */
12825
12826       /* Look for a likely section.  We probably won't even be
12827          using TOCstart.  */
12828       for (s = obfd->sections; s != NULL; s = s->next)
12829         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
12830                          | SEC_EXCLUDE))
12831             == (SEC_ALLOC | SEC_SMALL_DATA))
12832           break;
12833       if (s == NULL)
12834         for (s = obfd->sections; s != NULL; s = s->next)
12835           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
12836               == (SEC_ALLOC | SEC_SMALL_DATA))
12837             break;
12838       if (s == NULL)
12839         for (s = obfd->sections; s != NULL; s = s->next)
12840           if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
12841               == SEC_ALLOC)
12842             break;
12843       if (s == NULL)
12844         for (s = obfd->sections; s != NULL; s = s->next)
12845           if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
12846             break;
12847     }
12848
12849   TOCstart = 0;
12850   if (s != NULL)
12851     TOCstart = s->output_section->vma + s->output_offset;
12852
12853   /* Force alignment.  */
12854   adjust = TOCstart & (TOC_BASE_ALIGN - 1);
12855   TOCstart -= adjust;
12856   _bfd_set_gp_value (obfd, TOCstart);
12857
12858   if (info != NULL && s != NULL)
12859     {
12860       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12861
12862       if (htab != NULL)
12863         {
12864           if (htab->elf.hgot != NULL)
12865             {
12866               htab->elf.hgot->root.u.def.value = TOC_BASE_OFF - adjust;
12867               htab->elf.hgot->root.u.def.section = s;
12868             }
12869         }
12870       else
12871         {
12872           struct bfd_link_hash_entry *bh = NULL;
12873           _bfd_generic_link_add_one_symbol (info, obfd, ".TOC.", BSF_GLOBAL,
12874                                             s, TOC_BASE_OFF - adjust,
12875                                             NULL, FALSE, FALSE, &bh);
12876         }
12877     }
12878   return TOCstart;
12879 }
12880
12881 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
12882    write out any global entry stubs.  */
12883
12884 static bfd_boolean
12885 build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
12886 {
12887   struct bfd_link_info *info;
12888   struct ppc_link_hash_table *htab;
12889   struct plt_entry *pent;
12890   asection *s;
12891
12892   if (h->root.type == bfd_link_hash_indirect)
12893     return TRUE;
12894
12895   if (!h->pointer_equality_needed)
12896     return TRUE;
12897
12898   if (h->def_regular)
12899     return TRUE;
12900
12901   info = inf;
12902   htab = ppc_hash_table (info);
12903   if (htab == NULL)
12904     return FALSE;
12905
12906   s = htab->glink;
12907   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
12908     if (pent->plt.offset != (bfd_vma) -1
12909         && pent->addend == 0)
12910       {
12911         bfd_byte *p;
12912         asection *plt;
12913         bfd_vma off;
12914
12915         p = s->contents + h->root.u.def.value;
12916         plt = htab->elf.splt;
12917         if (!htab->elf.dynamic_sections_created
12918             || h->dynindx == -1)
12919           plt = htab->elf.iplt;
12920         off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
12921         off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
12922
12923         if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
12924           {
12925             info->callbacks->einfo
12926               (_("%P: linkage table error against `%T'\n"),
12927                h->root.root.string);
12928             bfd_set_error (bfd_error_bad_value);
12929             htab->stub_error = TRUE;
12930           }
12931
12932         htab->stub_count[ppc_stub_global_entry - 1] += 1;
12933         if (htab->params->emit_stub_syms)
12934           {
12935             size_t len = strlen (h->root.root.string);
12936             char *name = bfd_malloc (sizeof "12345678.global_entry." + len);
12937
12938             if (name == NULL)
12939               return FALSE;
12940
12941             sprintf (name, "%08x.global_entry.%s", s->id, h->root.root.string);
12942             h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
12943             if (h == NULL)
12944               return FALSE;
12945             if (h->root.type == bfd_link_hash_new)
12946               {
12947                 h->root.type = bfd_link_hash_defined;
12948                 h->root.u.def.section = s;
12949                 h->root.u.def.value = p - s->contents;
12950                 h->ref_regular = 1;
12951                 h->def_regular = 1;
12952                 h->ref_regular_nonweak = 1;
12953                 h->forced_local = 1;
12954                 h->non_elf = 0;
12955                 h->root.linker_def = 1;
12956               }
12957           }
12958
12959         if (PPC_HA (off) != 0)
12960           {
12961             bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
12962             p += 4;
12963           }
12964         bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
12965         p += 4;
12966         bfd_put_32 (s->owner, MTCTR_R12, p);
12967         p += 4;
12968         bfd_put_32 (s->owner, BCTR, p);
12969         break;
12970       }
12971   return TRUE;
12972 }
12973
12974 /* Build all the stubs associated with the current output file.
12975    The stubs are kept in a hash table attached to the main linker
12976    hash table.  This function is called via gldelf64ppc_finish.  */
12977
12978 bfd_boolean
12979 ppc64_elf_build_stubs (struct bfd_link_info *info,
12980                        char **stats)
12981 {
12982   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12983   struct map_stub *group;
12984   asection *stub_sec;
12985   bfd_byte *p;
12986   int stub_sec_count = 0;
12987
12988   if (htab == NULL)
12989     return FALSE;
12990
12991   /* Allocate memory to hold the linker stubs.  */
12992   for (stub_sec = htab->params->stub_bfd->sections;
12993        stub_sec != NULL;
12994        stub_sec = stub_sec->next)
12995     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12996         && stub_sec->size != 0)
12997       {
12998         stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
12999         if (stub_sec->contents == NULL)
13000           return FALSE;
13001         stub_sec->size = 0;
13002       }
13003
13004   if (htab->glink != NULL && htab->glink->size != 0)
13005     {
13006       unsigned int indx;
13007       bfd_vma plt0;
13008
13009       /* Build the .glink plt call stub.  */
13010       if (htab->params->emit_stub_syms)
13011         {
13012           struct elf_link_hash_entry *h;
13013           h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
13014                                     TRUE, FALSE, FALSE);
13015           if (h == NULL)
13016             return FALSE;
13017           if (h->root.type == bfd_link_hash_new)
13018             {
13019               h->root.type = bfd_link_hash_defined;
13020               h->root.u.def.section = htab->glink;
13021               h->root.u.def.value = 8;
13022               h->ref_regular = 1;
13023               h->def_regular = 1;
13024               h->ref_regular_nonweak = 1;
13025               h->forced_local = 1;
13026               h->non_elf = 0;
13027               h->root.linker_def = 1;
13028             }
13029         }
13030       plt0 = (htab->elf.splt->output_section->vma
13031               + htab->elf.splt->output_offset
13032               - 16);
13033       if (info->emitrelocations)
13034         {
13035           Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
13036           if (r == NULL)
13037             return FALSE;
13038           r->r_offset = (htab->glink->output_offset
13039                          + htab->glink->output_section->vma);
13040           r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
13041           r->r_addend = plt0;
13042         }
13043       p = htab->glink->contents;
13044       plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
13045       bfd_put_64 (htab->glink->owner, plt0, p);
13046       p += 8;
13047       if (htab->opd_abi)
13048         {
13049           bfd_put_32 (htab->glink->owner, MFLR_R12, p);
13050           p += 4;
13051           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13052           p += 4;
13053           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13054           p += 4;
13055           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13056           p += 4;
13057           bfd_put_32 (htab->glink->owner, MTLR_R12, p);
13058           p += 4;
13059           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13060           p += 4;
13061           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13062           p += 4;
13063           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
13064           p += 4;
13065           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13066           p += 4;
13067           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
13068           p += 4;
13069         }
13070       else
13071         {
13072           bfd_put_32 (htab->glink->owner, MFLR_R0, p);
13073           p += 4;
13074           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13075           p += 4;
13076           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13077           p += 4;
13078           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13079           p += 4;
13080           bfd_put_32 (htab->glink->owner, MTLR_R0, p);
13081           p += 4;
13082           bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
13083           p += 4;
13084           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13085           p += 4;
13086           bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
13087           p += 4;
13088           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13089           p += 4;
13090           bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
13091           p += 4;
13092           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13093           p += 4;
13094           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
13095           p += 4;
13096         }
13097       bfd_put_32 (htab->glink->owner, BCTR, p);
13098       p += 4;
13099       while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
13100         {
13101           bfd_put_32 (htab->glink->owner, NOP, p);
13102           p += 4;
13103         }
13104
13105       /* Build the .glink lazy link call stubs.  */
13106       indx = 0;
13107       while (p < htab->glink->contents + htab->glink->rawsize)
13108         {
13109           if (htab->opd_abi)
13110             {
13111               if (indx < 0x8000)
13112                 {
13113                   bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
13114                   p += 4;
13115                 }
13116               else
13117                 {
13118                   bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
13119                   p += 4;
13120                   bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
13121                               p);
13122                   p += 4;
13123                 }
13124             }
13125           bfd_put_32 (htab->glink->owner,
13126                       B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
13127           indx++;
13128           p += 4;
13129         }
13130
13131       /* Build .glink global entry stubs.  */
13132       if (htab->glink->size > htab->glink->rawsize)
13133         elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
13134     }
13135
13136   if (htab->brlt != NULL && htab->brlt->size != 0)
13137     {
13138       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
13139                                          htab->brlt->size);
13140       if (htab->brlt->contents == NULL)
13141         return FALSE;
13142     }
13143   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
13144     {
13145       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
13146                                             htab->relbrlt->size);
13147       if (htab->relbrlt->contents == NULL)
13148         return FALSE;
13149     }
13150
13151   /* Build the stubs as directed by the stub hash table.  */
13152   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
13153
13154   for (group = htab->group; group != NULL; group = group->next)
13155     if (group->needs_save_res)
13156       {
13157         stub_sec = group->stub_sec;
13158         memcpy (stub_sec->contents + stub_sec->size, htab->sfpr->contents,
13159                 htab->sfpr->size);
13160         if (htab->params->emit_stub_syms)
13161           {
13162             unsigned int i;
13163
13164             for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
13165               if (!sfpr_define (info, &save_res_funcs[i], stub_sec))
13166                 return FALSE;
13167           }
13168         stub_sec->size += htab->sfpr->size;
13169       }
13170
13171   if (htab->relbrlt != NULL)
13172     htab->relbrlt->reloc_count = 0;
13173
13174   if (htab->params->plt_stub_align != 0)
13175     for (stub_sec = htab->params->stub_bfd->sections;
13176          stub_sec != NULL;
13177          stub_sec = stub_sec->next)
13178       if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
13179         stub_sec->size = ((stub_sec->size
13180                            + (1 << htab->params->plt_stub_align) - 1)
13181                           & -(1 << htab->params->plt_stub_align));
13182
13183   for (stub_sec = htab->params->stub_bfd->sections;
13184        stub_sec != NULL;
13185        stub_sec = stub_sec->next)
13186     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
13187       {
13188         stub_sec_count += 1;
13189         if (stub_sec->rawsize != stub_sec->size
13190             && (htab->stub_iteration <= STUB_SHRINK_ITER
13191                 || stub_sec->rawsize < stub_sec->size))
13192           break;
13193       }
13194
13195   /* Note that the glink_eh_frame check here is not only testing that
13196      the generated size matched the calculated size but also that
13197      bfd_elf_discard_info didn't make any changes to the section.  */
13198   if (stub_sec != NULL
13199       || (htab->glink_eh_frame != NULL
13200           && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
13201     {
13202       htab->stub_error = TRUE;
13203       info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
13204     }
13205
13206   if (htab->stub_error)
13207     return FALSE;
13208
13209   if (stats != NULL)
13210     {
13211       *stats = bfd_malloc (500);
13212       if (*stats == NULL)
13213         return FALSE;
13214
13215       sprintf (*stats, _("linker stubs in %u group%s\n"
13216                          "  branch       %lu\n"
13217                          "  toc adjust   %lu\n"
13218                          "  long branch  %lu\n"
13219                          "  long toc adj %lu\n"
13220                          "  plt call     %lu\n"
13221                          "  plt call toc %lu\n"
13222                          "  global entry %lu"),
13223                stub_sec_count,
13224                stub_sec_count == 1 ? "" : "s",
13225                htab->stub_count[ppc_stub_long_branch - 1],
13226                htab->stub_count[ppc_stub_long_branch_r2off - 1],
13227                htab->stub_count[ppc_stub_plt_branch - 1],
13228                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
13229                htab->stub_count[ppc_stub_plt_call - 1],
13230                htab->stub_count[ppc_stub_plt_call_r2save - 1],
13231                htab->stub_count[ppc_stub_global_entry - 1]);
13232     }
13233   return TRUE;
13234 }
13235
13236 /* This function undoes the changes made by add_symbol_adjust.  */
13237
13238 static bfd_boolean
13239 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
13240 {
13241   struct ppc_link_hash_entry *eh;
13242
13243   if (h->root.type == bfd_link_hash_indirect)
13244     return TRUE;
13245
13246   eh = (struct ppc_link_hash_entry *) h;
13247   if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
13248     return TRUE;
13249
13250   eh->elf.root.type = bfd_link_hash_undefined;
13251   return TRUE;
13252 }
13253
13254 void
13255 ppc64_elf_restore_symbols (struct bfd_link_info *info)
13256 {
13257   struct ppc_link_hash_table *htab = ppc_hash_table (info);
13258
13259   if (htab != NULL)
13260     elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
13261 }
13262
13263 /* What to do when ld finds relocations against symbols defined in
13264    discarded sections.  */
13265
13266 static unsigned int
13267 ppc64_elf_action_discarded (asection *sec)
13268 {
13269   if (strcmp (".opd", sec->name) == 0)
13270     return 0;
13271
13272   if (strcmp (".toc", sec->name) == 0)
13273     return 0;
13274
13275   if (strcmp (".toc1", sec->name) == 0)
13276     return 0;
13277
13278   return _bfd_elf_default_action_discarded (sec);
13279 }
13280
13281 /* The RELOCATE_SECTION function is called by the ELF backend linker
13282    to handle the relocations for a section.
13283
13284    The relocs are always passed as Rela structures; if the section
13285    actually uses Rel structures, the r_addend field will always be
13286    zero.
13287
13288    This function is responsible for adjust the section contents as
13289    necessary, and (if using Rela relocs and generating a
13290    relocatable output file) adjusting the reloc addend as
13291    necessary.
13292
13293    This function does not have to worry about setting the reloc
13294    address or the reloc symbol index.
13295
13296    LOCAL_SYMS is a pointer to the swapped in local symbols.
13297
13298    LOCAL_SECTIONS is an array giving the section in the input file
13299    corresponding to the st_shndx field of each local symbol.
13300
13301    The global hash table entry for the global symbols can be found
13302    via elf_sym_hashes (input_bfd).
13303
13304    When generating relocatable output, this function must handle
13305    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
13306    going to be the section symbol corresponding to the output
13307    section, which means that the addend must be adjusted
13308    accordingly.  */
13309
13310 static bfd_boolean
13311 ppc64_elf_relocate_section (bfd *output_bfd,
13312                             struct bfd_link_info *info,
13313                             bfd *input_bfd,
13314                             asection *input_section,
13315                             bfd_byte *contents,
13316                             Elf_Internal_Rela *relocs,
13317                             Elf_Internal_Sym *local_syms,
13318                             asection **local_sections)
13319 {
13320   struct ppc_link_hash_table *htab;
13321   Elf_Internal_Shdr *symtab_hdr;
13322   struct elf_link_hash_entry **sym_hashes;
13323   Elf_Internal_Rela *rel;
13324   Elf_Internal_Rela *wrel;
13325   Elf_Internal_Rela *relend;
13326   Elf_Internal_Rela outrel;
13327   bfd_byte *loc;
13328   struct got_entry **local_got_ents;
13329   bfd_vma TOCstart;
13330   bfd_boolean ret = TRUE;
13331   bfd_boolean is_opd;
13332   /* Assume 'at' branch hints.  */
13333   bfd_boolean is_isa_v2 = TRUE;
13334   bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
13335
13336   /* Initialize howto table if needed.  */
13337   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
13338     ppc_howto_init ();
13339
13340   htab = ppc_hash_table (info);
13341   if (htab == NULL)
13342     return FALSE;
13343
13344   /* Don't relocate stub sections.  */
13345   if (input_section->owner == htab->params->stub_bfd)
13346     return TRUE;
13347
13348   BFD_ASSERT (is_ppc64_elf (input_bfd));
13349
13350   local_got_ents = elf_local_got_ents (input_bfd);
13351   TOCstart = elf_gp (output_bfd);
13352   symtab_hdr = &elf_symtab_hdr (input_bfd);
13353   sym_hashes = elf_sym_hashes (input_bfd);
13354   is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
13355
13356   rel = wrel = relocs;
13357   relend = relocs + input_section->reloc_count;
13358   for (; rel < relend; wrel++, rel++)
13359     {
13360       enum elf_ppc64_reloc_type r_type;
13361       bfd_vma addend;
13362       bfd_reloc_status_type r;
13363       Elf_Internal_Sym *sym;
13364       asection *sec;
13365       struct elf_link_hash_entry *h_elf;
13366       struct ppc_link_hash_entry *h;
13367       struct ppc_link_hash_entry *fdh;
13368       const char *sym_name;
13369       unsigned long r_symndx, toc_symndx;
13370       bfd_vma toc_addend;
13371       unsigned char tls_mask, tls_gd, tls_type;
13372       unsigned char sym_type;
13373       bfd_vma relocation;
13374       bfd_boolean unresolved_reloc;
13375       bfd_boolean warned;
13376       enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
13377       unsigned int insn;
13378       unsigned int mask;
13379       struct ppc_stub_hash_entry *stub_entry;
13380       bfd_vma max_br_offset;
13381       bfd_vma from;
13382       Elf_Internal_Rela orig_rel;
13383       reloc_howto_type *howto;
13384       struct reloc_howto_struct alt_howto;
13385
13386     again:
13387       orig_rel = *rel;
13388
13389       r_type = ELF64_R_TYPE (rel->r_info);
13390       r_symndx = ELF64_R_SYM (rel->r_info);
13391
13392       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
13393          symbol of the previous ADDR64 reloc.  The symbol gives us the
13394          proper TOC base to use.  */
13395       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
13396           && wrel != relocs
13397           && ELF64_R_TYPE (wrel[-1].r_info) == R_PPC64_ADDR64
13398           && is_opd)
13399         r_symndx = ELF64_R_SYM (wrel[-1].r_info);
13400
13401       sym = NULL;
13402       sec = NULL;
13403       h_elf = NULL;
13404       sym_name = NULL;
13405       unresolved_reloc = FALSE;
13406       warned = FALSE;
13407
13408       if (r_symndx < symtab_hdr->sh_info)
13409         {
13410           /* It's a local symbol.  */
13411           struct _opd_sec_data *opd;
13412
13413           sym = local_syms + r_symndx;
13414           sec = local_sections[r_symndx];
13415           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
13416           sym_type = ELF64_ST_TYPE (sym->st_info);
13417           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
13418           opd = get_opd_info (sec);
13419           if (opd != NULL && opd->adjust != NULL)
13420             {
13421               long adjust = opd->adjust[OPD_NDX (sym->st_value
13422                                                  + rel->r_addend)];
13423               if (adjust == -1)
13424                 relocation = 0;
13425               else
13426                 {
13427                   /* If this is a relocation against the opd section sym
13428                      and we have edited .opd, adjust the reloc addend so
13429                      that ld -r and ld --emit-relocs output is correct.
13430                      If it is a reloc against some other .opd symbol,
13431                      then the symbol value will be adjusted later.  */
13432                   if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
13433                     rel->r_addend += adjust;
13434                   else
13435                     relocation += adjust;
13436                 }
13437             }
13438         }
13439       else
13440         {
13441           bfd_boolean ignored;
13442
13443           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
13444                                    r_symndx, symtab_hdr, sym_hashes,
13445                                    h_elf, sec, relocation,
13446                                    unresolved_reloc, warned, ignored);
13447           sym_name = h_elf->root.root.string;
13448           sym_type = h_elf->type;
13449           if (sec != NULL
13450               && sec->owner == output_bfd
13451               && strcmp (sec->name, ".opd") == 0)
13452             {
13453               /* This is a symbol defined in a linker script.  All
13454                  such are defined in output sections, even those
13455                  defined by simple assignment from a symbol defined in
13456                  an input section.  Transfer the symbol to an
13457                  appropriate input .opd section, so that a branch to
13458                  this symbol will be mapped to the location specified
13459                  by the opd entry.  */
13460               struct bfd_link_order *lo;
13461               for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
13462                 if (lo->type == bfd_indirect_link_order)
13463                   {
13464                     asection *isec = lo->u.indirect.section;
13465                     if (h_elf->root.u.def.value >= isec->output_offset
13466                         && h_elf->root.u.def.value < (isec->output_offset
13467                                                       + isec->size))
13468                       {
13469                         h_elf->root.u.def.value -= isec->output_offset;
13470                         h_elf->root.u.def.section = isec;
13471                         sec = isec;
13472                         break;
13473                       }
13474                   }
13475             }
13476         }
13477       h = (struct ppc_link_hash_entry *) h_elf;
13478
13479       if (sec != NULL && discarded_section (sec))
13480         {
13481           _bfd_clear_contents (ppc64_elf_howto_table[r_type],
13482                                input_bfd, input_section,
13483                                contents + rel->r_offset);
13484           wrel->r_offset = rel->r_offset;
13485           wrel->r_info = 0;
13486           wrel->r_addend = 0;
13487
13488           /* For ld -r, remove relocations in debug sections against
13489              sections defined in discarded sections.  Not done for
13490              non-debug to preserve relocs in .eh_frame which the
13491              eh_frame editing code expects to be present.  */
13492           if (bfd_link_relocatable (info)
13493               && (input_section->flags & SEC_DEBUGGING))
13494             wrel--;
13495
13496           continue;
13497         }
13498
13499       if (bfd_link_relocatable (info))
13500         goto copy_reloc;
13501
13502       if (h != NULL && &h->elf == htab->elf.hgot)
13503         {
13504           relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
13505           sec = bfd_abs_section_ptr;
13506           unresolved_reloc = FALSE;
13507         }
13508
13509       /* TLS optimizations.  Replace instruction sequences and relocs
13510          based on information we collected in tls_optimize.  We edit
13511          RELOCS so that --emit-relocs will output something sensible
13512          for the final instruction stream.  */
13513       tls_mask = 0;
13514       tls_gd = 0;
13515       toc_symndx = 0;
13516       if (h != NULL)
13517         tls_mask = h->tls_mask;
13518       else if (local_got_ents != NULL)
13519         {
13520           struct plt_entry **local_plt = (struct plt_entry **)
13521             (local_got_ents + symtab_hdr->sh_info);
13522           unsigned char *lgot_masks = (unsigned char *)
13523             (local_plt + symtab_hdr->sh_info);
13524           tls_mask = lgot_masks[r_symndx];
13525         }
13526       if (tls_mask == 0
13527           && (r_type == R_PPC64_TLS
13528               || r_type == R_PPC64_TLSGD
13529               || r_type == R_PPC64_TLSLD))
13530         {
13531           /* Check for toc tls entries.  */
13532           unsigned char *toc_tls;
13533
13534           if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13535                              &local_syms, rel, input_bfd))
13536             return FALSE;
13537
13538           if (toc_tls)
13539             tls_mask = *toc_tls;
13540         }
13541
13542       /* Check that tls relocs are used with tls syms, and non-tls
13543          relocs are used with non-tls syms.  */
13544       if (r_symndx != STN_UNDEF
13545           && r_type != R_PPC64_NONE
13546           && (h == NULL
13547               || h->elf.root.type == bfd_link_hash_defined
13548               || h->elf.root.type == bfd_link_hash_defweak)
13549           && (IS_PPC64_TLS_RELOC (r_type)
13550               != (sym_type == STT_TLS
13551                   || (sym_type == STT_SECTION
13552                       && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13553         {
13554           if (tls_mask != 0
13555               && (r_type == R_PPC64_TLS
13556                   || r_type == R_PPC64_TLSGD
13557                   || r_type == R_PPC64_TLSLD))
13558             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
13559             ;
13560           else
13561             info->callbacks->einfo
13562               (!IS_PPC64_TLS_RELOC (r_type)
13563                ? _("%P: %H: %s used with TLS symbol `%T'\n")
13564                : _("%P: %H: %s used with non-TLS symbol `%T'\n"),
13565                input_bfd, input_section, rel->r_offset,
13566                ppc64_elf_howto_table[r_type]->name,
13567                sym_name);
13568         }
13569
13570       /* Ensure reloc mapping code below stays sane.  */
13571       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13572           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13573           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
13574           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13575           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13576           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13577           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
13578           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13579           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13580           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13581         abort ();
13582
13583       switch (r_type)
13584         {
13585         default:
13586           break;
13587
13588         case R_PPC64_LO_DS_OPT:
13589           insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13590           if ((insn & (0x3f << 26)) != 58u << 26)
13591             abort ();
13592           insn += (14u << 26) - (58u << 26);
13593           bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13594           r_type = R_PPC64_TOC16_LO;
13595           rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13596           break;
13597
13598         case R_PPC64_TOC16:
13599         case R_PPC64_TOC16_LO:
13600         case R_PPC64_TOC16_DS:
13601         case R_PPC64_TOC16_LO_DS:
13602           {
13603             /* Check for toc tls entries.  */
13604             unsigned char *toc_tls;
13605             int retval;
13606
13607             retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13608                                    &local_syms, rel, input_bfd);
13609             if (retval == 0)
13610               return FALSE;
13611
13612             if (toc_tls)
13613               {
13614                 tls_mask = *toc_tls;
13615                 if (r_type == R_PPC64_TOC16_DS
13616                     || r_type == R_PPC64_TOC16_LO_DS)
13617                   {
13618                     if (tls_mask != 0
13619                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13620                       goto toctprel;
13621                   }
13622                 else
13623                   {
13624                     /* If we found a GD reloc pair, then we might be
13625                        doing a GD->IE transition.  */
13626                     if (retval == 2)
13627                       {
13628                         tls_gd = TLS_TPRELGD;
13629                         if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13630                           goto tls_ldgd_opt;
13631                       }
13632                     else if (retval == 3)
13633                       {
13634                         if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13635                           goto tls_ldgd_opt;
13636                       }
13637                   }
13638               }
13639           }
13640           break;
13641
13642         case R_PPC64_GOT_TPREL16_HI:
13643         case R_PPC64_GOT_TPREL16_HA:
13644           if (tls_mask != 0
13645               && (tls_mask & TLS_TPREL) == 0)
13646             {
13647               rel->r_offset -= d_offset;
13648               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13649               r_type = R_PPC64_NONE;
13650               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13651             }
13652           break;
13653
13654         case R_PPC64_GOT_TPREL16_DS:
13655         case R_PPC64_GOT_TPREL16_LO_DS:
13656           if (tls_mask != 0
13657               && (tls_mask & TLS_TPREL) == 0)
13658             {
13659             toctprel:
13660               insn = bfd_get_32 (output_bfd,
13661                                  contents + rel->r_offset - d_offset);
13662               insn &= 31 << 21;
13663               insn |= 0x3c0d0000;       /* addis 0,13,0 */
13664               bfd_put_32 (output_bfd, insn,
13665                           contents + rel->r_offset - d_offset);
13666               r_type = R_PPC64_TPREL16_HA;
13667               if (toc_symndx != 0)
13668                 {
13669                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13670                   rel->r_addend = toc_addend;
13671                   /* We changed the symbol.  Start over in order to
13672                      get h, sym, sec etc. right.  */
13673                   goto again;
13674                 }
13675               else
13676                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13677             }
13678           break;
13679
13680         case R_PPC64_TLS:
13681           if (tls_mask != 0
13682               && (tls_mask & TLS_TPREL) == 0)
13683             {
13684               insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
13685               insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13686               if (insn == 0)
13687                 abort ();
13688               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13689               /* Was PPC64_TLS which sits on insn boundary, now
13690                  PPC64_TPREL16_LO which is at low-order half-word.  */
13691               rel->r_offset += d_offset;
13692               r_type = R_PPC64_TPREL16_LO;
13693               if (toc_symndx != 0)
13694                 {
13695                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13696                   rel->r_addend = toc_addend;
13697                   /* We changed the symbol.  Start over in order to
13698                      get h, sym, sec etc. right.  */
13699                   goto again;
13700                 }
13701               else
13702                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13703             }
13704           break;
13705
13706         case R_PPC64_GOT_TLSGD16_HI:
13707         case R_PPC64_GOT_TLSGD16_HA:
13708           tls_gd = TLS_TPRELGD;
13709           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13710             goto tls_gdld_hi;
13711           break;
13712
13713         case R_PPC64_GOT_TLSLD16_HI:
13714         case R_PPC64_GOT_TLSLD16_HA:
13715           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13716             {
13717             tls_gdld_hi:
13718               if ((tls_mask & tls_gd) != 0)
13719                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13720                           + R_PPC64_GOT_TPREL16_DS);
13721               else
13722                 {
13723                   rel->r_offset -= d_offset;
13724                   bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13725                   r_type = R_PPC64_NONE;
13726                 }
13727               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13728             }
13729           break;
13730
13731         case R_PPC64_GOT_TLSGD16:
13732         case R_PPC64_GOT_TLSGD16_LO:
13733           tls_gd = TLS_TPRELGD;
13734           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13735             goto tls_ldgd_opt;
13736           break;
13737
13738         case R_PPC64_GOT_TLSLD16:
13739         case R_PPC64_GOT_TLSLD16_LO:
13740           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13741             {
13742               unsigned int insn1, insn2, insn3;
13743               bfd_vma offset;
13744
13745             tls_ldgd_opt:
13746               offset = (bfd_vma) -1;
13747               /* If not using the newer R_PPC64_TLSGD/LD to mark
13748                  __tls_get_addr calls, we must trust that the call
13749                  stays with its arg setup insns, ie. that the next
13750                  reloc is the __tls_get_addr call associated with
13751                  the current reloc.  Edit both insns.  */
13752               if (input_section->has_tls_get_addr_call
13753                   && rel + 1 < relend
13754                   && branch_reloc_hash_match (input_bfd, rel + 1,
13755                                               htab->tls_get_addr,
13756                                               htab->tls_get_addr_fd))
13757                 offset = rel[1].r_offset;
13758               /* We read the low GOT_TLS (or TOC16) insn because we
13759                  need to keep the destination reg.  It may be
13760                  something other than the usual r3, and moved to r3
13761                  before the call by intervening code.  */
13762               insn1 = bfd_get_32 (output_bfd,
13763                                   contents + rel->r_offset - d_offset);
13764               if ((tls_mask & tls_gd) != 0)
13765                 {
13766                   /* IE */
13767                   insn1 &= (0x1f << 21) | (0x1f << 16);
13768                   insn1 |= 58 << 26;    /* ld */
13769                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13770                   if (offset != (bfd_vma) -1)
13771                     rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13772                   if ((tls_mask & TLS_EXPLICIT) == 0)
13773                     r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13774                               + R_PPC64_GOT_TPREL16_DS);
13775                   else
13776                     r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13777                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13778                 }
13779               else
13780                 {
13781                   /* LE */
13782                   insn1 &= 0x1f << 21;
13783                   insn1 |= 0x3c0d0000;  /* addis r,13,0 */
13784                   insn2 = 0x38630000;   /* addi 3,3,0 */
13785                   if (tls_gd == 0)
13786                     {
13787                       /* Was an LD reloc.  */
13788                       if (toc_symndx)
13789                         sec = local_sections[toc_symndx];
13790                       for (r_symndx = 0;
13791                            r_symndx < symtab_hdr->sh_info;
13792                            r_symndx++)
13793                         if (local_sections[r_symndx] == sec)
13794                           break;
13795                       if (r_symndx >= symtab_hdr->sh_info)
13796                         r_symndx = STN_UNDEF;
13797                       rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13798                       if (r_symndx != STN_UNDEF)
13799                         rel->r_addend -= (local_syms[r_symndx].st_value
13800                                           + sec->output_offset
13801                                           + sec->output_section->vma);
13802                     }
13803                   else if (toc_symndx != 0)
13804                     {
13805                       r_symndx = toc_symndx;
13806                       rel->r_addend = toc_addend;
13807                     }
13808                   r_type = R_PPC64_TPREL16_HA;
13809                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13810                   if (offset != (bfd_vma) -1)
13811                     {
13812                       rel[1].r_info = ELF64_R_INFO (r_symndx,
13813                                                     R_PPC64_TPREL16_LO);
13814                       rel[1].r_offset = offset + d_offset;
13815                       rel[1].r_addend = rel->r_addend;
13816                     }
13817                 }
13818               bfd_put_32 (output_bfd, insn1,
13819                           contents + rel->r_offset - d_offset);
13820               if (offset != (bfd_vma) -1)
13821                 {
13822                   insn3 = bfd_get_32 (output_bfd,
13823                                       contents + offset + 4);
13824                   if (insn3 == NOP
13825                       || insn3 == CROR_151515 || insn3 == CROR_313131)
13826                     {
13827                       rel[1].r_offset += 4;
13828                       bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13829                       insn2 = NOP;
13830                     }
13831                   bfd_put_32 (output_bfd, insn2, contents + offset);
13832                 }
13833               if ((tls_mask & tls_gd) == 0
13834                   && (tls_gd == 0 || toc_symndx != 0))
13835                 {
13836                   /* We changed the symbol.  Start over in order
13837                      to get h, sym, sec etc. right.  */
13838                   goto again;
13839                 }
13840             }
13841           break;
13842
13843         case R_PPC64_TLSGD:
13844           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13845             {
13846               unsigned int insn2, insn3;
13847               bfd_vma offset = rel->r_offset;
13848
13849               if ((tls_mask & TLS_TPRELGD) != 0)
13850                 {
13851                   /* IE */
13852                   r_type = R_PPC64_NONE;
13853                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13854                 }
13855               else
13856                 {
13857                   /* LE */
13858                   if (toc_symndx != 0)
13859                     {
13860                       r_symndx = toc_symndx;
13861                       rel->r_addend = toc_addend;
13862                     }
13863                   r_type = R_PPC64_TPREL16_LO;
13864                   rel->r_offset = offset + d_offset;
13865                   insn2 = 0x38630000;   /* addi 3,3,0 */
13866                 }
13867               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13868               /* Zap the reloc on the _tls_get_addr call too.  */
13869               BFD_ASSERT (offset == rel[1].r_offset);
13870               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13871               insn3 = bfd_get_32 (output_bfd,
13872                                   contents + offset + 4);
13873               if (insn3 == NOP
13874                   || insn3 == CROR_151515 || insn3 == CROR_313131)
13875                 {
13876                   rel->r_offset += 4;
13877                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13878                   insn2 = NOP;
13879                 }
13880               bfd_put_32 (output_bfd, insn2, contents + offset);
13881               if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
13882                 goto again;
13883             }
13884           break;
13885
13886         case R_PPC64_TLSLD:
13887           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13888             {
13889               unsigned int insn2, insn3;
13890               bfd_vma offset = rel->r_offset;
13891
13892               if (toc_symndx)
13893                 sec = local_sections[toc_symndx];
13894               for (r_symndx = 0;
13895                    r_symndx < symtab_hdr->sh_info;
13896                    r_symndx++)
13897                 if (local_sections[r_symndx] == sec)
13898                   break;
13899               if (r_symndx >= symtab_hdr->sh_info)
13900                 r_symndx = STN_UNDEF;
13901               rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13902               if (r_symndx != STN_UNDEF)
13903                 rel->r_addend -= (local_syms[r_symndx].st_value
13904                                   + sec->output_offset
13905                                   + sec->output_section->vma);
13906
13907               r_type = R_PPC64_TPREL16_LO;
13908               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13909               rel->r_offset = offset + d_offset;
13910               /* Zap the reloc on the _tls_get_addr call too.  */
13911               BFD_ASSERT (offset == rel[1].r_offset);
13912               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13913               insn2 = 0x38630000;       /* addi 3,3,0 */
13914               insn3 = bfd_get_32 (output_bfd,
13915                                   contents + offset + 4);
13916               if (insn3 == NOP
13917                   || insn3 == CROR_151515 || insn3 == CROR_313131)
13918                 {
13919                   rel->r_offset += 4;
13920                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13921                   insn2 = NOP;
13922                 }
13923               bfd_put_32 (output_bfd, insn2, contents + offset);
13924               goto again;
13925             }
13926           break;
13927
13928         case R_PPC64_DTPMOD64:
13929           if (rel + 1 < relend
13930               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
13931               && rel[1].r_offset == rel->r_offset + 8)
13932             {
13933               if ((tls_mask & TLS_GD) == 0)
13934                 {
13935                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
13936                   if ((tls_mask & TLS_TPRELGD) != 0)
13937                     r_type = R_PPC64_TPREL64;
13938                   else
13939                     {
13940                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13941                       r_type = R_PPC64_NONE;
13942                     }
13943                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13944                 }
13945             }
13946           else
13947             {
13948               if ((tls_mask & TLS_LD) == 0)
13949                 {
13950                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13951                   r_type = R_PPC64_NONE;
13952                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13953                 }
13954             }
13955           break;
13956
13957         case R_PPC64_TPREL64:
13958           if ((tls_mask & TLS_TPREL) == 0)
13959             {
13960               r_type = R_PPC64_NONE;
13961               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13962             }
13963           break;
13964
13965         case R_PPC64_ENTRY:
13966           relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
13967           if (!bfd_link_pic (info)
13968               && !info->traditional_format
13969               && relocation + 0x80008000 <= 0xffffffff)
13970             {
13971               unsigned int insn1, insn2;
13972
13973               insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
13974               insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
13975               if ((insn1 & ~0xfffc) == LD_R2_0R12
13976                   && insn2 == ADD_R2_R2_R12)
13977                 {
13978                   bfd_put_32 (output_bfd,
13979                               LIS_R2 + PPC_HA (relocation),
13980                               contents + rel->r_offset);
13981                   bfd_put_32 (output_bfd,
13982                               ADDI_R2_R2 + PPC_LO (relocation),
13983                               contents + rel->r_offset + 4);
13984                 }
13985             }
13986           else
13987             {
13988               relocation -= (rel->r_offset
13989                              + input_section->output_offset
13990                              + input_section->output_section->vma);
13991               if (relocation + 0x80008000 <= 0xffffffff)
13992                 {
13993                   unsigned int insn1, insn2;
13994
13995                   insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
13996                   insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
13997                   if ((insn1 & ~0xfffc) == LD_R2_0R12
13998                       && insn2 == ADD_R2_R2_R12)
13999                     {
14000                       bfd_put_32 (output_bfd,
14001                                   ADDIS_R2_R12 + PPC_HA (relocation),
14002                                   contents + rel->r_offset);
14003                       bfd_put_32 (output_bfd,
14004                                   ADDI_R2_R2 + PPC_LO (relocation),
14005                                   contents + rel->r_offset + 4);
14006                     }
14007                 }
14008             }
14009           break;
14010
14011         case R_PPC64_REL16_HA:
14012           /* If we are generating a non-PIC executable, edit
14013              .  0:      addis 2,12,.TOC.-0b@ha
14014              .          addi 2,2,.TOC.-0b@l
14015              used by ELFv2 global entry points to set up r2, to
14016              .          lis 2,.TOC.@ha
14017              .          addi 2,2,.TOC.@l
14018              if .TOC. is in range.  */
14019           if (!bfd_link_pic (info)
14020               && !info->traditional_format
14021               && !htab->opd_abi
14022               && rel->r_addend == d_offset
14023               && h != NULL && &h->elf == htab->elf.hgot
14024               && rel + 1 < relend
14025               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
14026               && rel[1].r_offset == rel->r_offset + 4
14027               && rel[1].r_addend == rel->r_addend + 4
14028               && relocation + 0x80008000 <= 0xffffffff)
14029             {
14030               unsigned int insn1, insn2;
14031               bfd_vma offset = rel->r_offset - d_offset;
14032               insn1 = bfd_get_32 (output_bfd, contents + offset);
14033               insn2 = bfd_get_32 (output_bfd, contents + offset + 4);
14034               if ((insn1 & 0xffff0000) == ADDIS_R2_R12
14035                   && (insn2 & 0xffff0000) == ADDI_R2_R2)
14036                 {
14037                   r_type = R_PPC64_ADDR16_HA;
14038                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14039                   rel->r_addend -= d_offset;
14040                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
14041                   rel[1].r_addend -= d_offset + 4;
14042                   bfd_put_32 (output_bfd, LIS_R2, contents + offset);
14043                 }
14044             }
14045           break;
14046         }
14047
14048       /* Handle other relocations that tweak non-addend part of insn.  */
14049       insn = 0;
14050       max_br_offset = 1 << 25;
14051       addend = rel->r_addend;
14052       reloc_dest = DEST_NORMAL;
14053       switch (r_type)
14054         {
14055         default:
14056           break;
14057
14058         case R_PPC64_TOCSAVE:
14059           if (relocation + addend == (rel->r_offset
14060                                       + input_section->output_offset
14061                                       + input_section->output_section->vma)
14062               && tocsave_find (htab, NO_INSERT,
14063                                &local_syms, rel, input_bfd))
14064             {
14065               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
14066               if (insn == NOP
14067                   || insn == CROR_151515 || insn == CROR_313131)
14068                 bfd_put_32 (input_bfd,
14069                             STD_R2_0R1 + STK_TOC (htab),
14070                             contents + rel->r_offset);
14071             }
14072           break;
14073
14074           /* Branch taken prediction relocations.  */
14075         case R_PPC64_ADDR14_BRTAKEN:
14076         case R_PPC64_REL14_BRTAKEN:
14077           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
14078           /* Fall through.  */
14079
14080           /* Branch not taken prediction relocations.  */
14081         case R_PPC64_ADDR14_BRNTAKEN:
14082         case R_PPC64_REL14_BRNTAKEN:
14083           insn |= bfd_get_32 (output_bfd,
14084                               contents + rel->r_offset) & ~(0x01 << 21);
14085           /* Fall through.  */
14086
14087         case R_PPC64_REL14:
14088           max_br_offset = 1 << 15;
14089           /* Fall through.  */
14090
14091         case R_PPC64_REL24:
14092           /* Calls to functions with a different TOC, such as calls to
14093              shared objects, need to alter the TOC pointer.  This is
14094              done using a linkage stub.  A REL24 branching to these
14095              linkage stubs needs to be followed by a nop, as the nop
14096              will be replaced with an instruction to restore the TOC
14097              base pointer.  */
14098           fdh = h;
14099           if (h != NULL
14100               && h->oh != NULL
14101               && h->oh->is_func_descriptor)
14102             fdh = ppc_follow_link (h->oh);
14103           stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
14104                                            htab);
14105           if (stub_entry != NULL
14106               && (stub_entry->stub_type == ppc_stub_plt_call
14107                   || stub_entry->stub_type == ppc_stub_plt_call_r2save
14108                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
14109                   || stub_entry->stub_type == ppc_stub_long_branch_r2off))
14110             {
14111               bfd_boolean can_plt_call = FALSE;
14112
14113               /* All of these stubs will modify r2, so there must be a
14114                  branch and link followed by a nop.  The nop is
14115                  replaced by an insn to restore r2.  */
14116               if (rel->r_offset + 8 <= input_section->size)
14117                 {
14118                   unsigned long br;
14119
14120                   br = bfd_get_32 (input_bfd,
14121                                    contents + rel->r_offset);
14122                   if ((br & 1) != 0)
14123                     {
14124                       unsigned long nop;
14125
14126                       nop = bfd_get_32 (input_bfd,
14127                                         contents + rel->r_offset + 4);
14128                       if (nop == NOP
14129                           || nop == CROR_151515 || nop == CROR_313131)
14130                         {
14131                           if (h != NULL
14132                               && (h == htab->tls_get_addr_fd
14133                                   || h == htab->tls_get_addr)
14134                               && htab->params->tls_get_addr_opt)
14135                             {
14136                               /* Special stub used, leave nop alone.  */
14137                             }
14138                           else
14139                             bfd_put_32 (input_bfd,
14140                                         LD_R2_0R1 + STK_TOC (htab),
14141                                         contents + rel->r_offset + 4);
14142                           can_plt_call = TRUE;
14143                         }
14144                     }
14145                 }
14146
14147               if (!can_plt_call && h != NULL)
14148                 {
14149                   const char *name = h->elf.root.root.string;
14150
14151                   if (*name == '.')
14152                     ++name;
14153
14154                   if (strncmp (name, "__libc_start_main", 17) == 0
14155                       && (name[17] == 0 || name[17] == '@'))
14156                     {
14157                       /* Allow crt1 branch to go via a toc adjusting
14158                          stub.  Other calls that never return could do
14159                          the same, if we could detect such.  */
14160                       can_plt_call = TRUE;
14161                     }
14162                 }
14163
14164               if (!can_plt_call)
14165                 {
14166                   /* g++ as of 20130507 emits self-calls without a
14167                      following nop.  This is arguably wrong since we
14168                      have conflicting information.  On the one hand a
14169                      global symbol and on the other a local call
14170                      sequence, but don't error for this special case.
14171                      It isn't possible to cheaply verify we have
14172                      exactly such a call.  Allow all calls to the same
14173                      section.  */
14174                   asection *code_sec = sec;
14175
14176                   if (get_opd_info (sec) != NULL)
14177                     {
14178                       bfd_vma off = (relocation + addend
14179                                      - sec->output_section->vma
14180                                      - sec->output_offset);
14181
14182                       opd_entry_value (sec, off, &code_sec, NULL, FALSE);
14183                     }
14184                   if (code_sec == input_section)
14185                     can_plt_call = TRUE;
14186                 }
14187
14188               if (!can_plt_call)
14189                 {
14190                   if (stub_entry->stub_type == ppc_stub_plt_call
14191                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14192                     info->callbacks->einfo
14193                       (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
14194                          "recompile with -fPIC\n"),
14195                        input_bfd, input_section, rel->r_offset, sym_name);
14196                   else
14197                     info->callbacks->einfo
14198                       (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
14199                          "(-mcmodel=small toc adjust stub)\n"),
14200                        input_bfd, input_section, rel->r_offset, sym_name);
14201
14202                   bfd_set_error (bfd_error_bad_value);
14203                   ret = FALSE;
14204                 }
14205
14206               if (can_plt_call
14207                   && (stub_entry->stub_type == ppc_stub_plt_call
14208                       || stub_entry->stub_type == ppc_stub_plt_call_r2save))
14209                 unresolved_reloc = FALSE;
14210             }
14211
14212           if ((stub_entry == NULL
14213                || stub_entry->stub_type == ppc_stub_long_branch
14214                || stub_entry->stub_type == ppc_stub_plt_branch)
14215               && get_opd_info (sec) != NULL)
14216             {
14217               /* The branch destination is the value of the opd entry. */
14218               bfd_vma off = (relocation + addend
14219                              - sec->output_section->vma
14220                              - sec->output_offset);
14221               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
14222               if (dest != (bfd_vma) -1)
14223                 {
14224                   relocation = dest;
14225                   addend = 0;
14226                   reloc_dest = DEST_OPD;
14227                 }
14228             }
14229
14230           /* If the branch is out of reach we ought to have a long
14231              branch stub.  */
14232           from = (rel->r_offset
14233                   + input_section->output_offset
14234                   + input_section->output_section->vma);
14235
14236           relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
14237                                                   ? fdh->elf.other
14238                                                   : sym->st_other);
14239
14240           if (stub_entry != NULL
14241               && (stub_entry->stub_type == ppc_stub_long_branch
14242                   || stub_entry->stub_type == ppc_stub_plt_branch)
14243               && (r_type == R_PPC64_ADDR14_BRTAKEN
14244                   || r_type == R_PPC64_ADDR14_BRNTAKEN
14245                   || (relocation + addend - from + max_br_offset
14246                       < 2 * max_br_offset)))
14247             /* Don't use the stub if this branch is in range.  */
14248             stub_entry = NULL;
14249
14250           if (stub_entry != NULL)
14251             {
14252               /* Munge up the value and addend so that we call the stub
14253                  rather than the procedure directly.  */
14254               asection *stub_sec = stub_entry->group->stub_sec;
14255
14256               if (stub_entry->stub_type == ppc_stub_save_res)
14257                 relocation += (stub_sec->output_offset
14258                                + stub_sec->output_section->vma
14259                                + stub_sec->size - htab->sfpr->size
14260                                - htab->sfpr->output_offset
14261                                - htab->sfpr->output_section->vma);
14262               else
14263                 relocation = (stub_entry->stub_offset
14264                               + stub_sec->output_offset
14265                               + stub_sec->output_section->vma);
14266               addend = 0;
14267               reloc_dest = DEST_STUB;
14268
14269               if ((stub_entry->stub_type == ppc_stub_plt_call
14270                    || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14271                   && (ALWAYS_EMIT_R2SAVE
14272                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14273                   && rel + 1 < relend
14274                   && rel[1].r_offset == rel->r_offset + 4
14275                   && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
14276                 relocation += 4;
14277             }
14278
14279           if (insn != 0)
14280             {
14281               if (is_isa_v2)
14282                 {
14283                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
14284                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
14285                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
14286                   if ((insn & (0x14 << 21)) == (0x04 << 21))
14287                     insn |= 0x02 << 21;
14288                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
14289                     insn |= 0x08 << 21;
14290                   else
14291                     break;
14292                 }
14293               else
14294                 {
14295                   /* Invert 'y' bit if not the default.  */
14296                   if ((bfd_signed_vma) (relocation + addend - from) < 0)
14297                     insn ^= 0x01 << 21;
14298                 }
14299
14300               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
14301             }
14302
14303           /* NOP out calls to undefined weak functions.
14304              We can thus call a weak function without first
14305              checking whether the function is defined.  */
14306           else if (h != NULL
14307                    && h->elf.root.type == bfd_link_hash_undefweak
14308                    && h->elf.dynindx == -1
14309                    && r_type == R_PPC64_REL24
14310                    && relocation == 0
14311                    && addend == 0)
14312             {
14313               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
14314               goto copy_reloc;
14315             }
14316           break;
14317         }
14318
14319       /* Set `addend'.  */
14320       tls_type = 0;
14321       switch (r_type)
14322         {
14323         default:
14324           info->callbacks->einfo
14325             (_("%P: %B: unknown relocation type %d for `%T'\n"),
14326              input_bfd, (int) r_type, sym_name);
14327
14328           bfd_set_error (bfd_error_bad_value);
14329           ret = FALSE;
14330           goto copy_reloc;
14331
14332         case R_PPC64_NONE:
14333         case R_PPC64_TLS:
14334         case R_PPC64_TLSGD:
14335         case R_PPC64_TLSLD:
14336         case R_PPC64_TOCSAVE:
14337         case R_PPC64_GNU_VTINHERIT:
14338         case R_PPC64_GNU_VTENTRY:
14339         case R_PPC64_ENTRY:
14340           goto copy_reloc;
14341
14342           /* GOT16 relocations.  Like an ADDR16 using the symbol's
14343              address in the GOT as relocation value instead of the
14344              symbol's value itself.  Also, create a GOT entry for the
14345              symbol and put the symbol value there.  */
14346         case R_PPC64_GOT_TLSGD16:
14347         case R_PPC64_GOT_TLSGD16_LO:
14348         case R_PPC64_GOT_TLSGD16_HI:
14349         case R_PPC64_GOT_TLSGD16_HA:
14350           tls_type = TLS_TLS | TLS_GD;
14351           goto dogot;
14352
14353         case R_PPC64_GOT_TLSLD16:
14354         case R_PPC64_GOT_TLSLD16_LO:
14355         case R_PPC64_GOT_TLSLD16_HI:
14356         case R_PPC64_GOT_TLSLD16_HA:
14357           tls_type = TLS_TLS | TLS_LD;
14358           goto dogot;
14359
14360         case R_PPC64_GOT_TPREL16_DS:
14361         case R_PPC64_GOT_TPREL16_LO_DS:
14362         case R_PPC64_GOT_TPREL16_HI:
14363         case R_PPC64_GOT_TPREL16_HA:
14364           tls_type = TLS_TLS | TLS_TPREL;
14365           goto dogot;
14366
14367         case R_PPC64_GOT_DTPREL16_DS:
14368         case R_PPC64_GOT_DTPREL16_LO_DS:
14369         case R_PPC64_GOT_DTPREL16_HI:
14370         case R_PPC64_GOT_DTPREL16_HA:
14371           tls_type = TLS_TLS | TLS_DTPREL;
14372           goto dogot;
14373
14374         case R_PPC64_GOT16:
14375         case R_PPC64_GOT16_LO:
14376         case R_PPC64_GOT16_HI:
14377         case R_PPC64_GOT16_HA:
14378         case R_PPC64_GOT16_DS:
14379         case R_PPC64_GOT16_LO_DS:
14380         dogot:
14381           {
14382             /* Relocation is to the entry for this symbol in the global
14383                offset table.  */
14384             asection *got;
14385             bfd_vma *offp;
14386             bfd_vma off;
14387             unsigned long indx = 0;
14388             struct got_entry *ent;
14389
14390             if (tls_type == (TLS_TLS | TLS_LD)
14391                 && (h == NULL
14392                     || !h->elf.def_dynamic))
14393               ent = ppc64_tlsld_got (input_bfd);
14394             else
14395               {
14396
14397                 if (h != NULL)
14398                   {
14399                     bfd_boolean dyn = htab->elf.dynamic_sections_created;
14400                     if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info),
14401                                                           &h->elf)
14402                         || (bfd_link_pic (info)
14403                             && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
14404                       /* This is actually a static link, or it is a
14405                          -Bsymbolic link and the symbol is defined
14406                          locally, or the symbol was forced to be local
14407                          because of a version file.  */
14408                       ;
14409                     else
14410                       {
14411                         BFD_ASSERT (h->elf.dynindx != -1);
14412                         indx = h->elf.dynindx;
14413                         unresolved_reloc = FALSE;
14414                       }
14415                     ent = h->elf.got.glist;
14416                   }
14417                 else
14418                   {
14419                     if (local_got_ents == NULL)
14420                       abort ();
14421                     ent = local_got_ents[r_symndx];
14422                   }
14423
14424                 for (; ent != NULL; ent = ent->next)
14425                   if (ent->addend == orig_rel.r_addend
14426                       && ent->owner == input_bfd
14427                       && ent->tls_type == tls_type)
14428                     break;
14429               }
14430
14431             if (ent == NULL)
14432               abort ();
14433             if (ent->is_indirect)
14434               ent = ent->got.ent;
14435             offp = &ent->got.offset;
14436             got = ppc64_elf_tdata (ent->owner)->got;
14437             if (got == NULL)
14438               abort ();
14439
14440             /* The offset must always be a multiple of 8.  We use the
14441                least significant bit to record whether we have already
14442                processed this entry.  */
14443             off = *offp;
14444             if ((off & 1) != 0)
14445               off &= ~1;
14446             else
14447               {
14448                 /* Generate relocs for the dynamic linker, except in
14449                    the case of TLSLD where we'll use one entry per
14450                    module.  */
14451                 asection *relgot;
14452                 bfd_boolean ifunc;
14453
14454                 *offp = off | 1;
14455                 relgot = NULL;
14456                 ifunc = (h != NULL
14457                          ? h->elf.type == STT_GNU_IFUNC
14458                          : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
14459                 if (ifunc)
14460                   relgot = htab->elf.irelplt;
14461                 else if ((bfd_link_pic (info) || indx != 0)
14462                          && (h == NULL
14463                              || (tls_type == (TLS_TLS | TLS_LD)
14464                                  && !h->elf.def_dynamic)
14465                              || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14466                              || h->elf.root.type != bfd_link_hash_undefweak))
14467                   relgot = ppc64_elf_tdata (ent->owner)->relgot;
14468                 if (relgot != NULL)
14469                   {
14470                     outrel.r_offset = (got->output_section->vma
14471                                        + got->output_offset
14472                                        + off);
14473                     outrel.r_addend = addend;
14474                     if (tls_type & (TLS_LD | TLS_GD))
14475                       {
14476                         outrel.r_addend = 0;
14477                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
14478                         if (tls_type == (TLS_TLS | TLS_GD))
14479                           {
14480                             loc = relgot->contents;
14481                             loc += (relgot->reloc_count++
14482                                     * sizeof (Elf64_External_Rela));
14483                             bfd_elf64_swap_reloca_out (output_bfd,
14484                                                        &outrel, loc);
14485                             outrel.r_offset += 8;
14486                             outrel.r_addend = addend;
14487                             outrel.r_info
14488                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14489                           }
14490                       }
14491                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
14492                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14493                     else if (tls_type == (TLS_TLS | TLS_TPREL))
14494                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
14495                     else if (indx != 0)
14496                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
14497                     else
14498                       {
14499                         if (ifunc)
14500                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14501                         else
14502                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14503
14504                         /* Write the .got section contents for the sake
14505                            of prelink.  */
14506                         loc = got->contents + off;
14507                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
14508                                     loc);
14509                       }
14510
14511                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
14512                       {
14513                         outrel.r_addend += relocation;
14514                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
14515                           {
14516                             if (htab->elf.tls_sec == NULL)
14517                               outrel.r_addend = 0;
14518                             else
14519                               outrel.r_addend -= htab->elf.tls_sec->vma;
14520                           }
14521                       }
14522                     loc = relgot->contents;
14523                     loc += (relgot->reloc_count++
14524                             * sizeof (Elf64_External_Rela));
14525                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14526                   }
14527
14528                 /* Init the .got section contents here if we're not
14529                    emitting a reloc.  */
14530                 else
14531                   {
14532                     relocation += addend;
14533                     if (tls_type == (TLS_TLS | TLS_LD))
14534                       relocation = 1;
14535                     else if (tls_type != 0)
14536                       {
14537                         if (htab->elf.tls_sec == NULL)
14538                           relocation = 0;
14539                         else
14540                           {
14541                             relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
14542                             if (tls_type == (TLS_TLS | TLS_TPREL))
14543                               relocation += DTP_OFFSET - TP_OFFSET;
14544                           }
14545
14546                         if (tls_type == (TLS_TLS | TLS_GD))
14547                           {
14548                             bfd_put_64 (output_bfd, relocation,
14549                                         got->contents + off + 8);
14550                             relocation = 1;
14551                           }
14552                       }
14553
14554                     bfd_put_64 (output_bfd, relocation,
14555                                 got->contents + off);
14556                   }
14557               }
14558
14559             if (off >= (bfd_vma) -2)
14560               abort ();
14561
14562             relocation = got->output_section->vma + got->output_offset + off;
14563             addend = -(TOCstart + htab->sec_info[input_section->id].toc_off);
14564           }
14565           break;
14566
14567         case R_PPC64_PLT16_HA:
14568         case R_PPC64_PLT16_HI:
14569         case R_PPC64_PLT16_LO:
14570         case R_PPC64_PLT32:
14571         case R_PPC64_PLT64:
14572           /* Relocation is to the entry for this symbol in the
14573              procedure linkage table.  */
14574           {
14575             struct plt_entry **plt_list = NULL;
14576             if (h != NULL)
14577               plt_list = &h->elf.plt.plist;
14578             else if (local_got_ents != NULL)
14579               {
14580                 struct plt_entry **local_plt = (struct plt_entry **)
14581                   (local_got_ents + symtab_hdr->sh_info);
14582                 unsigned char *local_got_tls_masks = (unsigned char *)
14583                   (local_plt + symtab_hdr->sh_info);
14584                 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
14585                   plt_list = local_plt + r_symndx;
14586               }
14587             if (plt_list)
14588               {
14589                 struct plt_entry *ent;
14590
14591                 for (ent = *plt_list; ent != NULL; ent = ent->next)
14592                   if (ent->plt.offset != (bfd_vma) -1
14593                       && ent->addend == orig_rel.r_addend)
14594                     {
14595                       asection *plt;
14596
14597                       plt = htab->elf.splt;
14598                       if (!htab->elf.dynamic_sections_created
14599                           || h == NULL
14600                           || h->elf.dynindx == -1)
14601                         plt = htab->elf.iplt;
14602                       relocation = (plt->output_section->vma
14603                                     + plt->output_offset
14604                                     + ent->plt.offset);
14605                       addend = 0;
14606                       unresolved_reloc = FALSE;
14607                       break;
14608                     }
14609               }
14610           }
14611           break;
14612
14613         case R_PPC64_TOC:
14614           /* Relocation value is TOC base.  */
14615           relocation = TOCstart;
14616           if (r_symndx == STN_UNDEF)
14617             relocation += htab->sec_info[input_section->id].toc_off;
14618           else if (unresolved_reloc)
14619             ;
14620           else if (sec != NULL && sec->id < htab->sec_info_arr_size)
14621             relocation += htab->sec_info[sec->id].toc_off;
14622           else
14623             unresolved_reloc = TRUE;
14624           goto dodyn;
14625
14626           /* TOC16 relocs.  We want the offset relative to the TOC base,
14627              which is the address of the start of the TOC plus 0x8000.
14628              The TOC consists of sections .got, .toc, .tocbss, and .plt,
14629              in this order.  */
14630         case R_PPC64_TOC16:
14631         case R_PPC64_TOC16_LO:
14632         case R_PPC64_TOC16_HI:
14633         case R_PPC64_TOC16_DS:
14634         case R_PPC64_TOC16_LO_DS:
14635         case R_PPC64_TOC16_HA:
14636           addend -= TOCstart + htab->sec_info[input_section->id].toc_off;
14637           break;
14638
14639           /* Relocate against the beginning of the section.  */
14640         case R_PPC64_SECTOFF:
14641         case R_PPC64_SECTOFF_LO:
14642         case R_PPC64_SECTOFF_HI:
14643         case R_PPC64_SECTOFF_DS:
14644         case R_PPC64_SECTOFF_LO_DS:
14645         case R_PPC64_SECTOFF_HA:
14646           if (sec != NULL)
14647             addend -= sec->output_section->vma;
14648           break;
14649
14650         case R_PPC64_REL16:
14651         case R_PPC64_REL16_LO:
14652         case R_PPC64_REL16_HI:
14653         case R_PPC64_REL16_HA:
14654         case R_PPC64_REL16DX_HA:
14655           break;
14656
14657         case R_PPC64_REL14:
14658         case R_PPC64_REL14_BRNTAKEN:
14659         case R_PPC64_REL14_BRTAKEN:
14660         case R_PPC64_REL24:
14661           break;
14662
14663         case R_PPC64_TPREL16:
14664         case R_PPC64_TPREL16_LO:
14665         case R_PPC64_TPREL16_HI:
14666         case R_PPC64_TPREL16_HA:
14667         case R_PPC64_TPREL16_DS:
14668         case R_PPC64_TPREL16_LO_DS:
14669         case R_PPC64_TPREL16_HIGH:
14670         case R_PPC64_TPREL16_HIGHA:
14671         case R_PPC64_TPREL16_HIGHER:
14672         case R_PPC64_TPREL16_HIGHERA:
14673         case R_PPC64_TPREL16_HIGHEST:
14674         case R_PPC64_TPREL16_HIGHESTA:
14675           if (h != NULL
14676               && h->elf.root.type == bfd_link_hash_undefweak
14677               && h->elf.dynindx == -1)
14678             {
14679               /* Make this relocation against an undefined weak symbol
14680                  resolve to zero.  This is really just a tweak, since
14681                  code using weak externs ought to check that they are
14682                  defined before using them.  */
14683               bfd_byte *p = contents + rel->r_offset - d_offset;
14684
14685               insn = bfd_get_32 (output_bfd, p);
14686               insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14687               if (insn != 0)
14688                 bfd_put_32 (output_bfd, insn, p);
14689               break;
14690             }
14691           if (htab->elf.tls_sec != NULL)
14692             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14693           if (bfd_link_pic (info))
14694             /* The TPREL16 relocs shouldn't really be used in shared
14695                libs as they will result in DT_TEXTREL being set, but
14696                support them anyway.  */
14697             goto dodyn;
14698           break;
14699
14700         case R_PPC64_DTPREL16:
14701         case R_PPC64_DTPREL16_LO:
14702         case R_PPC64_DTPREL16_HI:
14703         case R_PPC64_DTPREL16_HA:
14704         case R_PPC64_DTPREL16_DS:
14705         case R_PPC64_DTPREL16_LO_DS:
14706         case R_PPC64_DTPREL16_HIGH:
14707         case R_PPC64_DTPREL16_HIGHA:
14708         case R_PPC64_DTPREL16_HIGHER:
14709         case R_PPC64_DTPREL16_HIGHERA:
14710         case R_PPC64_DTPREL16_HIGHEST:
14711         case R_PPC64_DTPREL16_HIGHESTA:
14712           if (htab->elf.tls_sec != NULL)
14713             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14714           break;
14715
14716         case R_PPC64_ADDR64_LOCAL:
14717           addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
14718                                               ? h->elf.other
14719                                               : sym->st_other);
14720           break;
14721
14722         case R_PPC64_DTPMOD64:
14723           relocation = 1;
14724           addend = 0;
14725           goto dodyn;
14726
14727         case R_PPC64_TPREL64:
14728           if (htab->elf.tls_sec != NULL)
14729             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14730           goto dodyn;
14731
14732         case R_PPC64_DTPREL64:
14733           if (htab->elf.tls_sec != NULL)
14734             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14735           /* Fall through.  */
14736
14737           /* Relocations that may need to be propagated if this is a
14738              dynamic object.  */
14739         case R_PPC64_REL30:
14740         case R_PPC64_REL32:
14741         case R_PPC64_REL64:
14742         case R_PPC64_ADDR14:
14743         case R_PPC64_ADDR14_BRNTAKEN:
14744         case R_PPC64_ADDR14_BRTAKEN:
14745         case R_PPC64_ADDR16:
14746         case R_PPC64_ADDR16_DS:
14747         case R_PPC64_ADDR16_HA:
14748         case R_PPC64_ADDR16_HI:
14749         case R_PPC64_ADDR16_HIGH:
14750         case R_PPC64_ADDR16_HIGHA:
14751         case R_PPC64_ADDR16_HIGHER:
14752         case R_PPC64_ADDR16_HIGHERA:
14753         case R_PPC64_ADDR16_HIGHEST:
14754         case R_PPC64_ADDR16_HIGHESTA:
14755         case R_PPC64_ADDR16_LO:
14756         case R_PPC64_ADDR16_LO_DS:
14757         case R_PPC64_ADDR24:
14758         case R_PPC64_ADDR32:
14759         case R_PPC64_ADDR64:
14760         case R_PPC64_UADDR16:
14761         case R_PPC64_UADDR32:
14762         case R_PPC64_UADDR64:
14763         dodyn:
14764           if ((input_section->flags & SEC_ALLOC) == 0)
14765             break;
14766
14767           if (NO_OPD_RELOCS && is_opd)
14768             break;
14769
14770           if (bfd_link_pic (info)
14771               ? ((h != NULL && pc_dynrelocs (h))
14772                  || must_be_dyn_reloc (info, r_type))
14773               : (h != NULL
14774                  ? h->dyn_relocs != NULL
14775                  : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14776             {
14777               bfd_boolean skip, relocate;
14778               asection *sreloc;
14779               bfd_vma out_off;
14780
14781               /* When generating a dynamic object, these relocations
14782                  are copied into the output file to be resolved at run
14783                  time.  */
14784
14785               skip = FALSE;
14786               relocate = FALSE;
14787
14788               out_off = _bfd_elf_section_offset (output_bfd, info,
14789                                                  input_section, rel->r_offset);
14790               if (out_off == (bfd_vma) -1)
14791                 skip = TRUE;
14792               else if (out_off == (bfd_vma) -2)
14793                 skip = TRUE, relocate = TRUE;
14794               out_off += (input_section->output_section->vma
14795                           + input_section->output_offset);
14796               outrel.r_offset = out_off;
14797               outrel.r_addend = rel->r_addend;
14798
14799               /* Optimize unaligned reloc use.  */
14800               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14801                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14802                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14803               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14804                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
14805                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
14806               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
14807                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
14808                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
14809
14810               if (skip)
14811                 memset (&outrel, 0, sizeof outrel);
14812               else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14813                        && !is_opd
14814                        && r_type != R_PPC64_TOC)
14815                 {
14816                   BFD_ASSERT (h->elf.dynindx != -1);
14817                   outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
14818                 }
14819               else
14820                 {
14821                   /* This symbol is local, or marked to become local,
14822                      or this is an opd section reloc which must point
14823                      at a local function.  */
14824                   outrel.r_addend += relocation;
14825                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
14826                     {
14827                       if (is_opd && h != NULL)
14828                         {
14829                           /* Lie about opd entries.  This case occurs
14830                              when building shared libraries and we
14831                              reference a function in another shared
14832                              lib.  The same thing happens for a weak
14833                              definition in an application that's
14834                              overridden by a strong definition in a
14835                              shared lib.  (I believe this is a generic
14836                              bug in binutils handling of weak syms.)
14837                              In these cases we won't use the opd
14838                              entry in this lib.  */
14839                           unresolved_reloc = FALSE;
14840                         }
14841                       if (!is_opd
14842                           && r_type == R_PPC64_ADDR64
14843                           && (h != NULL
14844                               ? h->elf.type == STT_GNU_IFUNC
14845                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14846                         outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14847                       else
14848                         {
14849                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14850
14851                           /* We need to relocate .opd contents for ld.so.
14852                              Prelink also wants simple and consistent rules
14853                              for relocs.  This make all RELATIVE relocs have
14854                              *r_offset equal to r_addend.  */
14855                           relocate = TRUE;
14856                         }
14857                     }
14858                   else
14859                     {
14860                       long indx = 0;
14861
14862                       if (h != NULL
14863                           ? h->elf.type == STT_GNU_IFUNC
14864                           : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14865                         {
14866                           info->callbacks->einfo
14867                             (_("%P: %H: %s for indirect "
14868                                "function `%T' unsupported\n"),
14869                              input_bfd, input_section, rel->r_offset,
14870                              ppc64_elf_howto_table[r_type]->name,
14871                              sym_name);
14872                           ret = FALSE;
14873                         }
14874                       else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
14875                         ;
14876                       else if (sec == NULL || sec->owner == NULL)
14877                         {
14878                           bfd_set_error (bfd_error_bad_value);
14879                           return FALSE;
14880                         }
14881                       else
14882                         {
14883                           asection *osec;
14884
14885                           osec = sec->output_section;
14886                           indx = elf_section_data (osec)->dynindx;
14887
14888                           if (indx == 0)
14889                             {
14890                               if ((osec->flags & SEC_READONLY) == 0
14891                                   && htab->elf.data_index_section != NULL)
14892                                 osec = htab->elf.data_index_section;
14893                               else
14894                                 osec = htab->elf.text_index_section;
14895                               indx = elf_section_data (osec)->dynindx;
14896                             }
14897                           BFD_ASSERT (indx != 0);
14898
14899                           /* We are turning this relocation into one
14900                              against a section symbol, so subtract out
14901                              the output section's address but not the
14902                              offset of the input section in the output
14903                              section.  */
14904                           outrel.r_addend -= osec->vma;
14905                         }
14906
14907                       outrel.r_info = ELF64_R_INFO (indx, r_type);
14908                     }
14909                 }
14910
14911               sreloc = elf_section_data (input_section)->sreloc;
14912               if (h != NULL
14913                   ? h->elf.type == STT_GNU_IFUNC
14914                   : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14915                 sreloc = htab->elf.irelplt;
14916               if (sreloc == NULL)
14917                 abort ();
14918
14919               if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
14920                   >= sreloc->size)
14921                 abort ();
14922               loc = sreloc->contents;
14923               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
14924               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14925
14926               /* If this reloc is against an external symbol, it will
14927                  be computed at runtime, so there's no need to do
14928                  anything now.  However, for the sake of prelink ensure
14929                  that the section contents are a known value.  */
14930               if (! relocate)
14931                 {
14932                   unresolved_reloc = FALSE;
14933                   /* The value chosen here is quite arbitrary as ld.so
14934                      ignores section contents except for the special
14935                      case of .opd where the contents might be accessed
14936                      before relocation.  Choose zero, as that won't
14937                      cause reloc overflow.  */
14938                   relocation = 0;
14939                   addend = 0;
14940                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
14941                      to improve backward compatibility with older
14942                      versions of ld.  */
14943                   if (r_type == R_PPC64_ADDR64)
14944                     addend = outrel.r_addend;
14945                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
14946                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
14947                     addend = (input_section->output_section->vma
14948                               + input_section->output_offset
14949                               + rel->r_offset);
14950                 }
14951             }
14952           break;
14953
14954         case R_PPC64_COPY:
14955         case R_PPC64_GLOB_DAT:
14956         case R_PPC64_JMP_SLOT:
14957         case R_PPC64_JMP_IREL:
14958         case R_PPC64_RELATIVE:
14959           /* We shouldn't ever see these dynamic relocs in relocatable
14960              files.  */
14961           /* Fall through.  */
14962
14963         case R_PPC64_PLTGOT16:
14964         case R_PPC64_PLTGOT16_DS:
14965         case R_PPC64_PLTGOT16_HA:
14966         case R_PPC64_PLTGOT16_HI:
14967         case R_PPC64_PLTGOT16_LO:
14968         case R_PPC64_PLTGOT16_LO_DS:
14969         case R_PPC64_PLTREL32:
14970         case R_PPC64_PLTREL64:
14971           /* These ones haven't been implemented yet.  */
14972
14973           info->callbacks->einfo
14974             (_("%P: %B: %s is not supported for `%T'\n"),
14975              input_bfd,
14976              ppc64_elf_howto_table[r_type]->name, sym_name);
14977
14978           bfd_set_error (bfd_error_invalid_operation);
14979           ret = FALSE;
14980           goto copy_reloc;
14981         }
14982
14983       /* Multi-instruction sequences that access the TOC can be
14984          optimized, eg. addis ra,r2,0; addi rb,ra,x;
14985          to             nop;           addi rb,r2,x;  */
14986       switch (r_type)
14987         {
14988         default:
14989           break;
14990
14991         case R_PPC64_GOT_TLSLD16_HI:
14992         case R_PPC64_GOT_TLSGD16_HI:
14993         case R_PPC64_GOT_TPREL16_HI:
14994         case R_PPC64_GOT_DTPREL16_HI:
14995         case R_PPC64_GOT16_HI:
14996         case R_PPC64_TOC16_HI:
14997           /* These relocs would only be useful if building up an
14998              offset to later add to r2, perhaps in an indexed
14999              addressing mode instruction.  Don't try to optimize.
15000              Unfortunately, the possibility of someone building up an
15001              offset like this or even with the HA relocs, means that
15002              we need to check the high insn when optimizing the low
15003              insn.  */
15004           break;
15005
15006         case R_PPC64_GOT_TLSLD16_HA:
15007         case R_PPC64_GOT_TLSGD16_HA:
15008         case R_PPC64_GOT_TPREL16_HA:
15009         case R_PPC64_GOT_DTPREL16_HA:
15010         case R_PPC64_GOT16_HA:
15011         case R_PPC64_TOC16_HA:
15012           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
15013               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
15014             {
15015               bfd_byte *p = contents + (rel->r_offset & ~3);
15016               bfd_put_32 (input_bfd, NOP, p);
15017             }
15018           break;
15019
15020         case R_PPC64_GOT_TLSLD16_LO:
15021         case R_PPC64_GOT_TLSGD16_LO:
15022         case R_PPC64_GOT_TPREL16_LO_DS:
15023         case R_PPC64_GOT_DTPREL16_LO_DS:
15024         case R_PPC64_GOT16_LO:
15025         case R_PPC64_GOT16_LO_DS:
15026         case R_PPC64_TOC16_LO:
15027         case R_PPC64_TOC16_LO_DS:
15028           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
15029               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
15030             {
15031               bfd_byte *p = contents + (rel->r_offset & ~3);
15032               insn = bfd_get_32 (input_bfd, p);
15033               if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
15034                 {
15035                   /* Transform addic to addi when we change reg.  */
15036                   insn &= ~((0x3f << 26) | (0x1f << 16));
15037                   insn |= (14u << 26) | (2 << 16);
15038                 }
15039               else
15040                 {
15041                   insn &= ~(0x1f << 16);
15042                   insn |= 2 << 16;
15043                 }
15044               bfd_put_32 (input_bfd, insn, p);
15045             }
15046           break;
15047         }
15048
15049       /* Do any further special processing.  */
15050       howto = ppc64_elf_howto_table[(int) r_type];
15051       switch (r_type)
15052         {
15053         default:
15054           break;
15055
15056         case R_PPC64_REL16_HA:
15057         case R_PPC64_REL16DX_HA:
15058         case R_PPC64_ADDR16_HA:
15059         case R_PPC64_ADDR16_HIGHA:
15060         case R_PPC64_ADDR16_HIGHERA:
15061         case R_PPC64_ADDR16_HIGHESTA:
15062         case R_PPC64_TOC16_HA:
15063         case R_PPC64_SECTOFF_HA:
15064         case R_PPC64_TPREL16_HA:
15065         case R_PPC64_TPREL16_HIGHA:
15066         case R_PPC64_TPREL16_HIGHERA:
15067         case R_PPC64_TPREL16_HIGHESTA:
15068         case R_PPC64_DTPREL16_HA:
15069         case R_PPC64_DTPREL16_HIGHA:
15070         case R_PPC64_DTPREL16_HIGHERA:
15071         case R_PPC64_DTPREL16_HIGHESTA:
15072           /* It's just possible that this symbol is a weak symbol
15073              that's not actually defined anywhere. In that case,
15074              'sec' would be NULL, and we should leave the symbol
15075              alone (it will be set to zero elsewhere in the link).  */
15076           if (sec == NULL)
15077             break;
15078           /* Fall through.  */
15079
15080         case R_PPC64_GOT16_HA:
15081         case R_PPC64_PLTGOT16_HA:
15082         case R_PPC64_PLT16_HA:
15083         case R_PPC64_GOT_TLSGD16_HA:
15084         case R_PPC64_GOT_TLSLD16_HA:
15085         case R_PPC64_GOT_TPREL16_HA:
15086         case R_PPC64_GOT_DTPREL16_HA:
15087           /* Add 0x10000 if sign bit in 0:15 is set.
15088              Bits 0:15 are not used.  */
15089           addend += 0x8000;
15090           break;
15091
15092         case R_PPC64_ADDR16_DS:
15093         case R_PPC64_ADDR16_LO_DS:
15094         case R_PPC64_GOT16_DS:
15095         case R_PPC64_GOT16_LO_DS:
15096         case R_PPC64_PLT16_LO_DS:
15097         case R_PPC64_SECTOFF_DS:
15098         case R_PPC64_SECTOFF_LO_DS:
15099         case R_PPC64_TOC16_DS:
15100         case R_PPC64_TOC16_LO_DS:
15101         case R_PPC64_PLTGOT16_DS:
15102         case R_PPC64_PLTGOT16_LO_DS:
15103         case R_PPC64_GOT_TPREL16_DS:
15104         case R_PPC64_GOT_TPREL16_LO_DS:
15105         case R_PPC64_GOT_DTPREL16_DS:
15106         case R_PPC64_GOT_DTPREL16_LO_DS:
15107         case R_PPC64_TPREL16_DS:
15108         case R_PPC64_TPREL16_LO_DS:
15109         case R_PPC64_DTPREL16_DS:
15110         case R_PPC64_DTPREL16_LO_DS:
15111           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15112           mask = 3;
15113           /* If this reloc is against an lq, lxv, or stxv insn, then
15114              the value must be a multiple of 16.  This is somewhat of
15115              a hack, but the "correct" way to do this by defining _DQ
15116              forms of all the _DS relocs bloats all reloc switches in
15117              this file.  It doesn't make much sense to use these
15118              relocs in data, so testing the insn should be safe.  */
15119           if ((insn & (0x3f << 26)) == (56u << 26)
15120               || ((insn & (0x3f << 26)) == (61u << 26) && (insn & 3) == 1))
15121             mask = 15;
15122           relocation += addend;
15123           addend = insn & (mask ^ 3);
15124           if ((relocation & mask) != 0)
15125             {
15126               relocation ^= relocation & mask;
15127               info->callbacks->einfo
15128                 (_("%P: %H: error: %s not a multiple of %u\n"),
15129                  input_bfd, input_section, rel->r_offset,
15130                  howto->name,
15131                  mask + 1);
15132               bfd_set_error (bfd_error_bad_value);
15133               ret = FALSE;
15134               goto copy_reloc;
15135             }
15136           break;
15137         }
15138
15139       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
15140          because such sections are not SEC_ALLOC and thus ld.so will
15141          not process them.  */
15142       if (unresolved_reloc
15143           && !((input_section->flags & SEC_DEBUGGING) != 0
15144                && h->elf.def_dynamic)
15145           && _bfd_elf_section_offset (output_bfd, info, input_section,
15146                                       rel->r_offset) != (bfd_vma) -1)
15147         {
15148           info->callbacks->einfo
15149             (_("%P: %H: unresolvable %s against `%T'\n"),
15150              input_bfd, input_section, rel->r_offset,
15151              howto->name,
15152              h->elf.root.root.string);
15153           ret = FALSE;
15154         }
15155
15156       /* 16-bit fields in insns mostly have signed values, but a
15157          few insns have 16-bit unsigned values.  Really, we should
15158          have different reloc types.  */
15159       if (howto->complain_on_overflow != complain_overflow_dont
15160           && howto->dst_mask == 0xffff
15161           && (input_section->flags & SEC_CODE) != 0)
15162         {
15163           enum complain_overflow complain = complain_overflow_signed;
15164
15165           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15166           if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
15167             complain = complain_overflow_bitfield;
15168           else if (howto->rightshift == 0
15169                    ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
15170                       || (insn & (0x3f << 26)) == 24u << 26 /* ori */
15171                       || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
15172                    : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
15173                       || (insn & (0x3f << 26)) == 25u << 26 /* oris */
15174                       || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
15175             complain = complain_overflow_unsigned;
15176           if (howto->complain_on_overflow != complain)
15177             {
15178               alt_howto = *howto;
15179               alt_howto.complain_on_overflow = complain;
15180               howto = &alt_howto;
15181             }
15182         }
15183
15184       if (r_type == R_PPC64_REL16DX_HA)
15185         {
15186           /* Split field reloc isn't handled by _bfd_final_link_relocate.  */
15187           if (rel->r_offset + 4 > input_section->size)
15188             r = bfd_reloc_outofrange;
15189           else
15190             {
15191               relocation += addend;
15192               relocation -= (rel->r_offset
15193                              + input_section->output_offset
15194                              + input_section->output_section->vma);
15195               relocation = (bfd_signed_vma) relocation >> 16;
15196               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
15197               insn &= ~0x1fffc1;
15198               insn |= (relocation & 0xffc1) | ((relocation & 0x3e) << 15);
15199               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
15200               r = bfd_reloc_ok;
15201               if (relocation + 0x8000 > 0xffff)
15202                 r = bfd_reloc_overflow;
15203             }
15204         }
15205       else
15206         r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
15207                                       rel->r_offset, relocation, addend);
15208
15209       if (r != bfd_reloc_ok)
15210         {
15211           char *more_info = NULL;
15212           const char *reloc_name = howto->name;
15213
15214           if (reloc_dest != DEST_NORMAL)
15215             {
15216               more_info = bfd_malloc (strlen (reloc_name) + 8);
15217               if (more_info != NULL)
15218                 {
15219                   strcpy (more_info, reloc_name);
15220                   strcat (more_info, (reloc_dest == DEST_OPD
15221                                       ? " (OPD)" : " (stub)"));
15222                   reloc_name = more_info;
15223                 }
15224             }
15225
15226           if (r == bfd_reloc_overflow)
15227             {
15228               /* On code like "if (foo) foo();" don't report overflow
15229                  on a branch to zero when foo is undefined.  */
15230               if (!warned
15231                   && (reloc_dest == DEST_STUB
15232                       || !(h != NULL
15233                            && (h->elf.root.type == bfd_link_hash_undefweak
15234                                || h->elf.root.type == bfd_link_hash_undefined)
15235                            && is_branch_reloc (r_type))))
15236                 info->callbacks->reloc_overflow (info, &h->elf.root,
15237                                                  sym_name, reloc_name,
15238                                                  orig_rel.r_addend,
15239                                                  input_bfd, input_section,
15240                                                  rel->r_offset);
15241             }
15242           else
15243             {
15244               info->callbacks->einfo
15245                 (_("%P: %H: %s against `%T': error %d\n"),
15246                  input_bfd, input_section, rel->r_offset,
15247                  reloc_name, sym_name, (int) r);
15248               ret = FALSE;
15249             }
15250           if (more_info != NULL)
15251             free (more_info);
15252         }
15253     copy_reloc:
15254       if (wrel != rel)
15255         *wrel = *rel;
15256     }
15257
15258   if (wrel != rel)
15259     {
15260       Elf_Internal_Shdr *rel_hdr;
15261       size_t deleted = rel - wrel;
15262
15263       rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
15264       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15265       if (rel_hdr->sh_size == 0)
15266         {
15267           /* It is too late to remove an empty reloc section.  Leave
15268              one NONE reloc.
15269              ??? What is wrong with an empty section???  */
15270           rel_hdr->sh_size = rel_hdr->sh_entsize;
15271           deleted -= 1;
15272         }
15273       rel_hdr = _bfd_elf_single_rel_hdr (input_section);
15274       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15275       input_section->reloc_count -= deleted;
15276     }
15277
15278   /* If we're emitting relocations, then shortly after this function
15279      returns, reloc offsets and addends for this section will be
15280      adjusted.  Worse, reloc symbol indices will be for the output
15281      file rather than the input.  Save a copy of the relocs for
15282      opd_entry_value.  */
15283   if (is_opd && (info->emitrelocations || bfd_link_relocatable (info)))
15284     {
15285       bfd_size_type amt;
15286       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
15287       rel = bfd_alloc (input_bfd, amt);
15288       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
15289       ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
15290       if (rel == NULL)
15291         return FALSE;
15292       memcpy (rel, relocs, amt);
15293     }
15294   return ret;
15295 }
15296
15297 /* Adjust the value of any local symbols in opd sections.  */
15298
15299 static int
15300 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
15301                               const char *name ATTRIBUTE_UNUSED,
15302                               Elf_Internal_Sym *elfsym,
15303                               asection *input_sec,
15304                               struct elf_link_hash_entry *h)
15305 {
15306   struct _opd_sec_data *opd;
15307   long adjust;
15308   bfd_vma value;
15309
15310   if (h != NULL)
15311     return 1;
15312
15313   opd = get_opd_info (input_sec);
15314   if (opd == NULL || opd->adjust == NULL)
15315     return 1;
15316
15317   value = elfsym->st_value - input_sec->output_offset;
15318   if (!bfd_link_relocatable (info))
15319     value -= input_sec->output_section->vma;
15320
15321   adjust = opd->adjust[OPD_NDX (value)];
15322   if (adjust == -1)
15323     return 2;
15324
15325   elfsym->st_value += adjust;
15326   return 1;
15327 }
15328
15329 /* Finish up dynamic symbol handling.  We set the contents of various
15330    dynamic sections here.  */
15331
15332 static bfd_boolean
15333 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
15334                                  struct bfd_link_info *info,
15335                                  struct elf_link_hash_entry *h,
15336                                  Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
15337 {
15338   struct ppc_link_hash_table *htab;
15339   struct plt_entry *ent;
15340   Elf_Internal_Rela rela;
15341   bfd_byte *loc;
15342
15343   htab = ppc_hash_table (info);
15344   if (htab == NULL)
15345     return FALSE;
15346
15347   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
15348     if (ent->plt.offset != (bfd_vma) -1)
15349       {
15350         /* This symbol has an entry in the procedure linkage
15351            table.  Set it up.  */
15352         if (!htab->elf.dynamic_sections_created
15353             || h->dynindx == -1)
15354           {
15355             BFD_ASSERT (h->type == STT_GNU_IFUNC
15356                         && h->def_regular
15357                         && (h->root.type == bfd_link_hash_defined
15358                             || h->root.type == bfd_link_hash_defweak));
15359             rela.r_offset = (htab->elf.iplt->output_section->vma
15360                              + htab->elf.iplt->output_offset
15361                              + ent->plt.offset);
15362             if (htab->opd_abi)
15363               rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
15364             else
15365               rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15366             rela.r_addend = (h->root.u.def.value
15367                              + h->root.u.def.section->output_offset
15368                              + h->root.u.def.section->output_section->vma
15369                              + ent->addend);
15370             loc = (htab->elf.irelplt->contents
15371                    + (htab->elf.irelplt->reloc_count++
15372                       * sizeof (Elf64_External_Rela)));
15373           }
15374         else
15375           {
15376             rela.r_offset = (htab->elf.splt->output_section->vma
15377                              + htab->elf.splt->output_offset
15378                              + ent->plt.offset);
15379             rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
15380             rela.r_addend = ent->addend;
15381             loc = (htab->elf.srelplt->contents
15382                    + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
15383                       / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
15384           }
15385         bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15386
15387         if (!htab->opd_abi)
15388           {
15389             if (!h->def_regular)
15390               {
15391                 /* Mark the symbol as undefined, rather than as
15392                    defined in glink.  Leave the value if there were
15393                    any relocations where pointer equality matters
15394                    (this is a clue for the dynamic linker, to make
15395                    function pointer comparisons work between an
15396                    application and shared library), otherwise set it
15397                    to zero.  */
15398                 sym->st_shndx = SHN_UNDEF;
15399                 if (!h->pointer_equality_needed)
15400                   sym->st_value = 0;
15401                 else if (!h->ref_regular_nonweak)
15402                   {
15403                     /* This breaks function pointer comparisons, but
15404                        that is better than breaking tests for a NULL
15405                        function pointer.  */
15406                     sym->st_value = 0;
15407                   }
15408               }
15409           }
15410       }
15411
15412   if (h->needs_copy)
15413     {
15414       /* This symbol needs a copy reloc.  Set it up.  */
15415
15416       if (h->dynindx == -1
15417           || (h->root.type != bfd_link_hash_defined
15418               && h->root.type != bfd_link_hash_defweak)
15419           || htab->relbss == NULL)
15420         abort ();
15421
15422       rela.r_offset = (h->root.u.def.value
15423                        + h->root.u.def.section->output_section->vma
15424                        + h->root.u.def.section->output_offset);
15425       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
15426       rela.r_addend = 0;
15427       loc = htab->relbss->contents;
15428       loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
15429       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15430     }
15431
15432   return TRUE;
15433 }
15434
15435 /* Used to decide how to sort relocs in an optimal manner for the
15436    dynamic linker, before writing them out.  */
15437
15438 static enum elf_reloc_type_class
15439 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
15440                             const asection *rel_sec,
15441                             const Elf_Internal_Rela *rela)
15442 {
15443   enum elf_ppc64_reloc_type r_type;
15444   struct ppc_link_hash_table *htab = ppc_hash_table (info);
15445
15446   if (rel_sec == htab->elf.irelplt)
15447     return reloc_class_ifunc;
15448
15449   r_type = ELF64_R_TYPE (rela->r_info);
15450   switch (r_type)
15451     {
15452     case R_PPC64_RELATIVE:
15453       return reloc_class_relative;
15454     case R_PPC64_JMP_SLOT:
15455       return reloc_class_plt;
15456     case R_PPC64_COPY:
15457       return reloc_class_copy;
15458     default:
15459       return reloc_class_normal;
15460     }
15461 }
15462
15463 /* Finish up the dynamic sections.  */
15464
15465 static bfd_boolean
15466 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
15467                                    struct bfd_link_info *info)
15468 {
15469   struct ppc_link_hash_table *htab;
15470   bfd *dynobj;
15471   asection *sdyn;
15472
15473   htab = ppc_hash_table (info);
15474   if (htab == NULL)
15475     return FALSE;
15476
15477   dynobj = htab->elf.dynobj;
15478   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
15479
15480   if (htab->elf.dynamic_sections_created)
15481     {
15482       Elf64_External_Dyn *dyncon, *dynconend;
15483
15484       if (sdyn == NULL || htab->elf.sgot == NULL)
15485         abort ();
15486
15487       dyncon = (Elf64_External_Dyn *) sdyn->contents;
15488       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
15489       for (; dyncon < dynconend; dyncon++)
15490         {
15491           Elf_Internal_Dyn dyn;
15492           asection *s;
15493
15494           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
15495
15496           switch (dyn.d_tag)
15497             {
15498             default:
15499               continue;
15500
15501             case DT_PPC64_GLINK:
15502               s = htab->glink;
15503               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15504               /* We stupidly defined DT_PPC64_GLINK to be the start
15505                  of glink rather than the first entry point, which is
15506                  what ld.so needs, and now have a bigger stub to
15507                  support automatic multiple TOCs.  */
15508               dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
15509               break;
15510
15511             case DT_PPC64_OPD:
15512               s = bfd_get_section_by_name (output_bfd, ".opd");
15513               if (s == NULL)
15514                 continue;
15515               dyn.d_un.d_ptr = s->vma;
15516               break;
15517
15518             case DT_PPC64_OPT:
15519               if (htab->do_multi_toc && htab->multi_toc_needed)
15520                 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
15521               break;
15522
15523             case DT_PPC64_OPDSZ:
15524               s = bfd_get_section_by_name (output_bfd, ".opd");
15525               if (s == NULL)
15526                 continue;
15527               dyn.d_un.d_val = s->size;
15528               break;
15529
15530             case DT_PLTGOT:
15531               s = htab->elf.splt;
15532               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15533               break;
15534
15535             case DT_JMPREL:
15536               s = htab->elf.srelplt;
15537               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15538               break;
15539
15540             case DT_PLTRELSZ:
15541               dyn.d_un.d_val = htab->elf.srelplt->size;
15542               break;
15543
15544             case DT_RELASZ:
15545               /* Don't count procedure linkage table relocs in the
15546                  overall reloc count.  */
15547               s = htab->elf.srelplt;
15548               if (s == NULL)
15549                 continue;
15550               dyn.d_un.d_val -= s->size;
15551               break;
15552
15553             case DT_RELA:
15554               /* We may not be using the standard ELF linker script.
15555                  If .rela.plt is the first .rela section, we adjust
15556                  DT_RELA to not include it.  */
15557               s = htab->elf.srelplt;
15558               if (s == NULL)
15559                 continue;
15560               if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
15561                 continue;
15562               dyn.d_un.d_ptr += s->size;
15563               break;
15564             }
15565
15566           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
15567         }
15568     }
15569
15570   if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0)
15571     {
15572       /* Fill in the first entry in the global offset table.
15573          We use it to hold the link-time TOCbase.  */
15574       bfd_put_64 (output_bfd,
15575                   elf_gp (output_bfd) + TOC_BASE_OFF,
15576                   htab->elf.sgot->contents);
15577
15578       /* Set .got entry size.  */
15579       elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
15580     }
15581
15582   if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
15583     {
15584       /* Set .plt entry size.  */
15585       elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
15586         = PLT_ENTRY_SIZE (htab);
15587     }
15588
15589   /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
15590      brlt ourselves if emitrelocations.  */
15591   if (htab->brlt != NULL
15592       && htab->brlt->reloc_count != 0
15593       && !_bfd_elf_link_output_relocs (output_bfd,
15594                                        htab->brlt,
15595                                        elf_section_data (htab->brlt)->rela.hdr,
15596                                        elf_section_data (htab->brlt)->relocs,
15597                                        NULL))
15598     return FALSE;
15599
15600   if (htab->glink != NULL
15601       && htab->glink->reloc_count != 0
15602       && !_bfd_elf_link_output_relocs (output_bfd,
15603                                        htab->glink,
15604                                        elf_section_data (htab->glink)->rela.hdr,
15605                                        elf_section_data (htab->glink)->relocs,
15606                                        NULL))
15607     return FALSE;
15608
15609   if (htab->glink_eh_frame != NULL
15610       && htab->glink_eh_frame->size != 0)
15611     {
15612       bfd_vma val;
15613       bfd_byte *p;
15614       asection *stub_sec;
15615
15616       p = htab->glink_eh_frame->contents + sizeof (glink_eh_frame_cie);
15617       for (stub_sec = htab->params->stub_bfd->sections;
15618            stub_sec != NULL;
15619            stub_sec = stub_sec->next)
15620         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
15621           {
15622             /* FDE length.  */
15623             p += 4;
15624             /* CIE pointer.  */
15625             p += 4;
15626             /* Offset to stub section.  */
15627             val = (stub_sec->output_section->vma
15628                    + stub_sec->output_offset);
15629             val -= (htab->glink_eh_frame->output_section->vma
15630                     + htab->glink_eh_frame->output_offset
15631                     + (p - htab->glink_eh_frame->contents));
15632             if (val + 0x80000000 > 0xffffffff)
15633               {
15634                 info->callbacks->einfo
15635                   (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15636                    stub_sec->name);
15637                 return FALSE;
15638               }
15639             bfd_put_32 (dynobj, val, p);
15640             p += 4;
15641             /* stub section size.  */
15642             p += 4;
15643             /* Augmentation.  */
15644             p += 1;
15645             /* Pad.  */
15646             p += 7;
15647           }
15648       if (htab->glink != NULL && htab->glink->size != 0)
15649         {
15650           /* FDE length.  */
15651           p += 4;
15652           /* CIE pointer.  */
15653           p += 4;
15654           /* Offset to .glink.  */
15655           val = (htab->glink->output_section->vma
15656                  + htab->glink->output_offset
15657                  + 8);
15658           val -= (htab->glink_eh_frame->output_section->vma
15659                   + htab->glink_eh_frame->output_offset
15660                   + (p - htab->glink_eh_frame->contents));
15661           if (val + 0x80000000 > 0xffffffff)
15662             {
15663               info->callbacks->einfo
15664                 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15665                  htab->glink->name);
15666               return FALSE;
15667             }
15668           bfd_put_32 (dynobj, val, p);
15669           p += 4;
15670           /* .glink size.  */
15671           p += 4;
15672           /* Augmentation.  */
15673           p += 1;
15674           /* Ops.  */
15675           p += 7;
15676         }
15677
15678       if (htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
15679           && !_bfd_elf_write_section_eh_frame (output_bfd, info,
15680                                                htab->glink_eh_frame,
15681                                                htab->glink_eh_frame->contents))
15682         return FALSE;
15683     }
15684
15685   /* We need to handle writing out multiple GOT sections ourselves,
15686      since we didn't add them to DYNOBJ.  We know dynobj is the first
15687      bfd.  */
15688   while ((dynobj = dynobj->link.next) != NULL)
15689     {
15690       asection *s;
15691
15692       if (!is_ppc64_elf (dynobj))
15693         continue;
15694
15695       s = ppc64_elf_tdata (dynobj)->got;
15696       if (s != NULL
15697           && s->size != 0
15698           && s->output_section != bfd_abs_section_ptr
15699           && !bfd_set_section_contents (output_bfd, s->output_section,
15700                                         s->contents, s->output_offset,
15701                                         s->size))
15702         return FALSE;
15703       s = ppc64_elf_tdata (dynobj)->relgot;
15704       if (s != NULL
15705           && s->size != 0
15706           && s->output_section != bfd_abs_section_ptr
15707           && !bfd_set_section_contents (output_bfd, s->output_section,
15708                                         s->contents, s->output_offset,
15709                                         s->size))
15710         return FALSE;
15711     }
15712
15713   return TRUE;
15714 }
15715
15716 #include "elf64-target.h"
15717
15718 /* FreeBSD support */
15719
15720 #undef  TARGET_LITTLE_SYM
15721 #undef  TARGET_LITTLE_NAME
15722
15723 #undef  TARGET_BIG_SYM
15724 #define TARGET_BIG_SYM  powerpc_elf64_fbsd_vec
15725 #undef  TARGET_BIG_NAME
15726 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15727
15728 #undef  ELF_OSABI
15729 #define ELF_OSABI       ELFOSABI_FREEBSD
15730
15731 #undef  elf64_bed
15732 #define elf64_bed       elf64_powerpc_fbsd_bed
15733
15734 #include "elf64-target.h"
15735