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       /* xgettext:c-format */
2494       _bfd_error_handler (_("%B: invalid relocation type %d"),
2495                           abfd, (int) type);
2496       type = R_PPC64_NONE;
2497     }
2498   cache_ptr->howto = ppc64_elf_howto_table[type];
2499 }
2500
2501 /* Handle the R_PPC64_ADDR16_HA and similar relocs.  */
2502
2503 static bfd_reloc_status_type
2504 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2505                     void *data, asection *input_section,
2506                     bfd *output_bfd, char **error_message)
2507 {
2508   enum elf_ppc64_reloc_type r_type;
2509   long insn;
2510   bfd_size_type octets;
2511   bfd_vma value;
2512
2513   /* If this is a relocatable link (output_bfd test tells us), just
2514      call the generic function.  Any adjustment will be done at final
2515      link time.  */
2516   if (output_bfd != NULL)
2517     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2518                                   input_section, output_bfd, error_message);
2519
2520   /* Adjust the addend for sign extension of the low 16 bits.
2521      We won't actually be using the low 16 bits, so trashing them
2522      doesn't matter.  */
2523   reloc_entry->addend += 0x8000;
2524   r_type = reloc_entry->howto->type;
2525   if (r_type != R_PPC64_REL16DX_HA)
2526     return bfd_reloc_continue;
2527
2528   value = 0;
2529   if (!bfd_is_com_section (symbol->section))
2530     value = symbol->value;
2531   value += (reloc_entry->addend
2532             + symbol->section->output_offset
2533             + symbol->section->output_section->vma);
2534   value -= (reloc_entry->address
2535             + input_section->output_offset
2536             + input_section->output_section->vma);
2537   value = (bfd_signed_vma) value >> 16;
2538
2539   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2540   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2541   insn &= ~0x1fffc1;
2542   insn |= (value & 0xffc1) | ((value & 0x3e) << 15);
2543   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2544   if (value + 0x8000 > 0xffff)
2545     return bfd_reloc_overflow;
2546   return bfd_reloc_ok;
2547 }
2548
2549 static bfd_reloc_status_type
2550 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2551                         void *data, asection *input_section,
2552                         bfd *output_bfd, char **error_message)
2553 {
2554   if (output_bfd != NULL)
2555     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2556                                   input_section, output_bfd, error_message);
2557
2558   if (strcmp (symbol->section->name, ".opd") == 0
2559       && (symbol->section->owner->flags & DYNAMIC) == 0)
2560     {
2561       bfd_vma dest = opd_entry_value (symbol->section,
2562                                       symbol->value + reloc_entry->addend,
2563                                       NULL, NULL, FALSE);
2564       if (dest != (bfd_vma) -1)
2565         reloc_entry->addend = dest - (symbol->value
2566                                       + symbol->section->output_section->vma
2567                                       + symbol->section->output_offset);
2568     }
2569   else
2570     {
2571       elf_symbol_type *elfsym = (elf_symbol_type *) symbol;
2572
2573       if (symbol->section->owner != abfd
2574           && symbol->section->owner != NULL
2575           && abiversion (symbol->section->owner) >= 2)
2576         {
2577           unsigned int i;
2578
2579           for (i = 0; i < symbol->section->owner->symcount; ++i)
2580             {
2581               asymbol *symdef = symbol->section->owner->outsymbols[i];
2582
2583               if (strcmp (symdef->name, symbol->name) == 0)
2584                 {
2585                   elfsym = (elf_symbol_type *) symdef;
2586                   break;
2587                 }
2588             }
2589         }
2590       reloc_entry->addend
2591         += PPC64_LOCAL_ENTRY_OFFSET (elfsym->internal_elf_sym.st_other);
2592     }
2593   return bfd_reloc_continue;
2594 }
2595
2596 static bfd_reloc_status_type
2597 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2598                          void *data, asection *input_section,
2599                          bfd *output_bfd, char **error_message)
2600 {
2601   long insn;
2602   enum elf_ppc64_reloc_type r_type;
2603   bfd_size_type octets;
2604   /* Assume 'at' branch hints.  */
2605   bfd_boolean is_isa_v2 = TRUE;
2606
2607   /* If this is a relocatable link (output_bfd test tells us), just
2608      call the generic function.  Any adjustment will be done at final
2609      link time.  */
2610   if (output_bfd != NULL)
2611     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2612                                   input_section, output_bfd, error_message);
2613
2614   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2615   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2616   insn &= ~(0x01 << 21);
2617   r_type = reloc_entry->howto->type;
2618   if (r_type == R_PPC64_ADDR14_BRTAKEN
2619       || r_type == R_PPC64_REL14_BRTAKEN)
2620     insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
2621
2622   if (is_isa_v2)
2623     {
2624       /* Set 'a' bit.  This is 0b00010 in BO field for branch
2625          on CR(BI) insns (BO == 001at or 011at), and 0b01000
2626          for branch on CTR insns (BO == 1a00t or 1a01t).  */
2627       if ((insn & (0x14 << 21)) == (0x04 << 21))
2628         insn |= 0x02 << 21;
2629       else if ((insn & (0x14 << 21)) == (0x10 << 21))
2630         insn |= 0x08 << 21;
2631       else
2632         goto out;
2633     }
2634   else
2635     {
2636       bfd_vma target = 0;
2637       bfd_vma from;
2638
2639       if (!bfd_is_com_section (symbol->section))
2640         target = symbol->value;
2641       target += symbol->section->output_section->vma;
2642       target += symbol->section->output_offset;
2643       target += reloc_entry->addend;
2644
2645       from = (reloc_entry->address
2646               + input_section->output_offset
2647               + input_section->output_section->vma);
2648
2649       /* Invert 'y' bit if not the default.  */
2650       if ((bfd_signed_vma) (target - from) < 0)
2651         insn ^= 0x01 << 21;
2652     }
2653   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2654  out:
2655   return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2656                                  input_section, output_bfd, error_message);
2657 }
2658
2659 static bfd_reloc_status_type
2660 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2661                          void *data, asection *input_section,
2662                          bfd *output_bfd, char **error_message)
2663 {
2664   /* If this is a relocatable link (output_bfd test tells us), just
2665      call the generic function.  Any adjustment will be done at final
2666      link time.  */
2667   if (output_bfd != NULL)
2668     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2669                                   input_section, output_bfd, error_message);
2670
2671   /* Subtract the symbol section base address.  */
2672   reloc_entry->addend -= symbol->section->output_section->vma;
2673   return bfd_reloc_continue;
2674 }
2675
2676 static bfd_reloc_status_type
2677 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2678                             void *data, asection *input_section,
2679                             bfd *output_bfd, char **error_message)
2680 {
2681   /* If this is a relocatable link (output_bfd test tells us), just
2682      call the generic function.  Any adjustment will be done at final
2683      link time.  */
2684   if (output_bfd != NULL)
2685     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2686                                   input_section, output_bfd, error_message);
2687
2688   /* Subtract the symbol section base address.  */
2689   reloc_entry->addend -= symbol->section->output_section->vma;
2690
2691   /* Adjust the addend for sign extension of the low 16 bits.  */
2692   reloc_entry->addend += 0x8000;
2693   return bfd_reloc_continue;
2694 }
2695
2696 static bfd_reloc_status_type
2697 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2698                      void *data, asection *input_section,
2699                      bfd *output_bfd, char **error_message)
2700 {
2701   bfd_vma TOCstart;
2702
2703   /* If this is a relocatable link (output_bfd test tells us), just
2704      call the generic function.  Any adjustment will be done at final
2705      link time.  */
2706   if (output_bfd != NULL)
2707     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2708                                   input_section, output_bfd, error_message);
2709
2710   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2711   if (TOCstart == 0)
2712     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2713
2714   /* Subtract the TOC base address.  */
2715   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2716   return bfd_reloc_continue;
2717 }
2718
2719 static bfd_reloc_status_type
2720 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2721                         void *data, asection *input_section,
2722                         bfd *output_bfd, char **error_message)
2723 {
2724   bfd_vma TOCstart;
2725
2726   /* If this is a relocatable link (output_bfd test tells us), just
2727      call the generic function.  Any adjustment will be done at final
2728      link time.  */
2729   if (output_bfd != NULL)
2730     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2731                                   input_section, output_bfd, error_message);
2732
2733   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2734   if (TOCstart == 0)
2735     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2736
2737   /* Subtract the TOC base address.  */
2738   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2739
2740   /* Adjust the addend for sign extension of the low 16 bits.  */
2741   reloc_entry->addend += 0x8000;
2742   return bfd_reloc_continue;
2743 }
2744
2745 static bfd_reloc_status_type
2746 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2747                        void *data, asection *input_section,
2748                        bfd *output_bfd, char **error_message)
2749 {
2750   bfd_vma TOCstart;
2751   bfd_size_type octets;
2752
2753   /* If this is a relocatable link (output_bfd test tells us), just
2754      call the generic function.  Any adjustment will be done at final
2755      link time.  */
2756   if (output_bfd != NULL)
2757     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2758                                   input_section, output_bfd, error_message);
2759
2760   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2761   if (TOCstart == 0)
2762     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2763
2764   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2765   bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2766   return bfd_reloc_ok;
2767 }
2768
2769 static bfd_reloc_status_type
2770 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2771                            void *data, asection *input_section,
2772                            bfd *output_bfd, char **error_message)
2773 {
2774   /* If this is a relocatable link (output_bfd test tells us), just
2775      call the generic function.  Any adjustment will be done at final
2776      link time.  */
2777   if (output_bfd != NULL)
2778     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2779                                   input_section, output_bfd, error_message);
2780
2781   if (error_message != NULL)
2782     {
2783       static char buf[60];
2784       sprintf (buf, "generic linker can't handle %s",
2785                reloc_entry->howto->name);
2786       *error_message = buf;
2787     }
2788   return bfd_reloc_dangerous;
2789 }
2790
2791 /* Track GOT entries needed for a given symbol.  We might need more
2792    than one got entry per symbol.  */
2793 struct got_entry
2794 {
2795   struct got_entry *next;
2796
2797   /* The symbol addend that we'll be placing in the GOT.  */
2798   bfd_vma addend;
2799
2800   /* Unlike other ELF targets, we use separate GOT entries for the same
2801      symbol referenced from different input files.  This is to support
2802      automatic multiple TOC/GOT sections, where the TOC base can vary
2803      from one input file to another.  After partitioning into TOC groups
2804      we merge entries within the group.
2805
2806      Point to the BFD owning this GOT entry.  */
2807   bfd *owner;
2808
2809   /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2810      TLS_TPREL or TLS_DTPREL for tls entries.  */
2811   unsigned char tls_type;
2812
2813   /* Non-zero if got.ent points to real entry.  */
2814   unsigned char is_indirect;
2815
2816   /* Reference count until size_dynamic_sections, GOT offset thereafter.  */
2817   union
2818     {
2819       bfd_signed_vma refcount;
2820       bfd_vma offset;
2821       struct got_entry *ent;
2822     } got;
2823 };
2824
2825 /* The same for PLT.  */
2826 struct plt_entry
2827 {
2828   struct plt_entry *next;
2829
2830   bfd_vma addend;
2831
2832   union
2833     {
2834       bfd_signed_vma refcount;
2835       bfd_vma offset;
2836     } plt;
2837 };
2838
2839 struct ppc64_elf_obj_tdata
2840 {
2841   struct elf_obj_tdata elf;
2842
2843   /* Shortcuts to dynamic linker sections.  */
2844   asection *got;
2845   asection *relgot;
2846
2847   /* Used during garbage collection.  We attach global symbols defined
2848      on removed .opd entries to this section so that the sym is removed.  */
2849   asection *deleted_section;
2850
2851   /* TLS local dynamic got entry handling.  Support for multiple GOT
2852      sections means we potentially need one of these for each input bfd.  */
2853   struct got_entry tlsld_got;
2854
2855   union {
2856     /* A copy of relocs before they are modified for --emit-relocs.  */
2857     Elf_Internal_Rela *relocs;
2858
2859     /* Section contents.  */
2860     bfd_byte *contents;
2861   } opd;
2862
2863   /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2864      the reloc to be in the range -32768 to 32767.  */
2865   unsigned int has_small_toc_reloc : 1;
2866
2867   /* Set if toc/got ha relocs detected not using r2, or lo reloc
2868      instruction not one we handle.  */
2869   unsigned int unexpected_toc_insn : 1;
2870 };
2871
2872 #define ppc64_elf_tdata(bfd) \
2873   ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2874
2875 #define ppc64_tlsld_got(bfd) \
2876   (&ppc64_elf_tdata (bfd)->tlsld_got)
2877
2878 #define is_ppc64_elf(bfd) \
2879   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2880    && elf_object_id (bfd) == PPC64_ELF_DATA)
2881
2882 /* Override the generic function because we store some extras.  */
2883
2884 static bfd_boolean
2885 ppc64_elf_mkobject (bfd *abfd)
2886 {
2887   return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2888                                   PPC64_ELF_DATA);
2889 }
2890
2891 /* Fix bad default arch selected for a 64 bit input bfd when the
2892    default is 32 bit.  Also select arch based on apuinfo.  */
2893
2894 static bfd_boolean
2895 ppc64_elf_object_p (bfd *abfd)
2896 {
2897   if (!abfd->arch_info->the_default)
2898     return TRUE;
2899
2900   if (abfd->arch_info->bits_per_word == 32)
2901     {
2902       Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2903
2904       if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2905         {
2906           /* Relies on arch after 32 bit default being 64 bit default.  */
2907           abfd->arch_info = abfd->arch_info->next;
2908           BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2909         }
2910     }
2911   return _bfd_elf_ppc_set_arch (abfd);
2912 }
2913
2914 /* Support for core dump NOTE sections.  */
2915
2916 static bfd_boolean
2917 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2918 {
2919   size_t offset, size;
2920
2921   if (note->descsz != 504)
2922     return FALSE;
2923
2924   /* pr_cursig */
2925   elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2926
2927   /* pr_pid */
2928   elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2929
2930   /* pr_reg */
2931   offset = 112;
2932   size = 384;
2933
2934   /* Make a ".reg/999" section.  */
2935   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2936                                           size, note->descpos + offset);
2937 }
2938
2939 static bfd_boolean
2940 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2941 {
2942   if (note->descsz != 136)
2943     return FALSE;
2944
2945   elf_tdata (abfd)->core->pid
2946     = bfd_get_32 (abfd, note->descdata + 24);
2947   elf_tdata (abfd)->core->program
2948     = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2949   elf_tdata (abfd)->core->command
2950     = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2951
2952   return TRUE;
2953 }
2954
2955 static char *
2956 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2957                            ...)
2958 {
2959   switch (note_type)
2960     {
2961     default:
2962       return NULL;
2963
2964     case NT_PRPSINFO:
2965       {
2966         char data[136];
2967         va_list ap;
2968
2969         va_start (ap, note_type);
2970         memset (data, 0, sizeof (data));
2971         strncpy (data + 40, va_arg (ap, const char *), 16);
2972         strncpy (data + 56, va_arg (ap, const char *), 80);
2973         va_end (ap);
2974         return elfcore_write_note (abfd, buf, bufsiz,
2975                                    "CORE", note_type, data, sizeof (data));
2976       }
2977
2978     case NT_PRSTATUS:
2979       {
2980         char data[504];
2981         va_list ap;
2982         long pid;
2983         int cursig;
2984         const void *greg;
2985
2986         va_start (ap, note_type);
2987         memset (data, 0, 112);
2988         pid = va_arg (ap, long);
2989         bfd_put_32 (abfd, pid, data + 32);
2990         cursig = va_arg (ap, int);
2991         bfd_put_16 (abfd, cursig, data + 12);
2992         greg = va_arg (ap, const void *);
2993         memcpy (data + 112, greg, 384);
2994         memset (data + 496, 0, 8);
2995         va_end (ap);
2996         return elfcore_write_note (abfd, buf, bufsiz,
2997                                    "CORE", note_type, data, sizeof (data));
2998       }
2999     }
3000 }
3001
3002 /* Add extra PPC sections.  */
3003
3004 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
3005 {
3006   { STRING_COMMA_LEN (".plt"),    0, SHT_NOBITS,   0 },
3007   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
3008   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3009   { STRING_COMMA_LEN (".toc"),    0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3010   { STRING_COMMA_LEN (".toc1"),   0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3011   { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
3012   { NULL,                     0,  0, 0,            0 }
3013 };
3014
3015 enum _ppc64_sec_type {
3016   sec_normal = 0,
3017   sec_opd = 1,
3018   sec_toc = 2
3019 };
3020
3021 struct _ppc64_elf_section_data
3022 {
3023   struct bfd_elf_section_data elf;
3024
3025   union
3026   {
3027     /* An array with one entry for each opd function descriptor,
3028        and some spares since opd entries may be either 16 or 24 bytes.  */
3029 #define OPD_NDX(OFF) ((OFF) >> 4)
3030     struct _opd_sec_data
3031     {
3032       /* Points to the function code section for local opd entries.  */
3033       asection **func_sec;
3034
3035       /* After editing .opd, adjust references to opd local syms.  */
3036       long *adjust;
3037     } opd;
3038
3039     /* An array for toc sections, indexed by offset/8.  */
3040     struct _toc_sec_data
3041     {
3042       /* Specifies the relocation symbol index used at a given toc offset.  */
3043       unsigned *symndx;
3044
3045       /* And the relocation addend.  */
3046       bfd_vma *add;
3047     } toc;
3048   } u;
3049
3050   enum _ppc64_sec_type sec_type:2;
3051
3052   /* Flag set when small branches are detected.  Used to
3053      select suitable defaults for the stub group size.  */
3054   unsigned int has_14bit_branch:1;
3055 };
3056
3057 #define ppc64_elf_section_data(sec) \
3058   ((struct _ppc64_elf_section_data *) elf_section_data (sec))
3059
3060 static bfd_boolean
3061 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
3062 {
3063   if (!sec->used_by_bfd)
3064     {
3065       struct _ppc64_elf_section_data *sdata;
3066       bfd_size_type amt = sizeof (*sdata);
3067
3068       sdata = bfd_zalloc (abfd, amt);
3069       if (sdata == NULL)
3070         return FALSE;
3071       sec->used_by_bfd = sdata;
3072     }
3073
3074   return _bfd_elf_new_section_hook (abfd, sec);
3075 }
3076
3077 static struct _opd_sec_data *
3078 get_opd_info (asection * sec)
3079 {
3080   if (sec != NULL
3081       && ppc64_elf_section_data (sec) != NULL
3082       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
3083     return &ppc64_elf_section_data (sec)->u.opd;
3084   return NULL;
3085 }
3086 \f
3087 /* Parameters for the qsort hook.  */
3088 static bfd_boolean synthetic_relocatable;
3089 static asection *synthetic_opd;
3090
3091 /* qsort comparison function for ppc64_elf_get_synthetic_symtab.  */
3092
3093 static int
3094 compare_symbols (const void *ap, const void *bp)
3095 {
3096   const asymbol *a = * (const asymbol **) ap;
3097   const asymbol *b = * (const asymbol **) bp;
3098
3099   /* Section symbols first.  */
3100   if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
3101     return -1;
3102   if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
3103     return 1;
3104
3105   /* then .opd symbols.  */
3106   if (synthetic_opd != NULL)
3107     {
3108       if (strcmp (a->section->name, ".opd") == 0
3109           && strcmp (b->section->name, ".opd") != 0)
3110         return -1;
3111       if (strcmp (a->section->name, ".opd") != 0
3112           && strcmp (b->section->name, ".opd") == 0)
3113         return 1;
3114     }
3115
3116   /* then other code symbols.  */
3117   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3118       == (SEC_CODE | SEC_ALLOC)
3119       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3120          != (SEC_CODE | SEC_ALLOC))
3121     return -1;
3122
3123   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3124       != (SEC_CODE | SEC_ALLOC)
3125       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3126          == (SEC_CODE | SEC_ALLOC))
3127     return 1;
3128
3129   if (synthetic_relocatable)
3130     {
3131       if (a->section->id < b->section->id)
3132         return -1;
3133
3134       if (a->section->id > b->section->id)
3135         return 1;
3136     }
3137
3138   if (a->value + a->section->vma < b->value + b->section->vma)
3139     return -1;
3140
3141   if (a->value + a->section->vma > b->value + b->section->vma)
3142     return 1;
3143
3144   /* For syms with the same value, prefer strong dynamic global function
3145      syms over other syms.  */
3146   if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3147     return -1;
3148
3149   if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3150     return 1;
3151
3152   if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3153     return -1;
3154
3155   if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3156     return 1;
3157
3158   if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3159     return -1;
3160
3161   if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3162     return 1;
3163
3164   if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3165     return -1;
3166
3167   if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3168     return 1;
3169
3170   return 0;
3171 }
3172
3173 /* Search SYMS for a symbol of the given VALUE.  */
3174
3175 static asymbol *
3176 sym_exists_at (asymbol **syms, long lo, long hi, unsigned int id, bfd_vma value)
3177 {
3178   long mid;
3179
3180   if (id == (unsigned) -1)
3181     {
3182       while (lo < hi)
3183         {
3184           mid = (lo + hi) >> 1;
3185           if (syms[mid]->value + syms[mid]->section->vma < value)
3186             lo = mid + 1;
3187           else if (syms[mid]->value + syms[mid]->section->vma > value)
3188             hi = mid;
3189           else
3190             return syms[mid];
3191         }
3192     }
3193   else
3194     {
3195       while (lo < hi)
3196         {
3197           mid = (lo + hi) >> 1;
3198           if (syms[mid]->section->id < id)
3199             lo = mid + 1;
3200           else if (syms[mid]->section->id > id)
3201             hi = mid;
3202           else if (syms[mid]->value < value)
3203             lo = mid + 1;
3204           else if (syms[mid]->value > value)
3205             hi = mid;
3206           else
3207             return syms[mid];
3208         }
3209     }
3210   return NULL;
3211 }
3212
3213 static bfd_boolean
3214 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3215 {
3216   bfd_vma vma = *(bfd_vma *) ptr;
3217   return ((section->flags & SEC_ALLOC) != 0
3218           && section->vma <= vma
3219           && vma < section->vma + section->size);
3220 }
3221
3222 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3223    entry syms.  Also generate @plt symbols for the glink branch table.
3224    Returns count of synthetic symbols in RET or -1 on error.  */
3225
3226 static long
3227 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3228                                 long static_count, asymbol **static_syms,
3229                                 long dyn_count, asymbol **dyn_syms,
3230                                 asymbol **ret)
3231 {
3232   asymbol *s;
3233   long i;
3234   long count;
3235   char *names;
3236   long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3237   asection *opd = NULL;
3238   bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3239   asymbol **syms;
3240   int abi = abiversion (abfd);
3241
3242   *ret = NULL;
3243
3244   if (abi < 2)
3245     {
3246       opd = bfd_get_section_by_name (abfd, ".opd");
3247       if (opd == NULL && abi == 1)
3248         return 0;
3249     }
3250
3251   symcount = static_count;
3252   if (!relocatable)
3253     symcount += dyn_count;
3254   if (symcount == 0)
3255     return 0;
3256
3257   syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3258   if (syms == NULL)
3259     return -1;
3260
3261   if (!relocatable && static_count != 0 && dyn_count != 0)
3262     {
3263       /* Use both symbol tables.  */
3264       memcpy (syms, static_syms, static_count * sizeof (*syms));
3265       memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3266     }
3267   else if (!relocatable && static_count == 0)
3268     memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3269   else
3270     memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3271
3272   synthetic_relocatable = relocatable;
3273   synthetic_opd = opd;
3274   qsort (syms, symcount, sizeof (*syms), compare_symbols);
3275
3276   if (!relocatable && symcount > 1)
3277     {
3278       long j;
3279       /* Trim duplicate syms, since we may have merged the normal and
3280          dynamic symbols.  Actually, we only care about syms that have
3281          different values, so trim any with the same value.  */
3282       for (i = 1, j = 1; i < symcount; ++i)
3283         if (syms[i - 1]->value + syms[i - 1]->section->vma
3284             != syms[i]->value + syms[i]->section->vma)
3285           syms[j++] = syms[i];
3286       symcount = j;
3287     }
3288
3289   i = 0;
3290   /* Note that here and in compare_symbols we can't compare opd and
3291      sym->section directly.  With separate debug info files, the
3292      symbols will be extracted from the debug file while abfd passed
3293      to this function is the real binary.  */
3294   if (opd != NULL && strcmp (syms[i]->section->name, ".opd") == 0)
3295     ++i;
3296   codesecsym = i;
3297
3298   for (; i < symcount; ++i)
3299     if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3300          != (SEC_CODE | SEC_ALLOC))
3301         || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3302       break;
3303   codesecsymend = i;
3304
3305   for (; i < symcount; ++i)
3306     if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3307       break;
3308   secsymend = i;
3309
3310   if (opd != NULL)
3311     for (; i < symcount; ++i)
3312       if (strcmp (syms[i]->section->name, ".opd") != 0)
3313         break;
3314   opdsymend = i;
3315
3316   for (; i < symcount; ++i)
3317     if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3318         != (SEC_CODE | SEC_ALLOC))
3319       break;
3320   symcount = i;
3321
3322   count = 0;
3323
3324   if (relocatable)
3325     {
3326       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3327       arelent *r;
3328       size_t size;
3329       long relcount;
3330
3331       if (opdsymend == secsymend)
3332         goto done;
3333
3334       slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3335       relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3336       if (relcount == 0)
3337         goto done;
3338
3339       if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3340         {
3341           count = -1;
3342           goto done;
3343         }
3344
3345       size = 0;
3346       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3347         {
3348           asymbol *sym;
3349
3350           while (r < opd->relocation + relcount
3351                  && r->address < syms[i]->value + opd->vma)
3352             ++r;
3353
3354           if (r == opd->relocation + relcount)
3355             break;
3356
3357           if (r->address != syms[i]->value + opd->vma)
3358             continue;
3359
3360           if (r->howto->type != R_PPC64_ADDR64)
3361             continue;
3362
3363           sym = *r->sym_ptr_ptr;
3364           if (!sym_exists_at (syms, opdsymend, symcount,
3365                               sym->section->id, sym->value + r->addend))
3366             {
3367               ++count;
3368               size += sizeof (asymbol);
3369               size += strlen (syms[i]->name) + 2;
3370             }
3371         }
3372
3373       if (size == 0)
3374         goto done;
3375       s = *ret = bfd_malloc (size);
3376       if (s == NULL)
3377         {
3378           count = -1;
3379           goto done;
3380         }
3381
3382       names = (char *) (s + count);
3383
3384       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3385         {
3386           asymbol *sym;
3387
3388           while (r < opd->relocation + relcount
3389                  && r->address < syms[i]->value + opd->vma)
3390             ++r;
3391
3392           if (r == opd->relocation + relcount)
3393             break;
3394
3395           if (r->address != syms[i]->value + opd->vma)
3396             continue;
3397
3398           if (r->howto->type != R_PPC64_ADDR64)
3399             continue;
3400
3401           sym = *r->sym_ptr_ptr;
3402           if (!sym_exists_at (syms, opdsymend, symcount,
3403                               sym->section->id, sym->value + r->addend))
3404             {
3405               size_t len;
3406
3407               *s = *syms[i];
3408               s->flags |= BSF_SYNTHETIC;
3409               s->section = sym->section;
3410               s->value = sym->value + r->addend;
3411               s->name = names;
3412               *names++ = '.';
3413               len = strlen (syms[i]->name);
3414               memcpy (names, syms[i]->name, len + 1);
3415               names += len + 1;
3416               /* Have udata.p point back to the original symbol this
3417                  synthetic symbol was derived from.  */
3418               s->udata.p = syms[i];
3419               s++;
3420             }
3421         }
3422     }
3423   else
3424     {
3425       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3426       bfd_byte *contents = NULL;
3427       size_t size;
3428       long plt_count = 0;
3429       bfd_vma glink_vma = 0, resolv_vma = 0;
3430       asection *dynamic, *glink = NULL, *relplt = NULL;
3431       arelent *p;
3432
3433       if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3434         {
3435         free_contents_and_exit_err:
3436           count = -1;
3437         free_contents_and_exit:
3438           if (contents)
3439             free (contents);
3440           goto done;
3441         }
3442
3443       size = 0;
3444       for (i = secsymend; i < opdsymend; ++i)
3445         {
3446           bfd_vma ent;
3447
3448           /* Ignore bogus symbols.  */
3449           if (syms[i]->value > opd->size - 8)
3450             continue;
3451
3452           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3453           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3454             {
3455               ++count;
3456               size += sizeof (asymbol);
3457               size += strlen (syms[i]->name) + 2;
3458             }
3459         }
3460
3461       /* Get start of .glink stubs from DT_PPC64_GLINK.  */
3462       if (dyn_count != 0
3463           && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3464         {
3465           bfd_byte *dynbuf, *extdyn, *extdynend;
3466           size_t extdynsize;
3467           void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3468
3469           if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3470             goto free_contents_and_exit_err;
3471
3472           extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3473           swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3474
3475           extdyn = dynbuf;
3476           extdynend = extdyn + dynamic->size;
3477           for (; extdyn < extdynend; extdyn += extdynsize)
3478             {
3479               Elf_Internal_Dyn dyn;
3480               (*swap_dyn_in) (abfd, extdyn, &dyn);
3481
3482               if (dyn.d_tag == DT_NULL)
3483                 break;
3484
3485               if (dyn.d_tag == DT_PPC64_GLINK)
3486                 {
3487                   /* The first glink stub starts at offset 32; see
3488                      comment in ppc64_elf_finish_dynamic_sections. */
3489                   glink_vma = dyn.d_un.d_val + GLINK_CALL_STUB_SIZE - 8 * 4;
3490                   /* The .glink section usually does not survive the final
3491                      link; search for the section (usually .text) where the
3492                      glink stubs now reside.  */
3493                   glink = bfd_sections_find_if (abfd, section_covers_vma,
3494                                                 &glink_vma);
3495                   break;
3496                 }
3497             }
3498
3499           free (dynbuf);
3500         }
3501
3502       if (glink != NULL)
3503         {
3504           /* Determine __glink trampoline by reading the relative branch
3505              from the first glink stub.  */
3506           bfd_byte buf[4];
3507           unsigned int off = 0;
3508
3509           while (bfd_get_section_contents (abfd, glink, buf,
3510                                            glink_vma + off - glink->vma, 4))
3511             {
3512               unsigned int insn = bfd_get_32 (abfd, buf);
3513               insn ^= B_DOT;
3514               if ((insn & ~0x3fffffc) == 0)
3515                 {
3516                   resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3517                   break;
3518                 }
3519               off += 4;
3520               if (off > 4)
3521                 break;
3522             }
3523
3524           if (resolv_vma)
3525             size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3526
3527           relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3528           if (relplt != NULL)
3529             {
3530               slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3531               if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3532                 goto free_contents_and_exit_err;
3533
3534               plt_count = relplt->size / sizeof (Elf64_External_Rela);
3535               size += plt_count * sizeof (asymbol);
3536
3537               p = relplt->relocation;
3538               for (i = 0; i < plt_count; i++, p++)
3539                 {
3540                   size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3541                   if (p->addend != 0)
3542                     size += sizeof ("+0x") - 1 + 16;
3543                 }
3544             }
3545         }
3546
3547       if (size == 0)
3548         goto free_contents_and_exit;
3549       s = *ret = bfd_malloc (size);
3550       if (s == NULL)
3551         goto free_contents_and_exit_err;
3552
3553       names = (char *) (s + count + plt_count + (resolv_vma != 0));
3554
3555       for (i = secsymend; i < opdsymend; ++i)
3556         {
3557           bfd_vma ent;
3558
3559           if (syms[i]->value > opd->size - 8)
3560             continue;
3561
3562           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3563           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3564             {
3565               long lo, hi;
3566               size_t len;
3567               asection *sec = abfd->sections;
3568
3569               *s = *syms[i];
3570               lo = codesecsym;
3571               hi = codesecsymend;
3572               while (lo < hi)
3573                 {
3574                   long mid = (lo + hi) >> 1;
3575                   if (syms[mid]->section->vma < ent)
3576                     lo = mid + 1;
3577                   else if (syms[mid]->section->vma > ent)
3578                     hi = mid;
3579                   else
3580                     {
3581                       sec = syms[mid]->section;
3582                       break;
3583                     }
3584                 }
3585
3586               if (lo >= hi && lo > codesecsym)
3587                 sec = syms[lo - 1]->section;
3588
3589               for (; sec != NULL; sec = sec->next)
3590                 {
3591                   if (sec->vma > ent)
3592                     break;
3593                   /* SEC_LOAD may not be set if SEC is from a separate debug
3594                      info file.  */
3595                   if ((sec->flags & SEC_ALLOC) == 0)
3596                     break;
3597                   if ((sec->flags & SEC_CODE) != 0)
3598                     s->section = sec;
3599                 }
3600               s->flags |= BSF_SYNTHETIC;
3601               s->value = ent - s->section->vma;
3602               s->name = names;
3603               *names++ = '.';
3604               len = strlen (syms[i]->name);
3605               memcpy (names, syms[i]->name, len + 1);
3606               names += len + 1;
3607               /* Have udata.p point back to the original symbol this
3608                  synthetic symbol was derived from.  */
3609               s->udata.p = syms[i];
3610               s++;
3611             }
3612         }
3613       free (contents);
3614
3615       if (glink != NULL && relplt != NULL)
3616         {
3617           if (resolv_vma)
3618             {
3619               /* Add a symbol for the main glink trampoline.  */
3620               memset (s, 0, sizeof *s);
3621               s->the_bfd = abfd;
3622               s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3623               s->section = glink;
3624               s->value = resolv_vma - glink->vma;
3625               s->name = names;
3626               memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3627               names += sizeof ("__glink_PLTresolve");
3628               s++;
3629               count++;
3630             }
3631
3632           /* FIXME: It would be very much nicer to put sym@plt on the
3633              stub rather than on the glink branch table entry.  The
3634              objdump disassembler would then use a sensible symbol
3635              name on plt calls.  The difficulty in doing so is
3636              a) finding the stubs, and,
3637              b) matching stubs against plt entries, and,
3638              c) there can be multiple stubs for a given plt entry.
3639
3640              Solving (a) could be done by code scanning, but older
3641              ppc64 binaries used different stubs to current code.
3642              (b) is the tricky one since you need to known the toc
3643              pointer for at least one function that uses a pic stub to
3644              be able to calculate the plt address referenced.
3645              (c) means gdb would need to set multiple breakpoints (or
3646              find the glink branch itself) when setting breakpoints
3647              for pending shared library loads.  */
3648           p = relplt->relocation;
3649           for (i = 0; i < plt_count; i++, p++)
3650             {
3651               size_t len;
3652
3653               *s = **p->sym_ptr_ptr;
3654               /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
3655                  we are defining a symbol, ensure one of them is set.  */
3656               if ((s->flags & BSF_LOCAL) == 0)
3657                 s->flags |= BSF_GLOBAL;
3658               s->flags |= BSF_SYNTHETIC;
3659               s->section = glink;
3660               s->value = glink_vma - glink->vma;
3661               s->name = names;
3662               s->udata.p = NULL;
3663               len = strlen ((*p->sym_ptr_ptr)->name);
3664               memcpy (names, (*p->sym_ptr_ptr)->name, len);
3665               names += len;
3666               if (p->addend != 0)
3667                 {
3668                   memcpy (names, "+0x", sizeof ("+0x") - 1);
3669                   names += sizeof ("+0x") - 1;
3670                   bfd_sprintf_vma (abfd, names, p->addend);
3671                   names += strlen (names);
3672                 }
3673               memcpy (names, "@plt", sizeof ("@plt"));
3674               names += sizeof ("@plt");
3675               s++;
3676               if (abi < 2)
3677                 {
3678                   glink_vma += 8;
3679                   if (i >= 0x8000)
3680                     glink_vma += 4;
3681                 }
3682               else
3683                 glink_vma += 4;
3684             }
3685           count += plt_count;
3686         }
3687     }
3688
3689  done:
3690   free (syms);
3691   return count;
3692 }
3693 \f
3694 /* The following functions are specific to the ELF linker, while
3695    functions above are used generally.  Those named ppc64_elf_* are
3696    called by the main ELF linker code.  They appear in this file more
3697    or less in the order in which they are called.  eg.
3698    ppc64_elf_check_relocs is called early in the link process,
3699    ppc64_elf_finish_dynamic_sections is one of the last functions
3700    called.
3701
3702    PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3703    functions have both a function code symbol and a function descriptor
3704    symbol.  A call to foo in a relocatable object file looks like:
3705
3706    .            .text
3707    .    x:
3708    .            bl      .foo
3709    .            nop
3710
3711    The function definition in another object file might be:
3712
3713    .            .section .opd
3714    .    foo:    .quad   .foo
3715    .            .quad   .TOC.@tocbase
3716    .            .quad   0
3717    .
3718    .            .text
3719    .    .foo:   blr
3720
3721    When the linker resolves the call during a static link, the branch
3722    unsurprisingly just goes to .foo and the .opd information is unused.
3723    If the function definition is in a shared library, things are a little
3724    different:  The call goes via a plt call stub, the opd information gets
3725    copied to the plt, and the linker patches the nop.
3726
3727    .    x:
3728    .            bl      .foo_stub
3729    .            ld      2,40(1)
3730    .
3731    .
3732    .    .foo_stub:
3733    .            std     2,40(1)                 # in practice, the call stub
3734    .            addis   11,2,Lfoo@toc@ha        # is slightly optimized, but
3735    .            addi    11,11,Lfoo@toc@l        # this is the general idea
3736    .            ld      12,0(11)
3737    .            ld      2,8(11)
3738    .            mtctr   12
3739    .            ld      11,16(11)
3740    .            bctr
3741    .
3742    .            .section .plt
3743    .    Lfoo:   reloc (R_PPC64_JMP_SLOT, foo)
3744
3745    The "reloc ()" notation is supposed to indicate that the linker emits
3746    an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
3747    copying.
3748
3749    What are the difficulties here?  Well, firstly, the relocations
3750    examined by the linker in check_relocs are against the function code
3751    sym .foo, while the dynamic relocation in the plt is emitted against
3752    the function descriptor symbol, foo.  Somewhere along the line, we need
3753    to carefully copy dynamic link information from one symbol to the other.
3754    Secondly, the generic part of the elf linker will make .foo a dynamic
3755    symbol as is normal for most other backends.  We need foo dynamic
3756    instead, at least for an application final link.  However, when
3757    creating a shared library containing foo, we need to have both symbols
3758    dynamic so that references to .foo are satisfied during the early
3759    stages of linking.  Otherwise the linker might decide to pull in a
3760    definition from some other object, eg. a static library.
3761
3762    Update: As of August 2004, we support a new convention.  Function
3763    calls may use the function descriptor symbol, ie. "bl foo".  This
3764    behaves exactly as "bl .foo".  */
3765
3766 /* Of those relocs that might be copied as dynamic relocs, this function
3767    selects those that must be copied when linking a shared library,
3768    even when the symbol is local.  */
3769
3770 static int
3771 must_be_dyn_reloc (struct bfd_link_info *info,
3772                    enum elf_ppc64_reloc_type r_type)
3773 {
3774   switch (r_type)
3775     {
3776     default:
3777       return 1;
3778
3779     case R_PPC64_REL32:
3780     case R_PPC64_REL64:
3781     case R_PPC64_REL30:
3782       return 0;
3783
3784     case R_PPC64_TPREL16:
3785     case R_PPC64_TPREL16_LO:
3786     case R_PPC64_TPREL16_HI:
3787     case R_PPC64_TPREL16_HA:
3788     case R_PPC64_TPREL16_DS:
3789     case R_PPC64_TPREL16_LO_DS:
3790     case R_PPC64_TPREL16_HIGH:
3791     case R_PPC64_TPREL16_HIGHA:
3792     case R_PPC64_TPREL16_HIGHER:
3793     case R_PPC64_TPREL16_HIGHERA:
3794     case R_PPC64_TPREL16_HIGHEST:
3795     case R_PPC64_TPREL16_HIGHESTA:
3796     case R_PPC64_TPREL64:
3797       return !bfd_link_executable (info);
3798     }
3799 }
3800
3801 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3802    copying dynamic variables from a shared lib into an app's dynbss
3803    section, and instead use a dynamic relocation to point into the
3804    shared lib.  With code that gcc generates, it's vital that this be
3805    enabled;  In the PowerPC64 ABI, the address of a function is actually
3806    the address of a function descriptor, which resides in the .opd
3807    section.  gcc uses the descriptor directly rather than going via the
3808    GOT as some other ABI's do, which means that initialized function
3809    pointers must reference the descriptor.  Thus, a function pointer
3810    initialized to the address of a function in a shared library will
3811    either require a copy reloc, or a dynamic reloc.  Using a copy reloc
3812    redefines the function descriptor symbol to point to the copy.  This
3813    presents a problem as a plt entry for that function is also
3814    initialized from the function descriptor symbol and the copy reloc
3815    may not be initialized first.  */
3816 #define ELIMINATE_COPY_RELOCS 1
3817
3818 /* Section name for stubs is the associated section name plus this
3819    string.  */
3820 #define STUB_SUFFIX ".stub"
3821
3822 /* Linker stubs.
3823    ppc_stub_long_branch:
3824    Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3825    destination, but a 24 bit branch in a stub section will reach.
3826    .    b       dest
3827
3828    ppc_stub_plt_branch:
3829    Similar to the above, but a 24 bit branch in the stub section won't
3830    reach its destination.
3831    .    addis   %r11,%r2,xxx@toc@ha
3832    .    ld      %r12,xxx@toc@l(%r11)
3833    .    mtctr   %r12
3834    .    bctr
3835
3836    ppc_stub_plt_call:
3837    Used to call a function in a shared library.  If it so happens that
3838    the plt entry referenced crosses a 64k boundary, then an extra
3839    "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3840    .    std     %r2,40(%r1)
3841    .    addis   %r11,%r2,xxx@toc@ha
3842    .    ld      %r12,xxx+0@toc@l(%r11)
3843    .    mtctr   %r12
3844    .    ld      %r2,xxx+8@toc@l(%r11)
3845    .    ld      %r11,xxx+16@toc@l(%r11)
3846    .    bctr
3847
3848    ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3849    code to adjust the value and save r2 to support multiple toc sections.
3850    A ppc_stub_long_branch with an r2 offset looks like:
3851    .    std     %r2,40(%r1)
3852    .    addis   %r2,%r2,off@ha
3853    .    addi    %r2,%r2,off@l
3854    .    b       dest
3855
3856    A ppc_stub_plt_branch with an r2 offset looks like:
3857    .    std     %r2,40(%r1)
3858    .    addis   %r11,%r2,xxx@toc@ha
3859    .    ld      %r12,xxx@toc@l(%r11)
3860    .    addis   %r2,%r2,off@ha
3861    .    addi    %r2,%r2,off@l
3862    .    mtctr   %r12
3863    .    bctr
3864
3865    In cases where the "addis" instruction would add zero, the "addis" is
3866    omitted and following instructions modified slightly in some cases.
3867 */
3868
3869 enum ppc_stub_type {
3870   ppc_stub_none,
3871   ppc_stub_long_branch,
3872   ppc_stub_long_branch_r2off,
3873   ppc_stub_plt_branch,
3874   ppc_stub_plt_branch_r2off,
3875   ppc_stub_plt_call,
3876   ppc_stub_plt_call_r2save,
3877   ppc_stub_global_entry,
3878   ppc_stub_save_res
3879 };
3880
3881 /* Information on stub grouping.  */
3882 struct map_stub
3883 {
3884   /* The stub section.  */
3885   asection *stub_sec;
3886   /* This is the section to which stubs in the group will be attached.  */
3887   asection *link_sec;
3888   /* Next group.  */
3889   struct map_stub *next;
3890   /* Whether to emit a copy of register save/restore functions in this
3891      group.  */
3892   int needs_save_res;
3893 };
3894
3895 struct ppc_stub_hash_entry {
3896
3897   /* Base hash table entry structure.  */
3898   struct bfd_hash_entry root;
3899
3900   enum ppc_stub_type stub_type;
3901
3902   /* Group information.  */
3903   struct map_stub *group;
3904
3905   /* Offset within stub_sec of the beginning of this stub.  */
3906   bfd_vma stub_offset;
3907
3908   /* Given the symbol's value and its section we can determine its final
3909      value when building the stubs (so the stub knows where to jump.  */
3910   bfd_vma target_value;
3911   asection *target_section;
3912
3913   /* The symbol table entry, if any, that this was derived from.  */
3914   struct ppc_link_hash_entry *h;
3915   struct plt_entry *plt_ent;
3916
3917   /* Symbol st_other.  */
3918   unsigned char other;
3919 };
3920
3921 struct ppc_branch_hash_entry {
3922
3923   /* Base hash table entry structure.  */
3924   struct bfd_hash_entry root;
3925
3926   /* Offset within branch lookup table.  */
3927   unsigned int offset;
3928
3929   /* Generation marker.  */
3930   unsigned int iter;
3931 };
3932
3933 /* Used to track dynamic relocations for local symbols.  */
3934 struct ppc_dyn_relocs
3935 {
3936   struct ppc_dyn_relocs *next;
3937
3938   /* The input section of the reloc.  */
3939   asection *sec;
3940
3941   /* Total number of relocs copied for the input section.  */
3942   unsigned int count : 31;
3943
3944   /* Whether this entry is for STT_GNU_IFUNC symbols.  */
3945   unsigned int ifunc : 1;
3946 };
3947
3948 struct ppc_link_hash_entry
3949 {
3950   struct elf_link_hash_entry elf;
3951
3952   union {
3953     /* A pointer to the most recently used stub hash entry against this
3954        symbol.  */
3955     struct ppc_stub_hash_entry *stub_cache;
3956
3957     /* A pointer to the next symbol starting with a '.'  */
3958     struct ppc_link_hash_entry *next_dot_sym;
3959   } u;
3960
3961   /* Track dynamic relocs copied for this symbol.  */
3962   struct elf_dyn_relocs *dyn_relocs;
3963
3964   /* Chain of aliases referring to a weakdef.  */
3965   struct ppc_link_hash_entry *weakref;
3966
3967   /* Link between function code and descriptor symbols.  */
3968   struct ppc_link_hash_entry *oh;
3969
3970   /* Flag function code and descriptor symbols.  */
3971   unsigned int is_func:1;
3972   unsigned int is_func_descriptor:1;
3973   unsigned int fake:1;
3974
3975   /* Whether global opd/toc sym has been adjusted or not.
3976      After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3977      should be set for all globals defined in any opd/toc section.  */
3978   unsigned int adjust_done:1;
3979
3980   /* Set if we twiddled this symbol to weak at some stage.  */
3981   unsigned int was_undefined:1;
3982
3983   /* Set if this is an out-of-line register save/restore function,
3984      with non-standard calling convention.  */
3985   unsigned int save_res:1;
3986
3987   /* Contexts in which symbol is used in the GOT (or TOC).
3988      TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3989      corresponding relocs are encountered during check_relocs.
3990      tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3991      indicate the corresponding GOT entry type is not needed.
3992      tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3993      a TPREL one.  We use a separate flag rather than setting TPREL
3994      just for convenience in distinguishing the two cases.  */
3995 #define TLS_GD           1      /* GD reloc. */
3996 #define TLS_LD           2      /* LD reloc. */
3997 #define TLS_TPREL        4      /* TPREL reloc, => IE. */
3998 #define TLS_DTPREL       8      /* DTPREL reloc, => LD. */
3999 #define TLS_TLS         16      /* Any TLS reloc.  */
4000 #define TLS_EXPLICIT    32      /* Marks TOC section TLS relocs. */
4001 #define TLS_TPRELGD     64      /* TPREL reloc resulting from GD->IE. */
4002 #define PLT_IFUNC      128      /* STT_GNU_IFUNC.  */
4003   unsigned char tls_mask;
4004 };
4005
4006 /* ppc64 ELF linker hash table.  */
4007
4008 struct ppc_link_hash_table
4009 {
4010   struct elf_link_hash_table elf;
4011
4012   /* The stub hash table.  */
4013   struct bfd_hash_table stub_hash_table;
4014
4015   /* Another hash table for plt_branch stubs.  */
4016   struct bfd_hash_table branch_hash_table;
4017
4018   /* Hash table for function prologue tocsave.  */
4019   htab_t tocsave_htab;
4020
4021   /* Various options and other info passed from the linker.  */
4022   struct ppc64_elf_params *params;
4023
4024   /* The size of sec_info below.  */
4025   unsigned int sec_info_arr_size;
4026
4027   /* Per-section array of extra section info.  Done this way rather
4028      than as part of ppc64_elf_section_data so we have the info for
4029      non-ppc64 sections.  */
4030   struct
4031   {
4032     /* Along with elf_gp, specifies the TOC pointer used by this section.  */
4033     bfd_vma toc_off;
4034
4035     union
4036     {
4037       /* The section group that this section belongs to.  */
4038       struct map_stub *group;
4039       /* A temp section list pointer.  */
4040       asection *list;
4041     } u;
4042   } *sec_info;
4043
4044   /* Linked list of groups.  */
4045   struct map_stub *group;
4046
4047   /* Temp used when calculating TOC pointers.  */
4048   bfd_vma toc_curr;
4049   bfd *toc_bfd;
4050   asection *toc_first_sec;
4051
4052   /* Used when adding symbols.  */
4053   struct ppc_link_hash_entry *dot_syms;
4054
4055   /* Shortcuts to get to dynamic linker sections.  */
4056   asection *dynbss;
4057   asection *relbss;
4058   asection *glink;
4059   asection *sfpr;
4060   asection *brlt;
4061   asection *relbrlt;
4062   asection *glink_eh_frame;
4063
4064   /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
4065   struct ppc_link_hash_entry *tls_get_addr;
4066   struct ppc_link_hash_entry *tls_get_addr_fd;
4067
4068   /* The size of reliplt used by got entry relocs.  */
4069   bfd_size_type got_reli_size;
4070
4071   /* Statistics.  */
4072   unsigned long stub_count[ppc_stub_global_entry];
4073
4074   /* Number of stubs against global syms.  */
4075   unsigned long stub_globals;
4076
4077   /* Set if we're linking code with function descriptors.  */
4078   unsigned int opd_abi:1;
4079
4080   /* Support for multiple toc sections.  */
4081   unsigned int do_multi_toc:1;
4082   unsigned int multi_toc_needed:1;
4083   unsigned int second_toc_pass:1;
4084   unsigned int do_toc_opt:1;
4085
4086   /* Set on error.  */
4087   unsigned int stub_error:1;
4088
4089   /* Temp used by ppc64_elf_before_check_relocs.  */
4090   unsigned int twiddled_syms:1;
4091
4092   /* Incremented every time we size stubs.  */
4093   unsigned int stub_iteration;
4094
4095   /* Small local sym cache.  */
4096   struct sym_cache sym_cache;
4097 };
4098
4099 /* Rename some of the generic section flags to better document how they
4100    are used here.  */
4101
4102 /* Nonzero if this section has TLS related relocations.  */
4103 #define has_tls_reloc sec_flg0
4104
4105 /* Nonzero if this section has a call to __tls_get_addr.  */
4106 #define has_tls_get_addr_call sec_flg1
4107
4108 /* Nonzero if this section has any toc or got relocs.  */
4109 #define has_toc_reloc sec_flg2
4110
4111 /* Nonzero if this section has a call to another section that uses
4112    the toc or got.  */
4113 #define makes_toc_func_call sec_flg3
4114
4115 /* Recursion protection when determining above flag.  */
4116 #define call_check_in_progress sec_flg4
4117 #define call_check_done sec_flg5
4118
4119 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
4120
4121 #define ppc_hash_table(p) \
4122   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
4123   == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
4124
4125 #define ppc_stub_hash_lookup(table, string, create, copy) \
4126   ((struct ppc_stub_hash_entry *) \
4127    bfd_hash_lookup ((table), (string), (create), (copy)))
4128
4129 #define ppc_branch_hash_lookup(table, string, create, copy) \
4130   ((struct ppc_branch_hash_entry *) \
4131    bfd_hash_lookup ((table), (string), (create), (copy)))
4132
4133 /* Create an entry in the stub hash table.  */
4134
4135 static struct bfd_hash_entry *
4136 stub_hash_newfunc (struct bfd_hash_entry *entry,
4137                    struct bfd_hash_table *table,
4138                    const char *string)
4139 {
4140   /* Allocate the structure if it has not already been allocated by a
4141      subclass.  */
4142   if (entry == NULL)
4143     {
4144       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4145       if (entry == NULL)
4146         return entry;
4147     }
4148
4149   /* Call the allocation method of the superclass.  */
4150   entry = bfd_hash_newfunc (entry, table, string);
4151   if (entry != NULL)
4152     {
4153       struct ppc_stub_hash_entry *eh;
4154
4155       /* Initialize the local fields.  */
4156       eh = (struct ppc_stub_hash_entry *) entry;
4157       eh->stub_type = ppc_stub_none;
4158       eh->group = NULL;
4159       eh->stub_offset = 0;
4160       eh->target_value = 0;
4161       eh->target_section = NULL;
4162       eh->h = NULL;
4163       eh->plt_ent = NULL;
4164       eh->other = 0;
4165     }
4166
4167   return entry;
4168 }
4169
4170 /* Create an entry in the branch hash table.  */
4171
4172 static struct bfd_hash_entry *
4173 branch_hash_newfunc (struct bfd_hash_entry *entry,
4174                      struct bfd_hash_table *table,
4175                      const char *string)
4176 {
4177   /* Allocate the structure if it has not already been allocated by a
4178      subclass.  */
4179   if (entry == NULL)
4180     {
4181       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4182       if (entry == NULL)
4183         return entry;
4184     }
4185
4186   /* Call the allocation method of the superclass.  */
4187   entry = bfd_hash_newfunc (entry, table, string);
4188   if (entry != NULL)
4189     {
4190       struct ppc_branch_hash_entry *eh;
4191
4192       /* Initialize the local fields.  */
4193       eh = (struct ppc_branch_hash_entry *) entry;
4194       eh->offset = 0;
4195       eh->iter = 0;
4196     }
4197
4198   return entry;
4199 }
4200
4201 /* Create an entry in a ppc64 ELF linker hash table.  */
4202
4203 static struct bfd_hash_entry *
4204 link_hash_newfunc (struct bfd_hash_entry *entry,
4205                    struct bfd_hash_table *table,
4206                    const char *string)
4207 {
4208   /* Allocate the structure if it has not already been allocated by a
4209      subclass.  */
4210   if (entry == NULL)
4211     {
4212       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4213       if (entry == NULL)
4214         return entry;
4215     }
4216
4217   /* Call the allocation method of the superclass.  */
4218   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4219   if (entry != NULL)
4220     {
4221       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4222
4223       memset (&eh->u.stub_cache, 0,
4224               (sizeof (struct ppc_link_hash_entry)
4225                - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4226
4227       /* When making function calls, old ABI code references function entry
4228          points (dot symbols), while new ABI code references the function
4229          descriptor symbol.  We need to make any combination of reference and
4230          definition work together, without breaking archive linking.
4231
4232          For a defined function "foo" and an undefined call to "bar":
4233          An old object defines "foo" and ".foo", references ".bar" (possibly
4234          "bar" too).
4235          A new object defines "foo" and references "bar".
4236
4237          A new object thus has no problem with its undefined symbols being
4238          satisfied by definitions in an old object.  On the other hand, the
4239          old object won't have ".bar" satisfied by a new object.
4240
4241          Keep a list of newly added dot-symbols.  */
4242
4243       if (string[0] == '.')
4244         {
4245           struct ppc_link_hash_table *htab;
4246
4247           htab = (struct ppc_link_hash_table *) table;
4248           eh->u.next_dot_sym = htab->dot_syms;
4249           htab->dot_syms = eh;
4250         }
4251     }
4252
4253   return entry;
4254 }
4255
4256 struct tocsave_entry {
4257   asection *sec;
4258   bfd_vma offset;
4259 };
4260
4261 static hashval_t
4262 tocsave_htab_hash (const void *p)
4263 {
4264   const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4265   return ((bfd_vma)(intptr_t) e->sec ^ e->offset) >> 3;
4266 }
4267
4268 static int
4269 tocsave_htab_eq (const void *p1, const void *p2)
4270 {
4271   const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4272   const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4273   return e1->sec == e2->sec && e1->offset == e2->offset;
4274 }
4275
4276 /* Destroy a ppc64 ELF linker hash table.  */
4277
4278 static void
4279 ppc64_elf_link_hash_table_free (bfd *obfd)
4280 {
4281   struct ppc_link_hash_table *htab;
4282
4283   htab = (struct ppc_link_hash_table *) obfd->link.hash;
4284   if (htab->tocsave_htab)
4285     htab_delete (htab->tocsave_htab);
4286   bfd_hash_table_free (&htab->branch_hash_table);
4287   bfd_hash_table_free (&htab->stub_hash_table);
4288   _bfd_elf_link_hash_table_free (obfd);
4289 }
4290
4291 /* Create a ppc64 ELF linker hash table.  */
4292
4293 static struct bfd_link_hash_table *
4294 ppc64_elf_link_hash_table_create (bfd *abfd)
4295 {
4296   struct ppc_link_hash_table *htab;
4297   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4298
4299   htab = bfd_zmalloc (amt);
4300   if (htab == NULL)
4301     return NULL;
4302
4303   if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4304                                       sizeof (struct ppc_link_hash_entry),
4305                                       PPC64_ELF_DATA))
4306     {
4307       free (htab);
4308       return NULL;
4309     }
4310
4311   /* Init the stub hash table too.  */
4312   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4313                             sizeof (struct ppc_stub_hash_entry)))
4314     {
4315       _bfd_elf_link_hash_table_free (abfd);
4316       return NULL;
4317     }
4318
4319   /* And the branch hash table.  */
4320   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4321                             sizeof (struct ppc_branch_hash_entry)))
4322     {
4323       bfd_hash_table_free (&htab->stub_hash_table);
4324       _bfd_elf_link_hash_table_free (abfd);
4325       return NULL;
4326     }
4327
4328   htab->tocsave_htab = htab_try_create (1024,
4329                                         tocsave_htab_hash,
4330                                         tocsave_htab_eq,
4331                                         NULL);
4332   if (htab->tocsave_htab == NULL)
4333     {
4334       ppc64_elf_link_hash_table_free (abfd);
4335       return NULL;
4336     }
4337   htab->elf.root.hash_table_free = ppc64_elf_link_hash_table_free;
4338
4339   /* Initializing two fields of the union is just cosmetic.  We really
4340      only care about glist, but when compiled on a 32-bit host the
4341      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
4342      debugger inspection of these fields look nicer.  */
4343   htab->elf.init_got_refcount.refcount = 0;
4344   htab->elf.init_got_refcount.glist = NULL;
4345   htab->elf.init_plt_refcount.refcount = 0;
4346   htab->elf.init_plt_refcount.glist = NULL;
4347   htab->elf.init_got_offset.offset = 0;
4348   htab->elf.init_got_offset.glist = NULL;
4349   htab->elf.init_plt_offset.offset = 0;
4350   htab->elf.init_plt_offset.glist = NULL;
4351
4352   return &htab->elf.root;
4353 }
4354
4355 /* Create sections for linker generated code.  */
4356
4357 static bfd_boolean
4358 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4359 {
4360   struct ppc_link_hash_table *htab;
4361   flagword flags;
4362
4363   htab = ppc_hash_table (info);
4364
4365   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4366            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4367   if (htab->params->save_restore_funcs)
4368     {
4369       /* Create .sfpr for code to save and restore fp regs.  */
4370       htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4371                                                        flags);
4372       if (htab->sfpr == NULL
4373           || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4374         return FALSE;
4375     }
4376
4377   if (bfd_link_relocatable (info))
4378     return TRUE;
4379
4380   /* Create .glink for lazy dynamic linking support.  */
4381   htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4382                                                     flags);
4383   if (htab->glink == NULL
4384       || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4385     return FALSE;
4386
4387   if (!info->no_ld_generated_unwind_info)
4388     {
4389       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4390                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4391       htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4392                                                                  ".eh_frame",
4393                                                                  flags);
4394       if (htab->glink_eh_frame == NULL
4395           || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4396         return FALSE;
4397     }
4398
4399   flags = SEC_ALLOC | SEC_LINKER_CREATED;
4400   htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4401   if (htab->elf.iplt == NULL
4402       || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4403     return FALSE;
4404
4405   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4406            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4407   htab->elf.irelplt
4408     = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4409   if (htab->elf.irelplt == NULL
4410       || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4411     return FALSE;
4412
4413   /* Create branch lookup table for plt_branch stubs.  */
4414   flags = (SEC_ALLOC | SEC_LOAD
4415            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4416   htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4417                                                    flags);
4418   if (htab->brlt == NULL
4419       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4420     return FALSE;
4421
4422   if (!bfd_link_pic (info))
4423     return TRUE;
4424
4425   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4426            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4427   htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4428                                                       ".rela.branch_lt",
4429                                                       flags);
4430   if (htab->relbrlt == NULL
4431       || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4432     return FALSE;
4433
4434   return TRUE;
4435 }
4436
4437 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
4438
4439 bfd_boolean
4440 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4441                          struct ppc64_elf_params *params)
4442 {
4443   struct ppc_link_hash_table *htab;
4444
4445   elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4446
4447 /* Always hook our dynamic sections into the first bfd, which is the
4448    linker created stub bfd.  This ensures that the GOT header is at
4449    the start of the output TOC section.  */
4450   htab = ppc_hash_table (info);
4451   htab->elf.dynobj = params->stub_bfd;
4452   htab->params = params;
4453
4454   return create_linkage_sections (htab->elf.dynobj, info);
4455 }
4456
4457 /* Build a name for an entry in the stub hash table.  */
4458
4459 static char *
4460 ppc_stub_name (const asection *input_section,
4461                const asection *sym_sec,
4462                const struct ppc_link_hash_entry *h,
4463                const Elf_Internal_Rela *rel)
4464 {
4465   char *stub_name;
4466   ssize_t len;
4467
4468   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4469      offsets from a sym as a branch target?  In fact, we could
4470      probably assume the addend is always zero.  */
4471   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4472
4473   if (h)
4474     {
4475       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4476       stub_name = bfd_malloc (len);
4477       if (stub_name == NULL)
4478         return stub_name;
4479
4480       len = sprintf (stub_name, "%08x.%s+%x",
4481                      input_section->id & 0xffffffff,
4482                      h->elf.root.root.string,
4483                      (int) rel->r_addend & 0xffffffff);
4484     }
4485   else
4486     {
4487       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4488       stub_name = bfd_malloc (len);
4489       if (stub_name == NULL)
4490         return stub_name;
4491
4492       len = sprintf (stub_name, "%08x.%x:%x+%x",
4493                      input_section->id & 0xffffffff,
4494                      sym_sec->id & 0xffffffff,
4495                      (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4496                      (int) rel->r_addend & 0xffffffff);
4497     }
4498   if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4499     stub_name[len - 2] = 0;
4500   return stub_name;
4501 }
4502
4503 /* Look up an entry in the stub hash.  Stub entries are cached because
4504    creating the stub name takes a bit of time.  */
4505
4506 static struct ppc_stub_hash_entry *
4507 ppc_get_stub_entry (const asection *input_section,
4508                     const asection *sym_sec,
4509                     struct ppc_link_hash_entry *h,
4510                     const Elf_Internal_Rela *rel,
4511                     struct ppc_link_hash_table *htab)
4512 {
4513   struct ppc_stub_hash_entry *stub_entry;
4514   struct map_stub *group;
4515
4516   /* If this input section is part of a group of sections sharing one
4517      stub section, then use the id of the first section in the group.
4518      Stub names need to include a section id, as there may well be
4519      more than one stub used to reach say, printf, and we need to
4520      distinguish between them.  */
4521   group = htab->sec_info[input_section->id].u.group;
4522   if (group == NULL)
4523     return NULL;
4524
4525   if (h != NULL && h->u.stub_cache != NULL
4526       && h->u.stub_cache->h == h
4527       && h->u.stub_cache->group == group)
4528     {
4529       stub_entry = h->u.stub_cache;
4530     }
4531   else
4532     {
4533       char *stub_name;
4534
4535       stub_name = ppc_stub_name (group->link_sec, sym_sec, h, rel);
4536       if (stub_name == NULL)
4537         return NULL;
4538
4539       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4540                                          stub_name, FALSE, FALSE);
4541       if (h != NULL)
4542         h->u.stub_cache = stub_entry;
4543
4544       free (stub_name);
4545     }
4546
4547   return stub_entry;
4548 }
4549
4550 /* Add a new stub entry to the stub hash.  Not all fields of the new
4551    stub entry are initialised.  */
4552
4553 static struct ppc_stub_hash_entry *
4554 ppc_add_stub (const char *stub_name,
4555               asection *section,
4556               struct bfd_link_info *info)
4557 {
4558   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4559   struct map_stub *group;
4560   asection *link_sec;
4561   asection *stub_sec;
4562   struct ppc_stub_hash_entry *stub_entry;
4563
4564   group = htab->sec_info[section->id].u.group;
4565   link_sec = group->link_sec;
4566   stub_sec = group->stub_sec;
4567   if (stub_sec == NULL)
4568     {
4569       size_t namelen;
4570       bfd_size_type len;
4571       char *s_name;
4572
4573       namelen = strlen (link_sec->name);
4574       len = namelen + sizeof (STUB_SUFFIX);
4575       s_name = bfd_alloc (htab->params->stub_bfd, len);
4576       if (s_name == NULL)
4577         return NULL;
4578
4579       memcpy (s_name, link_sec->name, namelen);
4580       memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4581       stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4582       if (stub_sec == NULL)
4583         return NULL;
4584       group->stub_sec = stub_sec;
4585     }
4586
4587   /* Enter this entry into the linker stub hash table.  */
4588   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4589                                      TRUE, FALSE);
4590   if (stub_entry == NULL)
4591     {
4592       /* xgettext:c-format */
4593       info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4594                               section->owner, stub_name);
4595       return NULL;
4596     }
4597
4598   stub_entry->group = group;
4599   stub_entry->stub_offset = 0;
4600   return stub_entry;
4601 }
4602
4603 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4604    not already done.  */
4605
4606 static bfd_boolean
4607 create_got_section (bfd *abfd, struct bfd_link_info *info)
4608 {
4609   asection *got, *relgot;
4610   flagword flags;
4611   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4612
4613   if (!is_ppc64_elf (abfd))
4614     return FALSE;
4615   if (htab == NULL)
4616     return FALSE;
4617
4618   if (!htab->elf.sgot
4619       && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4620     return FALSE;
4621
4622   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4623            | SEC_LINKER_CREATED);
4624
4625   got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4626   if (!got
4627       || !bfd_set_section_alignment (abfd, got, 3))
4628     return FALSE;
4629
4630   relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4631                                                flags | SEC_READONLY);
4632   if (!relgot
4633       || ! bfd_set_section_alignment (abfd, relgot, 3))
4634     return FALSE;
4635
4636   ppc64_elf_tdata (abfd)->got = got;
4637   ppc64_elf_tdata (abfd)->relgot = relgot;
4638   return TRUE;
4639 }
4640
4641 /* Create the dynamic sections, and set up shortcuts.  */
4642
4643 static bfd_boolean
4644 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4645 {
4646   struct ppc_link_hash_table *htab;
4647
4648   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4649     return FALSE;
4650
4651   htab = ppc_hash_table (info);
4652   if (htab == NULL)
4653     return FALSE;
4654
4655   htab->dynbss = bfd_get_linker_section (dynobj, ".dynbss");
4656   if (!bfd_link_pic (info))
4657     htab->relbss = bfd_get_linker_section (dynobj, ".rela.bss");
4658
4659   if (!htab->elf.sgot || !htab->elf.splt || !htab->elf.srelplt || !htab->dynbss
4660       || (!bfd_link_pic (info) && !htab->relbss))
4661     abort ();
4662
4663   return TRUE;
4664 }
4665
4666 /* Follow indirect and warning symbol links.  */
4667
4668 static inline struct bfd_link_hash_entry *
4669 follow_link (struct bfd_link_hash_entry *h)
4670 {
4671   while (h->type == bfd_link_hash_indirect
4672          || h->type == bfd_link_hash_warning)
4673     h = h->u.i.link;
4674   return h;
4675 }
4676
4677 static inline struct elf_link_hash_entry *
4678 elf_follow_link (struct elf_link_hash_entry *h)
4679 {
4680   return (struct elf_link_hash_entry *) follow_link (&h->root);
4681 }
4682
4683 static inline struct ppc_link_hash_entry *
4684 ppc_follow_link (struct ppc_link_hash_entry *h)
4685 {
4686   return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4687 }
4688
4689 /* Merge PLT info on FROM with that on TO.  */
4690
4691 static void
4692 move_plt_plist (struct ppc_link_hash_entry *from,
4693                 struct ppc_link_hash_entry *to)
4694 {
4695   if (from->elf.plt.plist != NULL)
4696     {
4697       if (to->elf.plt.plist != NULL)
4698         {
4699           struct plt_entry **entp;
4700           struct plt_entry *ent;
4701
4702           for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4703             {
4704               struct plt_entry *dent;
4705
4706               for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4707                 if (dent->addend == ent->addend)
4708                   {
4709                     dent->plt.refcount += ent->plt.refcount;
4710                     *entp = ent->next;
4711                     break;
4712                   }
4713               if (dent == NULL)
4714                 entp = &ent->next;
4715             }
4716           *entp = to->elf.plt.plist;
4717         }
4718
4719       to->elf.plt.plist = from->elf.plt.plist;
4720       from->elf.plt.plist = NULL;
4721     }
4722 }
4723
4724 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
4725
4726 static void
4727 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4728                                 struct elf_link_hash_entry *dir,
4729                                 struct elf_link_hash_entry *ind)
4730 {
4731   struct ppc_link_hash_entry *edir, *eind;
4732
4733   edir = (struct ppc_link_hash_entry *) dir;
4734   eind = (struct ppc_link_hash_entry *) ind;
4735
4736   edir->is_func |= eind->is_func;
4737   edir->is_func_descriptor |= eind->is_func_descriptor;
4738   edir->tls_mask |= eind->tls_mask;
4739   if (eind->oh != NULL)
4740     edir->oh = ppc_follow_link (eind->oh);
4741
4742   /* If called to transfer flags for a weakdef during processing
4743      of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4744      We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
4745   if (!(ELIMINATE_COPY_RELOCS
4746         && eind->elf.root.type != bfd_link_hash_indirect
4747         && edir->elf.dynamic_adjusted))
4748     edir->elf.non_got_ref |= eind->elf.non_got_ref;
4749
4750   edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4751   edir->elf.ref_regular |= eind->elf.ref_regular;
4752   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4753   edir->elf.needs_plt |= eind->elf.needs_plt;
4754   edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4755
4756   /* If we were called to copy over info for a weak sym, don't copy
4757      dyn_relocs, plt/got info, or dynindx.  We used to copy dyn_relocs
4758      in order to simplify readonly_dynrelocs and save a field in the
4759      symbol hash entry, but that means dyn_relocs can't be used in any
4760      tests about a specific symbol, or affect other symbol flags which
4761      are then tested.
4762      Chain weakdefs so we can get from the weakdef back to an alias.
4763      The list is circular so that we don't need to use u.weakdef as
4764      well as this list to look at all aliases.  */
4765   if (eind->elf.root.type != bfd_link_hash_indirect)
4766     {
4767       struct ppc_link_hash_entry *cur, *add, *next;
4768
4769       add = eind;
4770       do
4771         {
4772           cur = edir->weakref;
4773           if (cur != NULL)
4774             {
4775               do
4776                 {
4777                   /* We can be called twice for the same symbols.
4778                      Don't make multiple loops.  */
4779                   if (cur == add)
4780                     return;
4781                   cur = cur->weakref;
4782                 } while (cur != edir);
4783             }
4784           next = add->weakref;
4785           if (cur != add)
4786             {
4787               add->weakref = edir->weakref != NULL ? edir->weakref : edir;
4788               edir->weakref = add;
4789             }
4790           add = next;
4791         } while (add != NULL && add != eind);
4792       return;
4793     }
4794
4795   /* Copy over any dynamic relocs we may have on the indirect sym.  */
4796   if (eind->dyn_relocs != NULL)
4797     {
4798       if (edir->dyn_relocs != NULL)
4799         {
4800           struct elf_dyn_relocs **pp;
4801           struct elf_dyn_relocs *p;
4802
4803           /* Add reloc counts against the indirect sym to the direct sym
4804              list.  Merge any entries against the same section.  */
4805           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4806             {
4807               struct elf_dyn_relocs *q;
4808
4809               for (q = edir->dyn_relocs; q != NULL; q = q->next)
4810                 if (q->sec == p->sec)
4811                   {
4812                     q->pc_count += p->pc_count;
4813                     q->count += p->count;
4814                     *pp = p->next;
4815                     break;
4816                   }
4817               if (q == NULL)
4818                 pp = &p->next;
4819             }
4820           *pp = edir->dyn_relocs;
4821         }
4822
4823       edir->dyn_relocs = eind->dyn_relocs;
4824       eind->dyn_relocs = NULL;
4825     }
4826
4827   /* Copy over got entries that we may have already seen to the
4828      symbol which just became indirect.  */
4829   if (eind->elf.got.glist != NULL)
4830     {
4831       if (edir->elf.got.glist != NULL)
4832         {
4833           struct got_entry **entp;
4834           struct got_entry *ent;
4835
4836           for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4837             {
4838               struct got_entry *dent;
4839
4840               for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4841                 if (dent->addend == ent->addend
4842                     && dent->owner == ent->owner
4843                     && dent->tls_type == ent->tls_type)
4844                   {
4845                     dent->got.refcount += ent->got.refcount;
4846                     *entp = ent->next;
4847                     break;
4848                   }
4849               if (dent == NULL)
4850                 entp = &ent->next;
4851             }
4852           *entp = edir->elf.got.glist;
4853         }
4854
4855       edir->elf.got.glist = eind->elf.got.glist;
4856       eind->elf.got.glist = NULL;
4857     }
4858
4859   /* And plt entries.  */
4860   move_plt_plist (eind, edir);
4861
4862   if (eind->elf.dynindx != -1)
4863     {
4864       if (edir->elf.dynindx != -1)
4865         _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4866                                 edir->elf.dynstr_index);
4867       edir->elf.dynindx = eind->elf.dynindx;
4868       edir->elf.dynstr_index = eind->elf.dynstr_index;
4869       eind->elf.dynindx = -1;
4870       eind->elf.dynstr_index = 0;
4871     }
4872 }
4873
4874 /* Find the function descriptor hash entry from the given function code
4875    hash entry FH.  Link the entries via their OH fields.  */
4876
4877 static struct ppc_link_hash_entry *
4878 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4879 {
4880   struct ppc_link_hash_entry *fdh = fh->oh;
4881
4882   if (fdh == NULL)
4883     {
4884       const char *fd_name = fh->elf.root.root.string + 1;
4885
4886       fdh = (struct ppc_link_hash_entry *)
4887         elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4888       if (fdh == NULL)
4889         return fdh;
4890
4891       fdh->is_func_descriptor = 1;
4892       fdh->oh = fh;
4893       fh->is_func = 1;
4894       fh->oh = fdh;
4895     }
4896
4897   return ppc_follow_link (fdh);
4898 }
4899
4900 /* Make a fake function descriptor sym for the code sym FH.  */
4901
4902 static struct ppc_link_hash_entry *
4903 make_fdh (struct bfd_link_info *info,
4904           struct ppc_link_hash_entry *fh)
4905 {
4906   bfd *abfd;
4907   asymbol *newsym;
4908   struct bfd_link_hash_entry *bh;
4909   struct ppc_link_hash_entry *fdh;
4910
4911   abfd = fh->elf.root.u.undef.abfd;
4912   newsym = bfd_make_empty_symbol (abfd);
4913   newsym->name = fh->elf.root.root.string + 1;
4914   newsym->section = bfd_und_section_ptr;
4915   newsym->value = 0;
4916   newsym->flags = BSF_WEAK;
4917
4918   bh = NULL;
4919   if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4920                                          newsym->flags, newsym->section,
4921                                          newsym->value, NULL, FALSE, FALSE,
4922                                          &bh))
4923     return NULL;
4924
4925   fdh = (struct ppc_link_hash_entry *) bh;
4926   fdh->elf.non_elf = 0;
4927   fdh->fake = 1;
4928   fdh->is_func_descriptor = 1;
4929   fdh->oh = fh;
4930   fh->is_func = 1;
4931   fh->oh = fdh;
4932   return fdh;
4933 }
4934
4935 /* Fix function descriptor symbols defined in .opd sections to be
4936    function type.  */
4937
4938 static bfd_boolean
4939 ppc64_elf_add_symbol_hook (bfd *ibfd,
4940                            struct bfd_link_info *info,
4941                            Elf_Internal_Sym *isym,
4942                            const char **name,
4943                            flagword *flags ATTRIBUTE_UNUSED,
4944                            asection **sec,
4945                            bfd_vma *value)
4946 {
4947   if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4948       && (ibfd->flags & DYNAMIC) == 0
4949       && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
4950     elf_tdata (info->output_bfd)->has_gnu_symbols |= elf_gnu_symbol_ifunc;
4951
4952   if (*sec != NULL
4953       && strcmp ((*sec)->name, ".opd") == 0)
4954     {
4955       asection *code_sec;
4956
4957       if (!(ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4958             || ELF_ST_TYPE (isym->st_info) == STT_FUNC))
4959         isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4960
4961       /* If the symbol is a function defined in .opd, and the function
4962          code is in a discarded group, let it appear to be undefined.  */
4963       if (!bfd_link_relocatable (info)
4964           && (*sec)->reloc_count != 0
4965           && opd_entry_value (*sec, *value, &code_sec, NULL,
4966                               FALSE) != (bfd_vma) -1
4967           && discarded_section (code_sec))
4968         {
4969           *sec = bfd_und_section_ptr;
4970           isym->st_shndx = SHN_UNDEF;
4971         }
4972     }
4973   else if (*sec != NULL
4974            && strcmp ((*sec)->name, ".toc") == 0
4975            && ELF_ST_TYPE (isym->st_info) == STT_OBJECT)
4976     {
4977       struct ppc_link_hash_table *htab = ppc_hash_table (info);
4978       if (htab != NULL)
4979         htab->params->object_in_toc = 1;
4980     }
4981
4982   if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4983     {
4984       if (abiversion (ibfd) == 0)
4985         set_abiversion (ibfd, 2);
4986       else if (abiversion (ibfd) == 1)
4987         {
4988           info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other"
4989                                     " for ABI version 1\n"), name);
4990           bfd_set_error (bfd_error_bad_value);
4991           return FALSE;
4992         }
4993     }
4994
4995   return TRUE;
4996 }
4997
4998 /* Merge non-visibility st_other attributes: local entry point.  */
4999
5000 static void
5001 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
5002                                   const Elf_Internal_Sym *isym,
5003                                   bfd_boolean definition,
5004                                   bfd_boolean dynamic)
5005 {
5006   if (definition && !dynamic)
5007     h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
5008                 | ELF_ST_VISIBILITY (h->other));
5009 }
5010
5011 /* This function makes an old ABI object reference to ".bar" cause the
5012    inclusion of a new ABI object archive that defines "bar".
5013    NAME is a symbol defined in an archive.  Return a symbol in the hash
5014    table that might be satisfied by the archive symbols.  */
5015
5016 static struct elf_link_hash_entry *
5017 ppc64_elf_archive_symbol_lookup (bfd *abfd,
5018                                  struct bfd_link_info *info,
5019                                  const char *name)
5020 {
5021   struct elf_link_hash_entry *h;
5022   char *dot_name;
5023   size_t len;
5024
5025   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
5026   if (h != NULL
5027       /* Don't return this sym if it is a fake function descriptor
5028          created by add_symbol_adjust.  */
5029       && !(h->root.type == bfd_link_hash_undefweak
5030            && ((struct ppc_link_hash_entry *) h)->fake))
5031     return h;
5032
5033   if (name[0] == '.')
5034     return h;
5035
5036   len = strlen (name);
5037   dot_name = bfd_alloc (abfd, len + 2);
5038   if (dot_name == NULL)
5039     return (struct elf_link_hash_entry *) 0 - 1;
5040   dot_name[0] = '.';
5041   memcpy (dot_name + 1, name, len + 1);
5042   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
5043   bfd_release (abfd, dot_name);
5044   return h;
5045 }
5046
5047 /* This function satisfies all old ABI object references to ".bar" if a
5048    new ABI object defines "bar".  Well, at least, undefined dot symbols
5049    are made weak.  This stops later archive searches from including an
5050    object if we already have a function descriptor definition.  It also
5051    prevents the linker complaining about undefined symbols.
5052    We also check and correct mismatched symbol visibility here.  The
5053    most restrictive visibility of the function descriptor and the
5054    function entry symbol is used.  */
5055
5056 static bfd_boolean
5057 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
5058 {
5059   struct ppc_link_hash_table *htab;
5060   struct ppc_link_hash_entry *fdh;
5061
5062   if (eh->elf.root.type == bfd_link_hash_indirect)
5063     return TRUE;
5064
5065   if (eh->elf.root.type == bfd_link_hash_warning)
5066     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
5067
5068   if (eh->elf.root.root.string[0] != '.')
5069     abort ();
5070
5071   htab = ppc_hash_table (info);
5072   if (htab == NULL)
5073     return FALSE;
5074
5075   fdh = lookup_fdh (eh, htab);
5076   if (fdh == NULL)
5077     {
5078       if (!bfd_link_relocatable (info)
5079           && (eh->elf.root.type == bfd_link_hash_undefined
5080               || eh->elf.root.type == bfd_link_hash_undefweak)
5081           && eh->elf.ref_regular)
5082         {
5083           /* Make an undefweak function descriptor sym, which is enough to
5084              pull in an --as-needed shared lib, but won't cause link
5085              errors.  Archives are handled elsewhere.  */
5086           fdh = make_fdh (info, eh);
5087           if (fdh == NULL)
5088             return FALSE;
5089           fdh->elf.ref_regular = 1;
5090         }
5091     }
5092   else
5093     {
5094       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
5095       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
5096       if (entry_vis < descr_vis)
5097         fdh->elf.other += entry_vis - descr_vis;
5098       else if (entry_vis > descr_vis)
5099         eh->elf.other += descr_vis - entry_vis;
5100
5101       if ((fdh->elf.root.type == bfd_link_hash_defined
5102            || fdh->elf.root.type == bfd_link_hash_defweak)
5103           && eh->elf.root.type == bfd_link_hash_undefined)
5104         {
5105           eh->elf.root.type = bfd_link_hash_undefweak;
5106           eh->was_undefined = 1;
5107           htab->twiddled_syms = 1;
5108         }
5109     }
5110
5111   return TRUE;
5112 }
5113
5114 /* Set up opd section info and abiversion for IBFD, and process list
5115    of dot-symbols we made in link_hash_newfunc.  */
5116
5117 static bfd_boolean
5118 ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
5119 {
5120   struct ppc_link_hash_table *htab;
5121   struct ppc_link_hash_entry **p, *eh;
5122   asection *opd = bfd_get_section_by_name (ibfd, ".opd");
5123
5124   if (opd != NULL && opd->size != 0)
5125     {
5126       if (abiversion (ibfd) == 0)
5127         set_abiversion (ibfd, 1);
5128       else if (abiversion (ibfd) >= 2)
5129         {
5130           /* xgettext:c-format */
5131           info->callbacks->einfo (_("%P: %B .opd not allowed in ABI"
5132                                     " version %d\n"),
5133                                   ibfd, abiversion (ibfd));
5134           bfd_set_error (bfd_error_bad_value);
5135           return FALSE;
5136         }
5137
5138       if ((ibfd->flags & DYNAMIC) == 0
5139           && (opd->flags & SEC_RELOC) != 0
5140           && opd->reloc_count != 0
5141           && !bfd_is_abs_section (opd->output_section))
5142         {
5143           /* Garbage collection needs some extra help with .opd sections.
5144              We don't want to necessarily keep everything referenced by
5145              relocs in .opd, as that would keep all functions.  Instead,
5146              if we reference an .opd symbol (a function descriptor), we
5147              want to keep the function code symbol's section.  This is
5148              easy for global symbols, but for local syms we need to keep
5149              information about the associated function section.  */
5150           bfd_size_type amt;
5151           asection **opd_sym_map;
5152
5153           amt = OPD_NDX (opd->size) * sizeof (*opd_sym_map);
5154           opd_sym_map = bfd_zalloc (ibfd, amt);
5155           if (opd_sym_map == NULL)
5156             return FALSE;
5157           ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
5158           BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
5159           ppc64_elf_section_data (opd)->sec_type = sec_opd;
5160         }
5161     }
5162
5163   if (!is_ppc64_elf (info->output_bfd))
5164     return TRUE;
5165   htab = ppc_hash_table (info);
5166   if (htab == NULL)
5167     return FALSE;
5168
5169   /* For input files without an explicit abiversion in e_flags
5170      we should have flagged any with symbol st_other bits set
5171      as ELFv1 and above flagged those with .opd as ELFv2.
5172      Set the output abiversion if not yet set, and for any input
5173      still ambiguous, take its abiversion from the output.
5174      Differences in ABI are reported later.  */
5175   if (abiversion (info->output_bfd) == 0)
5176     set_abiversion (info->output_bfd, abiversion (ibfd));
5177   else if (abiversion (ibfd) == 0)
5178     set_abiversion (ibfd, abiversion (info->output_bfd));
5179
5180   p = &htab->dot_syms;
5181   while ((eh = *p) != NULL)
5182     {
5183       *p = NULL;
5184       if (&eh->elf == htab->elf.hgot)
5185         ;
5186       else if (htab->elf.hgot == NULL
5187                && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
5188         htab->elf.hgot = &eh->elf;
5189       else if (!add_symbol_adjust (eh, info))
5190         return FALSE;
5191       p = &eh->u.next_dot_sym;
5192     }
5193
5194   /* Clear the list for non-ppc64 input files.  */
5195   p = &htab->dot_syms;
5196   while ((eh = *p) != NULL)
5197     {
5198       *p = NULL;
5199       p = &eh->u.next_dot_sym;
5200     }
5201
5202   /* We need to fix the undefs list for any syms we have twiddled to
5203      undefweak.  */
5204   if (htab->twiddled_syms)
5205     {
5206       bfd_link_repair_undef_list (&htab->elf.root);
5207       htab->twiddled_syms = 0;
5208     }
5209   return TRUE;
5210 }
5211
5212 /* Undo hash table changes when an --as-needed input file is determined
5213    not to be needed.  */
5214
5215 static bfd_boolean
5216 ppc64_elf_notice_as_needed (bfd *ibfd,
5217                             struct bfd_link_info *info,
5218                             enum notice_asneeded_action act)
5219 {
5220   if (act == notice_not_needed)
5221     {
5222       struct ppc_link_hash_table *htab = ppc_hash_table (info);
5223
5224       if (htab == NULL)
5225         return FALSE;
5226
5227       htab->dot_syms = NULL;
5228     }
5229   return _bfd_elf_notice_as_needed (ibfd, info, act);
5230 }
5231
5232 /* If --just-symbols against a final linked binary, then assume we need
5233    toc adjusting stubs when calling functions defined there.  */
5234
5235 static void
5236 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5237 {
5238   if ((sec->flags & SEC_CODE) != 0
5239       && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5240       && is_ppc64_elf (sec->owner))
5241     {
5242       if (abiversion (sec->owner) >= 2
5243           || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5244         sec->has_toc_reloc = 1;
5245     }
5246   _bfd_elf_link_just_syms (sec, info);
5247 }
5248
5249 static struct plt_entry **
5250 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5251                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5252 {
5253   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5254   struct plt_entry **local_plt;
5255   unsigned char *local_got_tls_masks;
5256
5257   if (local_got_ents == NULL)
5258     {
5259       bfd_size_type size = symtab_hdr->sh_info;
5260
5261       size *= (sizeof (*local_got_ents)
5262                + sizeof (*local_plt)
5263                + sizeof (*local_got_tls_masks));
5264       local_got_ents = bfd_zalloc (abfd, size);
5265       if (local_got_ents == NULL)
5266         return NULL;
5267       elf_local_got_ents (abfd) = local_got_ents;
5268     }
5269
5270   if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
5271     {
5272       struct got_entry *ent;
5273
5274       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5275         if (ent->addend == r_addend
5276             && ent->owner == abfd
5277             && ent->tls_type == tls_type)
5278           break;
5279       if (ent == NULL)
5280         {
5281           bfd_size_type amt = sizeof (*ent);
5282           ent = bfd_alloc (abfd, amt);
5283           if (ent == NULL)
5284             return FALSE;
5285           ent->next = local_got_ents[r_symndx];
5286           ent->addend = r_addend;
5287           ent->owner = abfd;
5288           ent->tls_type = tls_type;
5289           ent->is_indirect = FALSE;
5290           ent->got.refcount = 0;
5291           local_got_ents[r_symndx] = ent;
5292         }
5293       ent->got.refcount += 1;
5294     }
5295
5296   local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5297   local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5298   local_got_tls_masks[r_symndx] |= tls_type;
5299
5300   return local_plt + r_symndx;
5301 }
5302
5303 static bfd_boolean
5304 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5305 {
5306   struct plt_entry *ent;
5307
5308   for (ent = *plist; ent != NULL; ent = ent->next)
5309     if (ent->addend == addend)
5310       break;
5311   if (ent == NULL)
5312     {
5313       bfd_size_type amt = sizeof (*ent);
5314       ent = bfd_alloc (abfd, amt);
5315       if (ent == NULL)
5316         return FALSE;
5317       ent->next = *plist;
5318       ent->addend = addend;
5319       ent->plt.refcount = 0;
5320       *plist = ent;
5321     }
5322   ent->plt.refcount += 1;
5323   return TRUE;
5324 }
5325
5326 static bfd_boolean
5327 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5328 {
5329   return (r_type == R_PPC64_REL24
5330           || r_type == R_PPC64_REL14
5331           || r_type == R_PPC64_REL14_BRTAKEN
5332           || r_type == R_PPC64_REL14_BRNTAKEN
5333           || r_type == R_PPC64_ADDR24
5334           || r_type == R_PPC64_ADDR14
5335           || r_type == R_PPC64_ADDR14_BRTAKEN
5336           || r_type == R_PPC64_ADDR14_BRNTAKEN);
5337 }
5338
5339 /* Look through the relocs for a section during the first phase, and
5340    calculate needed space in the global offset table, procedure
5341    linkage table, and dynamic reloc sections.  */
5342
5343 static bfd_boolean
5344 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5345                         asection *sec, const Elf_Internal_Rela *relocs)
5346 {
5347   struct ppc_link_hash_table *htab;
5348   Elf_Internal_Shdr *symtab_hdr;
5349   struct elf_link_hash_entry **sym_hashes;
5350   const Elf_Internal_Rela *rel;
5351   const Elf_Internal_Rela *rel_end;
5352   asection *sreloc;
5353   asection **opd_sym_map;
5354   struct elf_link_hash_entry *tga, *dottga;
5355
5356   if (bfd_link_relocatable (info))
5357     return TRUE;
5358
5359   /* Don't do anything special with non-loaded, non-alloced sections.
5360      In particular, any relocs in such sections should not affect GOT
5361      and PLT reference counting (ie. we don't allow them to create GOT
5362      or PLT entries), there's no possibility or desire to optimize TLS
5363      relocs, and there's not much point in propagating relocs to shared
5364      libs that the dynamic linker won't relocate.  */
5365   if ((sec->flags & SEC_ALLOC) == 0)
5366     return TRUE;
5367
5368   BFD_ASSERT (is_ppc64_elf (abfd));
5369
5370   htab = ppc_hash_table (info);
5371   if (htab == NULL)
5372     return FALSE;
5373
5374   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5375                               FALSE, FALSE, TRUE);
5376   dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5377                                  FALSE, FALSE, TRUE);
5378   symtab_hdr = &elf_symtab_hdr (abfd);
5379   sym_hashes = elf_sym_hashes (abfd);
5380   sreloc = NULL;
5381   opd_sym_map = NULL;
5382   if (ppc64_elf_section_data (sec) != NULL
5383       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
5384     opd_sym_map = ppc64_elf_section_data (sec)->u.opd.func_sec;
5385
5386   rel_end = relocs + sec->reloc_count;
5387   for (rel = relocs; rel < rel_end; rel++)
5388     {
5389       unsigned long r_symndx;
5390       struct elf_link_hash_entry *h;
5391       enum elf_ppc64_reloc_type r_type;
5392       int tls_type;
5393       struct _ppc64_elf_section_data *ppc64_sec;
5394       struct plt_entry **ifunc, **plt_list;
5395
5396       r_symndx = ELF64_R_SYM (rel->r_info);
5397       if (r_symndx < symtab_hdr->sh_info)
5398         h = NULL;
5399       else
5400         {
5401           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5402           h = elf_follow_link (h);
5403
5404           /* PR15323, ref flags aren't set for references in the same
5405              object.  */
5406           h->root.non_ir_ref = 1;
5407
5408           if (h == htab->elf.hgot)
5409             sec->has_toc_reloc = 1;
5410         }
5411
5412       tls_type = 0;
5413       ifunc = NULL;
5414       if (h != NULL)
5415         {
5416           if (h->type == STT_GNU_IFUNC)
5417             {
5418               h->needs_plt = 1;
5419               ifunc = &h->plt.plist;
5420             }
5421         }
5422       else
5423         {
5424           Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5425                                                           abfd, r_symndx);
5426           if (isym == NULL)
5427             return FALSE;
5428
5429           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5430             {
5431               ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5432                                              rel->r_addend, PLT_IFUNC);
5433               if (ifunc == NULL)
5434                 return FALSE;
5435             }
5436         }
5437
5438       r_type = ELF64_R_TYPE (rel->r_info);
5439       switch (r_type)
5440         {
5441         case R_PPC64_TLSGD:
5442         case R_PPC64_TLSLD:
5443           /* These special tls relocs tie a call to __tls_get_addr with
5444              its parameter symbol.  */
5445           break;
5446
5447         case R_PPC64_GOT_TLSLD16:
5448         case R_PPC64_GOT_TLSLD16_LO:
5449         case R_PPC64_GOT_TLSLD16_HI:
5450         case R_PPC64_GOT_TLSLD16_HA:
5451           tls_type = TLS_TLS | TLS_LD;
5452           goto dogottls;
5453
5454         case R_PPC64_GOT_TLSGD16:
5455         case R_PPC64_GOT_TLSGD16_LO:
5456         case R_PPC64_GOT_TLSGD16_HI:
5457         case R_PPC64_GOT_TLSGD16_HA:
5458           tls_type = TLS_TLS | TLS_GD;
5459           goto dogottls;
5460
5461         case R_PPC64_GOT_TPREL16_DS:
5462         case R_PPC64_GOT_TPREL16_LO_DS:
5463         case R_PPC64_GOT_TPREL16_HI:
5464         case R_PPC64_GOT_TPREL16_HA:
5465           if (bfd_link_pic (info))
5466             info->flags |= DF_STATIC_TLS;
5467           tls_type = TLS_TLS | TLS_TPREL;
5468           goto dogottls;
5469
5470         case R_PPC64_GOT_DTPREL16_DS:
5471         case R_PPC64_GOT_DTPREL16_LO_DS:
5472         case R_PPC64_GOT_DTPREL16_HI:
5473         case R_PPC64_GOT_DTPREL16_HA:
5474           tls_type = TLS_TLS | TLS_DTPREL;
5475         dogottls:
5476           sec->has_tls_reloc = 1;
5477           /* Fall through */
5478
5479         case R_PPC64_GOT16:
5480         case R_PPC64_GOT16_DS:
5481         case R_PPC64_GOT16_HA:
5482         case R_PPC64_GOT16_HI:
5483         case R_PPC64_GOT16_LO:
5484         case R_PPC64_GOT16_LO_DS:
5485           /* This symbol requires a global offset table entry.  */
5486           sec->has_toc_reloc = 1;
5487           if (r_type == R_PPC64_GOT_TLSLD16
5488               || r_type == R_PPC64_GOT_TLSGD16
5489               || r_type == R_PPC64_GOT_TPREL16_DS
5490               || r_type == R_PPC64_GOT_DTPREL16_DS
5491               || r_type == R_PPC64_GOT16
5492               || r_type == R_PPC64_GOT16_DS)
5493             {
5494               htab->do_multi_toc = 1;
5495               ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5496             }
5497
5498           if (ppc64_elf_tdata (abfd)->got == NULL
5499               && !create_got_section (abfd, info))
5500             return FALSE;
5501
5502           if (h != NULL)
5503             {
5504               struct ppc_link_hash_entry *eh;
5505               struct got_entry *ent;
5506
5507               eh = (struct ppc_link_hash_entry *) h;
5508               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5509                 if (ent->addend == rel->r_addend
5510                     && ent->owner == abfd
5511                     && ent->tls_type == tls_type)
5512                   break;
5513               if (ent == NULL)
5514                 {
5515                   bfd_size_type amt = sizeof (*ent);
5516                   ent = bfd_alloc (abfd, amt);
5517                   if (ent == NULL)
5518                     return FALSE;
5519                   ent->next = eh->elf.got.glist;
5520                   ent->addend = rel->r_addend;
5521                   ent->owner = abfd;
5522                   ent->tls_type = tls_type;
5523                   ent->is_indirect = FALSE;
5524                   ent->got.refcount = 0;
5525                   eh->elf.got.glist = ent;
5526                 }
5527               ent->got.refcount += 1;
5528               eh->tls_mask |= tls_type;
5529             }
5530           else
5531             /* This is a global offset table entry for a local symbol.  */
5532             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5533                                         rel->r_addend, tls_type))
5534               return FALSE;
5535
5536           /* We may also need a plt entry if the symbol turns out to be
5537              an ifunc.  */
5538           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1)
5539             {
5540               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5541                 return FALSE;
5542             }
5543           break;
5544
5545         case R_PPC64_PLT16_HA:
5546         case R_PPC64_PLT16_HI:
5547         case R_PPC64_PLT16_LO:
5548         case R_PPC64_PLT32:
5549         case R_PPC64_PLT64:
5550           /* This symbol requires a procedure linkage table entry.  */
5551           plt_list = ifunc;
5552           if (h != NULL)
5553             {
5554               h->needs_plt = 1;
5555               if (h->root.root.string[0] == '.'
5556                   && h->root.root.string[1] != '\0')
5557                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5558               plt_list = &h->plt.plist;
5559             }
5560           if (plt_list == NULL)
5561             {
5562               /* It does not make sense to have a procedure linkage
5563                  table entry for a non-ifunc local symbol.  */
5564               info->callbacks->einfo
5565                 /* xgettext:c-format */
5566                 (_("%P: %H: %s reloc against local symbol\n"),
5567                  abfd, sec, rel->r_offset,
5568                  ppc64_elf_howto_table[r_type]->name);
5569               bfd_set_error (bfd_error_bad_value);
5570               return FALSE;
5571             }
5572           if (!update_plt_info (abfd, plt_list, rel->r_addend))
5573             return FALSE;
5574           break;
5575
5576           /* The following relocations don't need to propagate the
5577              relocation if linking a shared object since they are
5578              section relative.  */
5579         case R_PPC64_SECTOFF:
5580         case R_PPC64_SECTOFF_LO:
5581         case R_PPC64_SECTOFF_HI:
5582         case R_PPC64_SECTOFF_HA:
5583         case R_PPC64_SECTOFF_DS:
5584         case R_PPC64_SECTOFF_LO_DS:
5585         case R_PPC64_DTPREL16:
5586         case R_PPC64_DTPREL16_LO:
5587         case R_PPC64_DTPREL16_HI:
5588         case R_PPC64_DTPREL16_HA:
5589         case R_PPC64_DTPREL16_DS:
5590         case R_PPC64_DTPREL16_LO_DS:
5591         case R_PPC64_DTPREL16_HIGH:
5592         case R_PPC64_DTPREL16_HIGHA:
5593         case R_PPC64_DTPREL16_HIGHER:
5594         case R_PPC64_DTPREL16_HIGHERA:
5595         case R_PPC64_DTPREL16_HIGHEST:
5596         case R_PPC64_DTPREL16_HIGHESTA:
5597           break;
5598
5599           /* Nor do these.  */
5600         case R_PPC64_REL16:
5601         case R_PPC64_REL16_LO:
5602         case R_PPC64_REL16_HI:
5603         case R_PPC64_REL16_HA:
5604         case R_PPC64_REL16DX_HA:
5605           break;
5606
5607           /* Not supported as a dynamic relocation.  */
5608         case R_PPC64_ADDR64_LOCAL:
5609           if (bfd_link_pic (info))
5610             {
5611               if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5612                 ppc_howto_init ();
5613               /* xgettext:c-format */
5614               info->callbacks->einfo (_("%P: %H: %s reloc unsupported "
5615                                         "in shared libraries and PIEs.\n"),
5616                                       abfd, sec, rel->r_offset,
5617                                       ppc64_elf_howto_table[r_type]->name);
5618               bfd_set_error (bfd_error_bad_value);
5619               return FALSE;
5620             }
5621           break;
5622
5623         case R_PPC64_TOC16:
5624         case R_PPC64_TOC16_DS:
5625           htab->do_multi_toc = 1;
5626           ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5627           /* Fall through.  */
5628         case R_PPC64_TOC16_LO:
5629         case R_PPC64_TOC16_HI:
5630         case R_PPC64_TOC16_HA:
5631         case R_PPC64_TOC16_LO_DS:
5632           sec->has_toc_reloc = 1;
5633           break;
5634
5635           /* Marker reloc.  */
5636         case R_PPC64_ENTRY:
5637           break;
5638
5639           /* This relocation describes the C++ object vtable hierarchy.
5640              Reconstruct it for later use during GC.  */
5641         case R_PPC64_GNU_VTINHERIT:
5642           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5643             return FALSE;
5644           break;
5645
5646           /* This relocation describes which C++ vtable entries are actually
5647              used.  Record for later use during GC.  */
5648         case R_PPC64_GNU_VTENTRY:
5649           BFD_ASSERT (h != NULL);
5650           if (h != NULL
5651               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5652             return FALSE;
5653           break;
5654
5655         case R_PPC64_REL14:
5656         case R_PPC64_REL14_BRTAKEN:
5657         case R_PPC64_REL14_BRNTAKEN:
5658           {
5659             asection *dest = NULL;
5660
5661             /* Heuristic: If jumping outside our section, chances are
5662                we are going to need a stub.  */
5663             if (h != NULL)
5664               {
5665                 /* If the sym is weak it may be overridden later, so
5666                    don't assume we know where a weak sym lives.  */
5667                 if (h->root.type == bfd_link_hash_defined)
5668                   dest = h->root.u.def.section;
5669               }
5670             else
5671               {
5672                 Elf_Internal_Sym *isym;
5673
5674                 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5675                                               abfd, r_symndx);
5676                 if (isym == NULL)
5677                   return FALSE;
5678
5679                 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5680               }
5681
5682             if (dest != sec)
5683               ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5684           }
5685           /* Fall through.  */
5686
5687         case R_PPC64_REL24:
5688           plt_list = ifunc;
5689           if (h != NULL)
5690             {
5691               h->needs_plt = 1;
5692               if (h->root.root.string[0] == '.'
5693                   && h->root.root.string[1] != '\0')
5694                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5695
5696               if (h == tga || h == dottga)
5697                 {
5698                   sec->has_tls_reloc = 1;
5699                   if (rel != relocs
5700                       && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5701                           || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5702                     /* We have a new-style __tls_get_addr call with
5703                        a marker reloc.  */
5704                     ;
5705                   else
5706                     /* Mark this section as having an old-style call.  */
5707                     sec->has_tls_get_addr_call = 1;
5708                 }
5709               plt_list = &h->plt.plist;
5710             }
5711
5712           /* We may need a .plt entry if the function this reloc
5713              refers to is in a shared lib.  */
5714           if (plt_list
5715               && !update_plt_info (abfd, plt_list, rel->r_addend))
5716             return FALSE;
5717           break;
5718
5719         case R_PPC64_ADDR14:
5720         case R_PPC64_ADDR14_BRNTAKEN:
5721         case R_PPC64_ADDR14_BRTAKEN:
5722         case R_PPC64_ADDR24:
5723           goto dodyn;
5724
5725         case R_PPC64_TPREL64:
5726           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5727           if (bfd_link_pic (info))
5728             info->flags |= DF_STATIC_TLS;
5729           goto dotlstoc;
5730
5731         case R_PPC64_DTPMOD64:
5732           if (rel + 1 < rel_end
5733               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5734               && rel[1].r_offset == rel->r_offset + 8)
5735             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5736           else
5737             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5738           goto dotlstoc;
5739
5740         case R_PPC64_DTPREL64:
5741           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5742           if (rel != relocs
5743               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5744               && rel[-1].r_offset == rel->r_offset - 8)
5745             /* This is the second reloc of a dtpmod, dtprel pair.
5746                Don't mark with TLS_DTPREL.  */
5747             goto dodyn;
5748
5749         dotlstoc:
5750           sec->has_tls_reloc = 1;
5751           if (h != NULL)
5752             {
5753               struct ppc_link_hash_entry *eh;
5754               eh = (struct ppc_link_hash_entry *) h;
5755               eh->tls_mask |= tls_type;
5756             }
5757           else
5758             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5759                                         rel->r_addend, tls_type))
5760               return FALSE;
5761
5762           ppc64_sec = ppc64_elf_section_data (sec);
5763           if (ppc64_sec->sec_type != sec_toc)
5764             {
5765               bfd_size_type amt;
5766
5767               /* One extra to simplify get_tls_mask.  */
5768               amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5769               ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5770               if (ppc64_sec->u.toc.symndx == NULL)
5771                 return FALSE;
5772               amt = sec->size * sizeof (bfd_vma) / 8;
5773               ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5774               if (ppc64_sec->u.toc.add == NULL)
5775                 return FALSE;
5776               BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5777               ppc64_sec->sec_type = sec_toc;
5778             }
5779           BFD_ASSERT (rel->r_offset % 8 == 0);
5780           ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5781           ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5782
5783           /* Mark the second slot of a GD or LD entry.
5784              -1 to indicate GD and -2 to indicate LD.  */
5785           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5786             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5787           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5788             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5789           goto dodyn;
5790
5791         case R_PPC64_TPREL16:
5792         case R_PPC64_TPREL16_LO:
5793         case R_PPC64_TPREL16_HI:
5794         case R_PPC64_TPREL16_HA:
5795         case R_PPC64_TPREL16_DS:
5796         case R_PPC64_TPREL16_LO_DS:
5797         case R_PPC64_TPREL16_HIGH:
5798         case R_PPC64_TPREL16_HIGHA:
5799         case R_PPC64_TPREL16_HIGHER:
5800         case R_PPC64_TPREL16_HIGHERA:
5801         case R_PPC64_TPREL16_HIGHEST:
5802         case R_PPC64_TPREL16_HIGHESTA:
5803           if (bfd_link_pic (info))
5804             {
5805               info->flags |= DF_STATIC_TLS;
5806               goto dodyn;
5807             }
5808           break;
5809
5810         case R_PPC64_ADDR64:
5811           if (opd_sym_map != NULL
5812               && rel + 1 < rel_end
5813               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5814             {
5815               if (h != NULL)
5816                 {
5817                   if (h->root.root.string[0] == '.'
5818                       && h->root.root.string[1] != 0
5819                       && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
5820                     ;
5821                   else
5822                     ((struct ppc_link_hash_entry *) h)->is_func = 1;
5823                 }
5824               else
5825                 {
5826                   asection *s;
5827                   Elf_Internal_Sym *isym;
5828
5829                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5830                                                 abfd, r_symndx);
5831                   if (isym == NULL)
5832                     return FALSE;
5833
5834                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5835                   if (s != NULL && s != sec)
5836                     opd_sym_map[OPD_NDX (rel->r_offset)] = s;
5837                 }
5838             }
5839           /* Fall through.  */
5840
5841         case R_PPC64_ADDR16:
5842         case R_PPC64_ADDR16_DS:
5843         case R_PPC64_ADDR16_HA:
5844         case R_PPC64_ADDR16_HI:
5845         case R_PPC64_ADDR16_HIGH:
5846         case R_PPC64_ADDR16_HIGHA:
5847         case R_PPC64_ADDR16_HIGHER:
5848         case R_PPC64_ADDR16_HIGHERA:
5849         case R_PPC64_ADDR16_HIGHEST:
5850         case R_PPC64_ADDR16_HIGHESTA:
5851         case R_PPC64_ADDR16_LO:
5852         case R_PPC64_ADDR16_LO_DS:
5853           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1
5854               && rel->r_addend == 0)
5855             {
5856               /* We may need a .plt entry if this reloc refers to a
5857                  function in a shared lib.  */
5858               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5859                 return FALSE;
5860               h->pointer_equality_needed = 1;
5861             }
5862           /* Fall through.  */
5863
5864         case R_PPC64_REL30:
5865         case R_PPC64_REL32:
5866         case R_PPC64_REL64:
5867         case R_PPC64_ADDR32:
5868         case R_PPC64_UADDR16:
5869         case R_PPC64_UADDR32:
5870         case R_PPC64_UADDR64:
5871         case R_PPC64_TOC:
5872           if (h != NULL && !bfd_link_pic (info))
5873             /* We may need a copy reloc.  */
5874             h->non_got_ref = 1;
5875
5876           /* Don't propagate .opd relocs.  */
5877           if (NO_OPD_RELOCS && opd_sym_map != NULL)
5878             break;
5879
5880           /* If we are creating a shared library, and this is a reloc
5881              against a global symbol, or a non PC relative reloc
5882              against a local symbol, then we need to copy the reloc
5883              into the shared library.  However, if we are linking with
5884              -Bsymbolic, we do not need to copy a reloc against a
5885              global symbol which is defined in an object we are
5886              including in the link (i.e., DEF_REGULAR is set).  At
5887              this point we have not seen all the input files, so it is
5888              possible that DEF_REGULAR is not set now but will be set
5889              later (it is never cleared).  In case of a weak definition,
5890              DEF_REGULAR may be cleared later by a strong definition in
5891              a shared library.  We account for that possibility below by
5892              storing information in the dyn_relocs field of the hash
5893              table entry.  A similar situation occurs when creating
5894              shared libraries and symbol visibility changes render the
5895              symbol local.
5896
5897              If on the other hand, we are creating an executable, we
5898              may need to keep relocations for symbols satisfied by a
5899              dynamic library if we manage to avoid copy relocs for the
5900              symbol.  */
5901         dodyn:
5902           if ((bfd_link_pic (info)
5903                && (must_be_dyn_reloc (info, r_type)
5904                    || (h != NULL
5905                        && (!SYMBOLIC_BIND (info, h)
5906                            || h->root.type == bfd_link_hash_defweak
5907                            || !h->def_regular))))
5908               || (ELIMINATE_COPY_RELOCS
5909                   && !bfd_link_pic (info)
5910                   && h != NULL
5911                   && (h->root.type == bfd_link_hash_defweak
5912                       || !h->def_regular))
5913               || (!bfd_link_pic (info)
5914                   && ifunc != NULL))
5915             {
5916               /* We must copy these reloc types into the output file.
5917                  Create a reloc section in dynobj and make room for
5918                  this reloc.  */
5919               if (sreloc == NULL)
5920                 {
5921                   sreloc = _bfd_elf_make_dynamic_reloc_section
5922                     (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5923
5924                   if (sreloc == NULL)
5925                     return FALSE;
5926                 }
5927
5928               /* If this is a global symbol, we count the number of
5929                  relocations we need for this symbol.  */
5930               if (h != NULL)
5931                 {
5932                   struct elf_dyn_relocs *p;
5933                   struct elf_dyn_relocs **head;
5934
5935                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5936                   p = *head;
5937                   if (p == NULL || p->sec != sec)
5938                     {
5939                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5940                       if (p == NULL)
5941                         return FALSE;
5942                       p->next = *head;
5943                       *head = p;
5944                       p->sec = sec;
5945                       p->count = 0;
5946                       p->pc_count = 0;
5947                     }
5948                   p->count += 1;
5949                   if (!must_be_dyn_reloc (info, r_type))
5950                     p->pc_count += 1;
5951                 }
5952               else
5953                 {
5954                   /* Track dynamic relocs needed for local syms too.
5955                      We really need local syms available to do this
5956                      easily.  Oh well.  */
5957                   struct ppc_dyn_relocs *p;
5958                   struct ppc_dyn_relocs **head;
5959                   bfd_boolean is_ifunc;
5960                   asection *s;
5961                   void *vpp;
5962                   Elf_Internal_Sym *isym;
5963
5964                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5965                                                 abfd, r_symndx);
5966                   if (isym == NULL)
5967                     return FALSE;
5968
5969                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5970                   if (s == NULL)
5971                     s = sec;
5972
5973                   vpp = &elf_section_data (s)->local_dynrel;
5974                   head = (struct ppc_dyn_relocs **) vpp;
5975                   is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5976                   p = *head;
5977                   if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5978                     p = p->next;
5979                   if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5980                     {
5981                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5982                       if (p == NULL)
5983                         return FALSE;
5984                       p->next = *head;
5985                       *head = p;
5986                       p->sec = sec;
5987                       p->ifunc = is_ifunc;
5988                       p->count = 0;
5989                     }
5990                   p->count += 1;
5991                 }
5992             }
5993           break;
5994
5995         default:
5996           break;
5997         }
5998     }
5999
6000   return TRUE;
6001 }
6002
6003 /* Merge backend specific data from an object file to the output
6004    object file when linking.  */
6005
6006 static bfd_boolean
6007 ppc64_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
6008 {
6009   bfd *obfd = info->output_bfd;
6010   unsigned long iflags, oflags;
6011
6012   if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
6013     return TRUE;
6014
6015   if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
6016     return TRUE;
6017
6018   if (!_bfd_generic_verify_endian_match (ibfd, info))
6019     return FALSE;
6020
6021   iflags = elf_elfheader (ibfd)->e_flags;
6022   oflags = elf_elfheader (obfd)->e_flags;
6023
6024   if (iflags & ~EF_PPC64_ABI)
6025     {
6026       _bfd_error_handler
6027         /* xgettext:c-format */
6028         (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
6029       bfd_set_error (bfd_error_bad_value);
6030       return FALSE;
6031     }
6032   else if (iflags != oflags && iflags != 0)
6033     {
6034       _bfd_error_handler
6035         /* xgettext:c-format */
6036         (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
6037          ibfd, iflags, oflags);
6038       bfd_set_error (bfd_error_bad_value);
6039       return FALSE;
6040     }
6041
6042   _bfd_elf_ppc_merge_fp_attributes (ibfd, info);
6043
6044   /* Merge Tag_compatibility attributes and any common GNU ones.  */
6045   _bfd_elf_merge_object_attributes (ibfd, info);
6046
6047   return TRUE;
6048 }
6049
6050 static bfd_boolean
6051 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
6052 {
6053   /* Print normal ELF private data.  */
6054   _bfd_elf_print_private_bfd_data (abfd, ptr);
6055
6056   if (elf_elfheader (abfd)->e_flags != 0)
6057     {
6058       FILE *file = ptr;
6059
6060       fprintf (file, _("private flags = 0x%lx:"),
6061                elf_elfheader (abfd)->e_flags);
6062
6063       if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
6064         fprintf (file, _(" [abiv%ld]"),
6065                  elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
6066       fputc ('\n', file);
6067     }
6068
6069   return TRUE;
6070 }
6071
6072 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
6073    of the code entry point, and its section, which must be in the same
6074    object as OPD_SEC.  Returns (bfd_vma) -1 on error.  */
6075
6076 static bfd_vma
6077 opd_entry_value (asection *opd_sec,
6078                  bfd_vma offset,
6079                  asection **code_sec,
6080                  bfd_vma *code_off,
6081                  bfd_boolean in_code_sec)
6082 {
6083   bfd *opd_bfd = opd_sec->owner;
6084   Elf_Internal_Rela *relocs;
6085   Elf_Internal_Rela *lo, *hi, *look;
6086   bfd_vma val;
6087
6088   /* No relocs implies we are linking a --just-symbols object, or looking
6089      at a final linked executable with addr2line or somesuch.  */
6090   if (opd_sec->reloc_count == 0)
6091     {
6092       bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
6093
6094       if (contents == NULL)
6095         {
6096           if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
6097             return (bfd_vma) -1;
6098           ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
6099         }
6100
6101       /* PR 17512: file: 64b9dfbb.  */
6102       if (offset + 7 >= opd_sec->size || offset + 7 < offset)
6103         return (bfd_vma) -1;
6104
6105       val = bfd_get_64 (opd_bfd, contents + offset);
6106       if (code_sec != NULL)
6107         {
6108           asection *sec, *likely = NULL;
6109
6110           if (in_code_sec)
6111             {
6112               sec = *code_sec;
6113               if (sec->vma <= val
6114                   && val < sec->vma + sec->size)
6115                 likely = sec;
6116               else
6117                 val = -1;
6118             }
6119           else
6120             for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
6121               if (sec->vma <= val
6122                   && (sec->flags & SEC_LOAD) != 0
6123                   && (sec->flags & SEC_ALLOC) != 0)
6124                 likely = sec;
6125           if (likely != NULL)
6126             {
6127               *code_sec = likely;
6128               if (code_off != NULL)
6129                 *code_off = val - likely->vma;
6130             }
6131         }
6132       return val;
6133     }
6134
6135   BFD_ASSERT (is_ppc64_elf (opd_bfd));
6136
6137   relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
6138   if (relocs == NULL)
6139     relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
6140   /* PR 17512: file: df8e1fd6.  */
6141   if (relocs == NULL)
6142     return (bfd_vma) -1;
6143
6144   /* Go find the opd reloc at the sym address.  */
6145   lo = relocs;
6146   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
6147   val = (bfd_vma) -1;
6148   while (lo < hi)
6149     {
6150       look = lo + (hi - lo) / 2;
6151       if (look->r_offset < offset)
6152         lo = look + 1;
6153       else if (look->r_offset > offset)
6154         hi = look;
6155       else
6156         {
6157           Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
6158
6159           if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
6160               && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
6161             {
6162               unsigned long symndx = ELF64_R_SYM (look->r_info);
6163               asection *sec = NULL;
6164
6165               if (symndx >= symtab_hdr->sh_info
6166                   && elf_sym_hashes (opd_bfd) != NULL)
6167                 {
6168                   struct elf_link_hash_entry **sym_hashes;
6169                   struct elf_link_hash_entry *rh;
6170
6171                   sym_hashes = elf_sym_hashes (opd_bfd);
6172                   rh = sym_hashes[symndx - symtab_hdr->sh_info];
6173                   if (rh != NULL)
6174                     {
6175                       rh = elf_follow_link (rh);
6176                       if (rh->root.type != bfd_link_hash_defined
6177                           && rh->root.type != bfd_link_hash_defweak)
6178                         break;
6179                       if (rh->root.u.def.section->owner == opd_bfd)
6180                         {
6181                           val = rh->root.u.def.value;
6182                           sec = rh->root.u.def.section;
6183                         }
6184                     }
6185                 }
6186
6187               if (sec == NULL)
6188                 {
6189                   Elf_Internal_Sym *sym;
6190
6191                   if (symndx < symtab_hdr->sh_info)
6192                     {
6193                       sym = (Elf_Internal_Sym *) symtab_hdr->contents;
6194                       if (sym == NULL)
6195                         {
6196                           size_t symcnt = symtab_hdr->sh_info;
6197                           sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6198                                                       symcnt, 0,
6199                                                       NULL, NULL, NULL);
6200                           if (sym == NULL)
6201                             break;
6202                           symtab_hdr->contents = (bfd_byte *) sym;
6203                         }
6204                       sym += symndx;
6205                     }
6206                   else
6207                     {
6208                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6209                                                   1, symndx,
6210                                                   NULL, NULL, NULL);
6211                       if (sym == NULL)
6212                         break;
6213                     }
6214                   sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6215                   if (sec == NULL)
6216                     break;
6217                   BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
6218                   val = sym->st_value;
6219                 }
6220
6221               val += look->r_addend;
6222               if (code_off != NULL)
6223                 *code_off = val;
6224               if (code_sec != NULL)
6225                 {
6226                   if (in_code_sec && *code_sec != sec)
6227                     return -1;
6228                   else
6229                     *code_sec = sec;
6230                 }
6231               if (sec->output_section != NULL)
6232                 val += sec->output_section->vma + sec->output_offset;
6233             }
6234           break;
6235         }
6236     }
6237
6238   return val;
6239 }
6240
6241 /* If the ELF symbol SYM might be a function in SEC, return the
6242    function size and set *CODE_OFF to the function's entry point,
6243    otherwise return zero.  */
6244
6245 static bfd_size_type
6246 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6247                               bfd_vma *code_off)
6248 {
6249   bfd_size_type size;
6250
6251   if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6252                      | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6253     return 0;
6254
6255   size = 0;
6256   if (!(sym->flags & BSF_SYNTHETIC))
6257     size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6258
6259   if (strcmp (sym->section->name, ".opd") == 0)
6260     {
6261       struct _opd_sec_data *opd = get_opd_info (sym->section);
6262       bfd_vma symval = sym->value;
6263
6264       if (opd != NULL
6265           && opd->adjust != NULL
6266           && elf_section_data (sym->section)->relocs != NULL)
6267         {
6268           /* opd_entry_value will use cached relocs that have been
6269              adjusted, but with raw symbols.  That means both local
6270              and global symbols need adjusting.  */
6271           long adjust = opd->adjust[OPD_NDX (symval)];
6272           if (adjust == -1)
6273             return 0;
6274           symval += adjust;
6275         }
6276
6277       if (opd_entry_value (sym->section, symval,
6278                            &sec, code_off, TRUE) == (bfd_vma) -1)
6279         return 0;
6280       /* An old ABI binary with dot-syms has a size of 24 on the .opd
6281          symbol.  This size has nothing to do with the code size of the
6282          function, which is what we're supposed to return, but the
6283          code size isn't available without looking up the dot-sym.
6284          However, doing that would be a waste of time particularly
6285          since elf_find_function will look at the dot-sym anyway.
6286          Now, elf_find_function will keep the largest size of any
6287          function sym found at the code address of interest, so return
6288          1 here to avoid it incorrectly caching a larger function size
6289          for a small function.  This does mean we return the wrong
6290          size for a new-ABI function of size 24, but all that does is
6291          disable caching for such functions.  */
6292       if (size == 24)
6293         size = 1;
6294     }
6295   else
6296     {
6297       if (sym->section != sec)
6298         return 0;
6299       *code_off = sym->value;
6300     }
6301   if (size == 0)
6302     size = 1;
6303   return size;
6304 }
6305
6306 /* Return true if symbol is defined in a regular object file.  */
6307
6308 static bfd_boolean
6309 is_static_defined (struct elf_link_hash_entry *h)
6310 {
6311   return ((h->root.type == bfd_link_hash_defined
6312            || h->root.type == bfd_link_hash_defweak)
6313           && h->root.u.def.section != NULL
6314           && h->root.u.def.section->output_section != NULL);
6315 }
6316
6317 /* If FDH is a function descriptor symbol, return the associated code
6318    entry symbol if it is defined.  Return NULL otherwise.  */
6319
6320 static struct ppc_link_hash_entry *
6321 defined_code_entry (struct ppc_link_hash_entry *fdh)
6322 {
6323   if (fdh->is_func_descriptor)
6324     {
6325       struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6326       if (fh->elf.root.type == bfd_link_hash_defined
6327           || fh->elf.root.type == bfd_link_hash_defweak)
6328         return fh;
6329     }
6330   return NULL;
6331 }
6332
6333 /* If FH is a function code entry symbol, return the associated
6334    function descriptor symbol if it is defined.  Return NULL otherwise.  */
6335
6336 static struct ppc_link_hash_entry *
6337 defined_func_desc (struct ppc_link_hash_entry *fh)
6338 {
6339   if (fh->oh != NULL
6340       && fh->oh->is_func_descriptor)
6341     {
6342       struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6343       if (fdh->elf.root.type == bfd_link_hash_defined
6344           || fdh->elf.root.type == bfd_link_hash_defweak)
6345         return fdh;
6346     }
6347   return NULL;
6348 }
6349
6350 /* Mark all our entry sym sections, both opd and code section.  */
6351
6352 static void
6353 ppc64_elf_gc_keep (struct bfd_link_info *info)
6354 {
6355   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6356   struct bfd_sym_chain *sym;
6357
6358   if (htab == NULL)
6359     return;
6360
6361   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6362     {
6363       struct ppc_link_hash_entry *eh, *fh;
6364       asection *sec;
6365
6366       eh = (struct ppc_link_hash_entry *)
6367         elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6368       if (eh == NULL)
6369         continue;
6370       if (eh->elf.root.type != bfd_link_hash_defined
6371           && eh->elf.root.type != bfd_link_hash_defweak)
6372         continue;
6373
6374       fh = defined_code_entry (eh);
6375       if (fh != NULL)
6376         {
6377           sec = fh->elf.root.u.def.section;
6378           sec->flags |= SEC_KEEP;
6379         }
6380       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6381                && opd_entry_value (eh->elf.root.u.def.section,
6382                                    eh->elf.root.u.def.value,
6383                                    &sec, NULL, FALSE) != (bfd_vma) -1)
6384         sec->flags |= SEC_KEEP;
6385
6386       sec = eh->elf.root.u.def.section;
6387       sec->flags |= SEC_KEEP;
6388     }
6389 }
6390
6391 /* Mark sections containing dynamically referenced symbols.  When
6392    building shared libraries, we must assume that any visible symbol is
6393    referenced.  */
6394
6395 static bfd_boolean
6396 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6397 {
6398   struct bfd_link_info *info = (struct bfd_link_info *) inf;
6399   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6400   struct ppc_link_hash_entry *fdh;
6401   struct bfd_elf_dynamic_list *d = info->dynamic_list;
6402
6403   /* Dynamic linking info is on the func descriptor sym.  */
6404   fdh = defined_func_desc (eh);
6405   if (fdh != NULL)
6406     eh = fdh;
6407
6408   if ((eh->elf.root.type == bfd_link_hash_defined
6409        || eh->elf.root.type == bfd_link_hash_defweak)
6410       && (eh->elf.ref_dynamic
6411           || ((eh->elf.def_regular || ELF_COMMON_DEF_P (&eh->elf))
6412               && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6413               && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6414               && (!bfd_link_executable (info)
6415                   || info->export_dynamic
6416                   || (eh->elf.dynamic
6417                       && d != NULL
6418                       && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
6419               && (strchr (eh->elf.root.root.string, ELF_VER_CHR) != NULL
6420                   || !bfd_hide_sym_by_version (info->version_info,
6421                                                eh->elf.root.root.string)))))
6422     {
6423       asection *code_sec;
6424       struct ppc_link_hash_entry *fh;
6425
6426       eh->elf.root.u.def.section->flags |= SEC_KEEP;
6427
6428       /* Function descriptor syms cause the associated
6429          function code sym section to be marked.  */
6430       fh = defined_code_entry (eh);
6431       if (fh != NULL)
6432         {
6433           code_sec = fh->elf.root.u.def.section;
6434           code_sec->flags |= SEC_KEEP;
6435         }
6436       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6437                && opd_entry_value (eh->elf.root.u.def.section,
6438                                    eh->elf.root.u.def.value,
6439                                    &code_sec, NULL, FALSE) != (bfd_vma) -1)
6440         code_sec->flags |= SEC_KEEP;
6441     }
6442
6443   return TRUE;
6444 }
6445
6446 /* Return the section that should be marked against GC for a given
6447    relocation.  */
6448
6449 static asection *
6450 ppc64_elf_gc_mark_hook (asection *sec,
6451                         struct bfd_link_info *info,
6452                         Elf_Internal_Rela *rel,
6453                         struct elf_link_hash_entry *h,
6454                         Elf_Internal_Sym *sym)
6455 {
6456   asection *rsec;
6457
6458   /* Syms return NULL if we're marking .opd, so we avoid marking all
6459      function sections, as all functions are referenced in .opd.  */
6460   rsec = NULL;
6461   if (get_opd_info (sec) != NULL)
6462     return rsec;
6463
6464   if (h != NULL)
6465     {
6466       enum elf_ppc64_reloc_type r_type;
6467       struct ppc_link_hash_entry *eh, *fh, *fdh;
6468
6469       r_type = ELF64_R_TYPE (rel->r_info);
6470       switch (r_type)
6471         {
6472         case R_PPC64_GNU_VTINHERIT:
6473         case R_PPC64_GNU_VTENTRY:
6474           break;
6475
6476         default:
6477           switch (h->root.type)
6478             {
6479             case bfd_link_hash_defined:
6480             case bfd_link_hash_defweak:
6481               eh = (struct ppc_link_hash_entry *) h;
6482               fdh = defined_func_desc (eh);
6483               if (fdh != NULL)
6484                 eh = fdh;
6485
6486               /* Function descriptor syms cause the associated
6487                  function code sym section to be marked.  */
6488               fh = defined_code_entry (eh);
6489               if (fh != NULL)
6490                 {
6491                   /* They also mark their opd section.  */
6492                   eh->elf.root.u.def.section->gc_mark = 1;
6493
6494                   rsec = fh->elf.root.u.def.section;
6495                 }
6496               else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6497                        && opd_entry_value (eh->elf.root.u.def.section,
6498                                            eh->elf.root.u.def.value,
6499                                            &rsec, NULL, FALSE) != (bfd_vma) -1)
6500                 eh->elf.root.u.def.section->gc_mark = 1;
6501               else
6502                 rsec = h->root.u.def.section;
6503               break;
6504
6505             case bfd_link_hash_common:
6506               rsec = h->root.u.c.p->section;
6507               break;
6508
6509             default:
6510               return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6511             }
6512         }
6513     }
6514   else
6515     {
6516       struct _opd_sec_data *opd;
6517
6518       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6519       opd = get_opd_info (rsec);
6520       if (opd != NULL && opd->func_sec != NULL)
6521         {
6522           rsec->gc_mark = 1;
6523
6524           rsec = opd->func_sec[OPD_NDX (sym->st_value + rel->r_addend)];
6525         }
6526     }
6527
6528   return rsec;
6529 }
6530
6531 /* Update the .got, .plt. and dynamic reloc reference counts for the
6532    section being removed.  */
6533
6534 static bfd_boolean
6535 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
6536                          asection *sec, const Elf_Internal_Rela *relocs)
6537 {
6538   struct ppc_link_hash_table *htab;
6539   Elf_Internal_Shdr *symtab_hdr;
6540   struct elf_link_hash_entry **sym_hashes;
6541   struct got_entry **local_got_ents;
6542   const Elf_Internal_Rela *rel, *relend;
6543
6544   if (bfd_link_relocatable (info))
6545     return TRUE;
6546
6547   if ((sec->flags & SEC_ALLOC) == 0)
6548     return TRUE;
6549
6550   elf_section_data (sec)->local_dynrel = NULL;
6551
6552   htab = ppc_hash_table (info);
6553   if (htab == NULL)
6554     return FALSE;
6555
6556   symtab_hdr = &elf_symtab_hdr (abfd);
6557   sym_hashes = elf_sym_hashes (abfd);
6558   local_got_ents = elf_local_got_ents (abfd);
6559
6560   relend = relocs + sec->reloc_count;
6561   for (rel = relocs; rel < relend; rel++)
6562     {
6563       unsigned long r_symndx;
6564       enum elf_ppc64_reloc_type r_type;
6565       struct elf_link_hash_entry *h = NULL;
6566       struct plt_entry **plt_list;
6567       unsigned char tls_type = 0;
6568
6569       r_symndx = ELF64_R_SYM (rel->r_info);
6570       r_type = ELF64_R_TYPE (rel->r_info);
6571       if (r_symndx >= symtab_hdr->sh_info)
6572         {
6573           struct ppc_link_hash_entry *eh;
6574           struct elf_dyn_relocs **pp;
6575           struct elf_dyn_relocs *p;
6576
6577           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6578           h = elf_follow_link (h);
6579           eh = (struct ppc_link_hash_entry *) h;
6580
6581           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6582             if (p->sec == sec)
6583               {
6584                 /* Everything must go for SEC.  */
6585                 *pp = p->next;
6586                 break;
6587               }
6588         }
6589
6590       switch (r_type)
6591         {
6592         case R_PPC64_GOT_TLSLD16:
6593         case R_PPC64_GOT_TLSLD16_LO:
6594         case R_PPC64_GOT_TLSLD16_HI:
6595         case R_PPC64_GOT_TLSLD16_HA:
6596           tls_type = TLS_TLS | TLS_LD;
6597           goto dogot;
6598
6599         case R_PPC64_GOT_TLSGD16:
6600         case R_PPC64_GOT_TLSGD16_LO:
6601         case R_PPC64_GOT_TLSGD16_HI:
6602         case R_PPC64_GOT_TLSGD16_HA:
6603           tls_type = TLS_TLS | TLS_GD;
6604           goto dogot;
6605
6606         case R_PPC64_GOT_TPREL16_DS:
6607         case R_PPC64_GOT_TPREL16_LO_DS:
6608         case R_PPC64_GOT_TPREL16_HI:
6609         case R_PPC64_GOT_TPREL16_HA:
6610           tls_type = TLS_TLS | TLS_TPREL;
6611           goto dogot;
6612
6613         case R_PPC64_GOT_DTPREL16_DS:
6614         case R_PPC64_GOT_DTPREL16_LO_DS:
6615         case R_PPC64_GOT_DTPREL16_HI:
6616         case R_PPC64_GOT_DTPREL16_HA:
6617           tls_type = TLS_TLS | TLS_DTPREL;
6618           goto dogot;
6619
6620         case R_PPC64_GOT16:
6621         case R_PPC64_GOT16_DS:
6622         case R_PPC64_GOT16_HA:
6623         case R_PPC64_GOT16_HI:
6624         case R_PPC64_GOT16_LO:
6625         case R_PPC64_GOT16_LO_DS:
6626         dogot:
6627           {
6628             struct got_entry *ent;
6629
6630             if (h != NULL)
6631               ent = h->got.glist;
6632             else
6633               ent = local_got_ents[r_symndx];
6634
6635             for (; ent != NULL; ent = ent->next)
6636               if (ent->addend == rel->r_addend
6637                   && ent->owner == abfd
6638                   && ent->tls_type == tls_type)
6639                 break;
6640             if (ent == NULL)
6641               abort ();
6642             if (ent->got.refcount > 0)
6643               ent->got.refcount -= 1;
6644           }
6645           break;
6646
6647         case R_PPC64_PLT16_HA:
6648         case R_PPC64_PLT16_HI:
6649         case R_PPC64_PLT16_LO:
6650         case R_PPC64_PLT32:
6651         case R_PPC64_PLT64:
6652         case R_PPC64_REL14:
6653         case R_PPC64_REL14_BRNTAKEN:
6654         case R_PPC64_REL14_BRTAKEN:
6655         case R_PPC64_REL24:
6656           plt_list = NULL;
6657           if (h != NULL)
6658             plt_list = &h->plt.plist;
6659           else if (local_got_ents != NULL)
6660             {
6661               struct plt_entry **local_plt = (struct plt_entry **)
6662                 (local_got_ents + symtab_hdr->sh_info);
6663               unsigned char *local_got_tls_masks = (unsigned char *)
6664                 (local_plt + symtab_hdr->sh_info);
6665               if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6666                 plt_list = local_plt + r_symndx;
6667             }
6668           if (plt_list)
6669             {
6670               struct plt_entry *ent;
6671
6672               for (ent = *plt_list; ent != NULL; ent = ent->next)
6673                 if (ent->addend == rel->r_addend)
6674                   break;
6675               if (ent != NULL && ent->plt.refcount > 0)
6676                 ent->plt.refcount -= 1;
6677             }
6678           break;
6679
6680         default:
6681           break;
6682         }
6683     }
6684   return TRUE;
6685 }
6686
6687 /* The maximum size of .sfpr.  */
6688 #define SFPR_MAX (218*4)
6689
6690 struct sfpr_def_parms
6691 {
6692   const char name[12];
6693   unsigned char lo, hi;
6694   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6695   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6696 };
6697
6698 /* Auto-generate _save*, _rest* functions in .sfpr.
6699    If STUB_SEC is non-null, define alias symbols in STUB_SEC
6700    instead.  */
6701
6702 static bfd_boolean
6703 sfpr_define (struct bfd_link_info *info,
6704              const struct sfpr_def_parms *parm,
6705              asection *stub_sec)
6706 {
6707   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6708   unsigned int i;
6709   size_t len = strlen (parm->name);
6710   bfd_boolean writing = FALSE;
6711   char sym[16];
6712
6713   if (htab == NULL)
6714     return FALSE;
6715
6716   memcpy (sym, parm->name, len);
6717   sym[len + 2] = 0;
6718
6719   for (i = parm->lo; i <= parm->hi; i++)
6720     {
6721       struct ppc_link_hash_entry *h;
6722
6723       sym[len + 0] = i / 10 + '0';
6724       sym[len + 1] = i % 10 + '0';
6725       h = (struct ppc_link_hash_entry *)
6726         elf_link_hash_lookup (&htab->elf, sym, writing, TRUE, TRUE);
6727       if (stub_sec != NULL)
6728         {
6729           if (h != NULL
6730               && h->elf.root.type == bfd_link_hash_defined
6731               && h->elf.root.u.def.section == htab->sfpr)
6732             {
6733               struct elf_link_hash_entry *s;
6734               char buf[32];
6735               sprintf (buf, "%08x.%s", stub_sec->id & 0xffffffff, sym);
6736               s = elf_link_hash_lookup (&htab->elf, buf, TRUE, TRUE, FALSE);
6737               if (s == NULL)
6738                 return FALSE;
6739               if (s->root.type == bfd_link_hash_new
6740                   || (s->root.type = bfd_link_hash_defined
6741                       && s->root.u.def.section == stub_sec))
6742                 {
6743                   s->root.type = bfd_link_hash_defined;
6744                   s->root.u.def.section = stub_sec;
6745                   s->root.u.def.value = (stub_sec->size
6746                                          + h->elf.root.u.def.value);
6747                   s->ref_regular = 1;
6748                   s->def_regular = 1;
6749                   s->ref_regular_nonweak = 1;
6750                   s->forced_local = 1;
6751                   s->non_elf = 0;
6752                   s->root.linker_def = 1;
6753                 }
6754             }
6755           continue;
6756         }
6757       if (h != NULL)
6758         {
6759           h->save_res = 1;
6760           if (!h->elf.def_regular)
6761             {
6762               h->elf.root.type = bfd_link_hash_defined;
6763               h->elf.root.u.def.section = htab->sfpr;
6764               h->elf.root.u.def.value = htab->sfpr->size;
6765               h->elf.type = STT_FUNC;
6766               h->elf.def_regular = 1;
6767               h->elf.non_elf = 0;
6768               _bfd_elf_link_hash_hide_symbol (info, &h->elf, TRUE);
6769               writing = TRUE;
6770               if (htab->sfpr->contents == NULL)
6771                 {
6772                   htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6773                   if (htab->sfpr->contents == NULL)
6774                     return FALSE;
6775                 }
6776             }
6777         }
6778       if (writing)
6779         {
6780           bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6781           if (i != parm->hi)
6782             p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6783           else
6784             p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6785           htab->sfpr->size = p - htab->sfpr->contents;
6786         }
6787     }
6788
6789   return TRUE;
6790 }
6791
6792 static bfd_byte *
6793 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6794 {
6795   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6796   return p + 4;
6797 }
6798
6799 static bfd_byte *
6800 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6801 {
6802   p = savegpr0 (abfd, p, r);
6803   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6804   p = p + 4;
6805   bfd_put_32 (abfd, BLR, p);
6806   return p + 4;
6807 }
6808
6809 static bfd_byte *
6810 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6811 {
6812   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6813   return p + 4;
6814 }
6815
6816 static bfd_byte *
6817 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6818 {
6819   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6820   p = p + 4;
6821   p = restgpr0 (abfd, p, r);
6822   bfd_put_32 (abfd, MTLR_R0, p);
6823   p = p + 4;
6824   if (r == 29)
6825     {
6826       p = restgpr0 (abfd, p, 30);
6827       p = restgpr0 (abfd, p, 31);
6828     }
6829   bfd_put_32 (abfd, BLR, p);
6830   return p + 4;
6831 }
6832
6833 static bfd_byte *
6834 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6835 {
6836   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6837   return p + 4;
6838 }
6839
6840 static bfd_byte *
6841 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6842 {
6843   p = savegpr1 (abfd, p, r);
6844   bfd_put_32 (abfd, BLR, p);
6845   return p + 4;
6846 }
6847
6848 static bfd_byte *
6849 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6850 {
6851   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6852   return p + 4;
6853 }
6854
6855 static bfd_byte *
6856 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6857 {
6858   p = restgpr1 (abfd, p, r);
6859   bfd_put_32 (abfd, BLR, p);
6860   return p + 4;
6861 }
6862
6863 static bfd_byte *
6864 savefpr (bfd *abfd, bfd_byte *p, int r)
6865 {
6866   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6867   return p + 4;
6868 }
6869
6870 static bfd_byte *
6871 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6872 {
6873   p = savefpr (abfd, p, r);
6874   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6875   p = p + 4;
6876   bfd_put_32 (abfd, BLR, p);
6877   return p + 4;
6878 }
6879
6880 static bfd_byte *
6881 restfpr (bfd *abfd, bfd_byte *p, int r)
6882 {
6883   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6884   return p + 4;
6885 }
6886
6887 static bfd_byte *
6888 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6889 {
6890   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6891   p = p + 4;
6892   p = restfpr (abfd, p, r);
6893   bfd_put_32 (abfd, MTLR_R0, p);
6894   p = p + 4;
6895   if (r == 29)
6896     {
6897       p = restfpr (abfd, p, 30);
6898       p = restfpr (abfd, p, 31);
6899     }
6900   bfd_put_32 (abfd, BLR, p);
6901   return p + 4;
6902 }
6903
6904 static bfd_byte *
6905 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6906 {
6907   p = savefpr (abfd, p, r);
6908   bfd_put_32 (abfd, BLR, p);
6909   return p + 4;
6910 }
6911
6912 static bfd_byte *
6913 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6914 {
6915   p = restfpr (abfd, p, r);
6916   bfd_put_32 (abfd, BLR, p);
6917   return p + 4;
6918 }
6919
6920 static bfd_byte *
6921 savevr (bfd *abfd, bfd_byte *p, int r)
6922 {
6923   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6924   p = p + 4;
6925   bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6926   return p + 4;
6927 }
6928
6929 static bfd_byte *
6930 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6931 {
6932   p = savevr (abfd, p, r);
6933   bfd_put_32 (abfd, BLR, p);
6934   return p + 4;
6935 }
6936
6937 static bfd_byte *
6938 restvr (bfd *abfd, bfd_byte *p, int r)
6939 {
6940   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6941   p = p + 4;
6942   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6943   return p + 4;
6944 }
6945
6946 static bfd_byte *
6947 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6948 {
6949   p = restvr (abfd, p, r);
6950   bfd_put_32 (abfd, BLR, p);
6951   return p + 4;
6952 }
6953
6954 /* Called via elf_link_hash_traverse to transfer dynamic linking
6955    information on function code symbol entries to their corresponding
6956    function descriptor symbol entries.  */
6957
6958 static bfd_boolean
6959 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6960 {
6961   struct bfd_link_info *info;
6962   struct ppc_link_hash_table *htab;
6963   struct plt_entry *ent;
6964   struct ppc_link_hash_entry *fh;
6965   struct ppc_link_hash_entry *fdh;
6966   bfd_boolean force_local;
6967
6968   fh = (struct ppc_link_hash_entry *) h;
6969   if (fh->elf.root.type == bfd_link_hash_indirect)
6970     return TRUE;
6971
6972   info = inf;
6973   htab = ppc_hash_table (info);
6974   if (htab == NULL)
6975     return FALSE;
6976
6977   /* Resolve undefined references to dot-symbols as the value
6978      in the function descriptor, if we have one in a regular object.
6979      This is to satisfy cases like ".quad .foo".  Calls to functions
6980      in dynamic objects are handled elsewhere.  */
6981   if (fh->elf.root.type == bfd_link_hash_undefweak
6982       && fh->was_undefined
6983       && (fdh = defined_func_desc (fh)) != NULL
6984       && get_opd_info (fdh->elf.root.u.def.section) != NULL
6985       && opd_entry_value (fdh->elf.root.u.def.section,
6986                           fdh->elf.root.u.def.value,
6987                           &fh->elf.root.u.def.section,
6988                           &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
6989     {
6990       fh->elf.root.type = fdh->elf.root.type;
6991       fh->elf.forced_local = 1;
6992       fh->elf.def_regular = fdh->elf.def_regular;
6993       fh->elf.def_dynamic = fdh->elf.def_dynamic;
6994     }
6995
6996   /* If this is a function code symbol, transfer dynamic linking
6997      information to the function descriptor symbol.  */
6998   if (!fh->is_func)
6999     return TRUE;
7000
7001   for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
7002     if (ent->plt.refcount > 0)
7003       break;
7004   if (ent == NULL
7005       || fh->elf.root.root.string[0] != '.'
7006       || fh->elf.root.root.string[1] == '\0')
7007     return TRUE;
7008
7009   /* Find the corresponding function descriptor symbol.  Create it
7010      as undefined if necessary.  */
7011
7012   fdh = lookup_fdh (fh, htab);
7013   if (fdh == NULL
7014       && !bfd_link_executable (info)
7015       && (fh->elf.root.type == bfd_link_hash_undefined
7016           || fh->elf.root.type == bfd_link_hash_undefweak))
7017     {
7018       fdh = make_fdh (info, fh);
7019       if (fdh == NULL)
7020         return FALSE;
7021     }
7022
7023   /* Fake function descriptors are made undefweak.  If the function
7024      code symbol is strong undefined, make the fake sym the same.
7025      If the function code symbol is defined, then force the fake
7026      descriptor local;  We can't support overriding of symbols in a
7027      shared library on a fake descriptor.  */
7028
7029   if (fdh != NULL
7030       && fdh->fake
7031       && fdh->elf.root.type == bfd_link_hash_undefweak)
7032     {
7033       if (fh->elf.root.type == bfd_link_hash_undefined)
7034         {
7035           fdh->elf.root.type = bfd_link_hash_undefined;
7036           bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
7037         }
7038       else if (fh->elf.root.type == bfd_link_hash_defined
7039                || fh->elf.root.type == bfd_link_hash_defweak)
7040         {
7041           _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
7042         }
7043     }
7044
7045   if (fdh != NULL
7046       && !fdh->elf.forced_local
7047       && (!bfd_link_executable (info)
7048           || fdh->elf.def_dynamic
7049           || fdh->elf.ref_dynamic
7050           || (fdh->elf.root.type == bfd_link_hash_undefweak
7051               && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
7052     {
7053       if (fdh->elf.dynindx == -1)
7054         if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
7055           return FALSE;
7056       fdh->elf.ref_regular |= fh->elf.ref_regular;
7057       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
7058       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
7059       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
7060       if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
7061         {
7062           move_plt_plist (fh, fdh);
7063           fdh->elf.needs_plt = 1;
7064         }
7065       fdh->is_func_descriptor = 1;
7066       fdh->oh = fh;
7067       fh->oh = fdh;
7068     }
7069
7070   /* Now that the info is on the function descriptor, clear the
7071      function code sym info.  Any function code syms for which we
7072      don't have a definition in a regular file, we force local.
7073      This prevents a shared library from exporting syms that have
7074      been imported from another library.  Function code syms that
7075      are really in the library we must leave global to prevent the
7076      linker dragging in a definition from a static library.  */
7077   force_local = (!fh->elf.def_regular
7078                  || fdh == NULL
7079                  || !fdh->elf.def_regular
7080                  || fdh->elf.forced_local);
7081   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7082
7083   return TRUE;
7084 }
7085
7086 static const struct sfpr_def_parms save_res_funcs[] =
7087   {
7088     { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
7089     { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
7090     { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
7091     { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
7092     { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
7093     { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
7094     { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
7095     { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
7096     { "._savef", 14, 31, savefpr, savefpr1_tail },
7097     { "._restf", 14, 31, restfpr, restfpr1_tail },
7098     { "_savevr_", 20, 31, savevr, savevr_tail },
7099     { "_restvr_", 20, 31, restvr, restvr_tail }
7100   };
7101
7102 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
7103    this hook to a) provide some gcc support functions, and b) transfer
7104    dynamic linking information gathered so far on function code symbol
7105    entries, to their corresponding function descriptor symbol entries.  */
7106
7107 static bfd_boolean
7108 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
7109                             struct bfd_link_info *info)
7110 {
7111   struct ppc_link_hash_table *htab;
7112
7113   htab = ppc_hash_table (info);
7114   if (htab == NULL)
7115     return FALSE;
7116
7117   /* Provide any missing _save* and _rest* functions.  */
7118   if (htab->sfpr != NULL)
7119     {
7120       unsigned int i;
7121
7122       htab->sfpr->size = 0;
7123       for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
7124         if (!sfpr_define (info, &save_res_funcs[i], NULL))
7125           return FALSE;
7126       if (htab->sfpr->size == 0)
7127         htab->sfpr->flags |= SEC_EXCLUDE;
7128     }
7129
7130   if (bfd_link_relocatable (info))
7131     return TRUE;
7132
7133   if (htab->elf.hgot != NULL)
7134     {
7135       _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
7136       /* Make .TOC. defined so as to prevent it being made dynamic.
7137          The wrong value here is fixed later in ppc64_elf_set_toc.  */
7138       if (!htab->elf.hgot->def_regular
7139           || htab->elf.hgot->root.type != bfd_link_hash_defined)
7140         {
7141           htab->elf.hgot->root.type = bfd_link_hash_defined;
7142           htab->elf.hgot->root.u.def.value = 0;
7143           htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
7144           htab->elf.hgot->def_regular = 1;
7145           htab->elf.hgot->root.linker_def = 1;
7146         }
7147       htab->elf.hgot->type = STT_OBJECT;
7148       htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
7149                                | STV_HIDDEN);
7150     }
7151
7152   elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
7153
7154   return TRUE;
7155 }
7156
7157 /* Return true if we have dynamic relocs against H that apply to
7158    read-only sections.  */
7159
7160 static bfd_boolean
7161 readonly_dynrelocs (struct elf_link_hash_entry *h)
7162 {
7163   struct ppc_link_hash_entry *eh;
7164   struct elf_dyn_relocs *p;
7165
7166   eh = (struct ppc_link_hash_entry *) h;
7167   for (p = eh->dyn_relocs; p != NULL; p = p->next)
7168     {
7169       asection *s = p->sec->output_section;
7170
7171       if (s != NULL && (s->flags & SEC_READONLY) != 0)
7172         return TRUE;
7173     }
7174   return FALSE;
7175 }
7176
7177 /* Return true if we have dynamic relocs against H or any of its weak
7178    aliases, that apply to read-only sections.  */
7179
7180 static bfd_boolean
7181 alias_readonly_dynrelocs (struct elf_link_hash_entry *h)
7182 {
7183   struct ppc_link_hash_entry *eh;
7184
7185   eh = (struct ppc_link_hash_entry *) h;
7186   do
7187     {
7188       if (readonly_dynrelocs (&eh->elf))
7189         return TRUE;
7190       eh = eh->weakref;
7191     } while (eh != NULL && &eh->elf != h);
7192
7193   return FALSE;
7194 }
7195
7196 /* Return whether EH has pc-relative dynamic relocs.  */
7197
7198 static bfd_boolean
7199 pc_dynrelocs (struct ppc_link_hash_entry *eh)
7200 {
7201   struct elf_dyn_relocs *p;
7202
7203   for (p = eh->dyn_relocs; p != NULL; p = p->next)
7204     if (p->pc_count != 0)
7205       return TRUE;
7206   return FALSE;
7207 }
7208
7209 /* Return true if a global entry stub will be created for H.  Valid
7210    for ELFv2 before plt entries have been allocated.  */
7211
7212 static bfd_boolean
7213 global_entry_stub (struct elf_link_hash_entry *h)
7214 {
7215   struct plt_entry *pent;
7216
7217   if (!h->pointer_equality_needed
7218       || h->def_regular)
7219     return FALSE;
7220
7221   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
7222     if (pent->plt.refcount > 0
7223         && pent->addend == 0)
7224       return TRUE;
7225
7226   return FALSE;
7227 }
7228
7229 /* Adjust a symbol defined by a dynamic object and referenced by a
7230    regular object.  The current definition is in some section of the
7231    dynamic object, but we're not including those sections.  We have to
7232    change the definition to something the rest of the link can
7233    understand.  */
7234
7235 static bfd_boolean
7236 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
7237                                  struct elf_link_hash_entry *h)
7238 {
7239   struct ppc_link_hash_table *htab;
7240   asection *s;
7241
7242   htab = ppc_hash_table (info);
7243   if (htab == NULL)
7244     return FALSE;
7245
7246   /* Deal with function syms.  */
7247   if (h->type == STT_FUNC
7248       || h->type == STT_GNU_IFUNC
7249       || h->needs_plt)
7250     {
7251       /* Clear procedure linkage table information for any symbol that
7252          won't need a .plt entry.  */
7253       struct plt_entry *ent;
7254       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
7255         if (ent->plt.refcount > 0)
7256           break;
7257       if (ent == NULL
7258           || (h->type != STT_GNU_IFUNC
7259               && (SYMBOL_CALLS_LOCAL (info, h)
7260                   || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
7261                       && h->root.type == bfd_link_hash_undefweak)))
7262           || ((struct ppc_link_hash_entry *) h)->save_res)
7263         {
7264           h->plt.plist = NULL;
7265           h->needs_plt = 0;
7266           h->pointer_equality_needed = 0;
7267         }
7268       else if (abiversion (info->output_bfd) >= 2)
7269         {
7270           /* Taking a function's address in a read/write section
7271              doesn't require us to define the function symbol in the
7272              executable on a global entry stub.  A dynamic reloc can
7273              be used instead.  The reason we prefer a few more dynamic
7274              relocs is that calling via a global entry stub costs a
7275              few more instructions, and pointer_equality_needed causes
7276              extra work in ld.so when resolving these symbols.  */
7277           if (global_entry_stub (h)
7278               && !alias_readonly_dynrelocs (h))
7279             {
7280               h->pointer_equality_needed = 0;
7281               /* After adjust_dynamic_symbol, non_got_ref set in
7282                  the non-pic case means that dyn_relocs for this
7283                  symbol should be discarded.  */
7284               h->non_got_ref = 0;
7285             }
7286
7287           /* If making a plt entry, then we don't need copy relocs.  */
7288           return TRUE;
7289         }
7290     }
7291   else
7292     h->plt.plist = NULL;
7293
7294   /* If this is a weak symbol, and there is a real definition, the
7295      processor independent code will have arranged for us to see the
7296      real definition first, and we can just use the same value.  */
7297   if (h->u.weakdef != NULL)
7298     {
7299       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
7300                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
7301       h->root.u.def.section = h->u.weakdef->root.u.def.section;
7302       h->root.u.def.value = h->u.weakdef->root.u.def.value;
7303       if (ELIMINATE_COPY_RELOCS)
7304         h->non_got_ref = h->u.weakdef->non_got_ref;
7305       return TRUE;
7306     }
7307
7308   /* If we are creating a shared library, we must presume that the
7309      only references to the symbol are via the global offset table.
7310      For such cases we need not do anything here; the relocations will
7311      be handled correctly by relocate_section.  */
7312   if (bfd_link_pic (info))
7313     return TRUE;
7314
7315   /* If there are no references to this symbol that do not use the
7316      GOT, we don't need to generate a copy reloc.  */
7317   if (!h->non_got_ref)
7318     return TRUE;
7319
7320   /* Don't generate a copy reloc for symbols defined in the executable.  */
7321   if (!h->def_dynamic || !h->ref_regular || h->def_regular
7322
7323       /* If -z nocopyreloc was given, don't generate them either.  */
7324       || info->nocopyreloc
7325
7326       /* If we didn't find any dynamic relocs in read-only sections, then
7327          we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
7328       || (ELIMINATE_COPY_RELOCS && !alias_readonly_dynrelocs (h))
7329
7330       /* Protected variables do not work with .dynbss.  The copy in
7331          .dynbss won't be used by the shared library with the protected
7332          definition for the variable.  Text relocations are preferable
7333          to an incorrect program.  */
7334       || h->protected_def)
7335     {
7336       h->non_got_ref = 0;
7337       return TRUE;
7338     }
7339
7340   if (h->plt.plist != NULL)
7341     {
7342       /* We should never get here, but unfortunately there are versions
7343          of gcc out there that improperly (for this ABI) put initialized
7344          function pointers, vtable refs and suchlike in read-only
7345          sections.  Allow them to proceed, but warn that this might
7346          break at runtime.  */
7347       info->callbacks->einfo
7348         (_("%P: copy reloc against `%T' requires lazy plt linking; "
7349            "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7350          h->root.root.string);
7351     }
7352
7353   /* This is a reference to a symbol defined by a dynamic object which
7354      is not a function.  */
7355
7356   /* We must allocate the symbol in our .dynbss section, which will
7357      become part of the .bss section of the executable.  There will be
7358      an entry for this symbol in the .dynsym section.  The dynamic
7359      object will contain position independent code, so all references
7360      from the dynamic object to this symbol will go through the global
7361      offset table.  The dynamic linker will use the .dynsym entry to
7362      determine the address it must put in the global offset table, so
7363      both the dynamic object and the regular object will refer to the
7364      same memory location for the variable.  */
7365
7366   /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
7367      to copy the initial value out of the dynamic object and into the
7368      runtime process image.  We need to remember the offset into the
7369      .rela.bss section we are going to use.  */
7370   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7371     {
7372       htab->relbss->size += sizeof (Elf64_External_Rela);
7373       h->needs_copy = 1;
7374     }
7375
7376   s = htab->dynbss;
7377
7378   return _bfd_elf_adjust_dynamic_copy (info, h, s);
7379 }
7380
7381 /* If given a function descriptor symbol, hide both the function code
7382    sym and the descriptor.  */
7383 static void
7384 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7385                        struct elf_link_hash_entry *h,
7386                        bfd_boolean force_local)
7387 {
7388   struct ppc_link_hash_entry *eh;
7389   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7390
7391   eh = (struct ppc_link_hash_entry *) h;
7392   if (eh->is_func_descriptor)
7393     {
7394       struct ppc_link_hash_entry *fh = eh->oh;
7395
7396       if (fh == NULL)
7397         {
7398           const char *p, *q;
7399           struct ppc_link_hash_table *htab;
7400           char save;
7401
7402           /* We aren't supposed to use alloca in BFD because on
7403              systems which do not have alloca the version in libiberty
7404              calls xmalloc, which might cause the program to crash
7405              when it runs out of memory.  This function doesn't have a
7406              return status, so there's no way to gracefully return an
7407              error.  So cheat.  We know that string[-1] can be safely
7408              accessed;  It's either a string in an ELF string table,
7409              or allocated in an objalloc structure.  */
7410
7411           p = eh->elf.root.root.string - 1;
7412           save = *p;
7413           *(char *) p = '.';
7414           htab = ppc_hash_table (info);
7415           if (htab == NULL)
7416             return;
7417
7418           fh = (struct ppc_link_hash_entry *)
7419             elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7420           *(char *) p = save;
7421
7422           /* Unfortunately, if it so happens that the string we were
7423              looking for was allocated immediately before this string,
7424              then we overwrote the string terminator.  That's the only
7425              reason the lookup should fail.  */
7426           if (fh == NULL)
7427             {
7428               q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7429               while (q >= eh->elf.root.root.string && *q == *p)
7430                 --q, --p;
7431               if (q < eh->elf.root.root.string && *p == '.')
7432                 fh = (struct ppc_link_hash_entry *)
7433                   elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7434             }
7435           if (fh != NULL)
7436             {
7437               eh->oh = fh;
7438               fh->oh = eh;
7439             }
7440         }
7441       if (fh != NULL)
7442         _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7443     }
7444 }
7445
7446 static bfd_boolean
7447 get_sym_h (struct elf_link_hash_entry **hp,
7448            Elf_Internal_Sym **symp,
7449            asection **symsecp,
7450            unsigned char **tls_maskp,
7451            Elf_Internal_Sym **locsymsp,
7452            unsigned long r_symndx,
7453            bfd *ibfd)
7454 {
7455   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7456
7457   if (r_symndx >= symtab_hdr->sh_info)
7458     {
7459       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7460       struct elf_link_hash_entry *h;
7461
7462       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7463       h = elf_follow_link (h);
7464
7465       if (hp != NULL)
7466         *hp = h;
7467
7468       if (symp != NULL)
7469         *symp = NULL;
7470
7471       if (symsecp != NULL)
7472         {
7473           asection *symsec = NULL;
7474           if (h->root.type == bfd_link_hash_defined
7475               || h->root.type == bfd_link_hash_defweak)
7476             symsec = h->root.u.def.section;
7477           *symsecp = symsec;
7478         }
7479
7480       if (tls_maskp != NULL)
7481         {
7482           struct ppc_link_hash_entry *eh;
7483
7484           eh = (struct ppc_link_hash_entry *) h;
7485           *tls_maskp = &eh->tls_mask;
7486         }
7487     }
7488   else
7489     {
7490       Elf_Internal_Sym *sym;
7491       Elf_Internal_Sym *locsyms = *locsymsp;
7492
7493       if (locsyms == NULL)
7494         {
7495           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7496           if (locsyms == NULL)
7497             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7498                                             symtab_hdr->sh_info,
7499                                             0, NULL, NULL, NULL);
7500           if (locsyms == NULL)
7501             return FALSE;
7502           *locsymsp = locsyms;
7503         }
7504       sym = locsyms + r_symndx;
7505
7506       if (hp != NULL)
7507         *hp = NULL;
7508
7509       if (symp != NULL)
7510         *symp = sym;
7511
7512       if (symsecp != NULL)
7513         *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7514
7515       if (tls_maskp != NULL)
7516         {
7517           struct got_entry **lgot_ents;
7518           unsigned char *tls_mask;
7519
7520           tls_mask = NULL;
7521           lgot_ents = elf_local_got_ents (ibfd);
7522           if (lgot_ents != NULL)
7523             {
7524               struct plt_entry **local_plt = (struct plt_entry **)
7525                 (lgot_ents + symtab_hdr->sh_info);
7526               unsigned char *lgot_masks = (unsigned char *)
7527                 (local_plt + symtab_hdr->sh_info);
7528               tls_mask = &lgot_masks[r_symndx];
7529             }
7530           *tls_maskp = tls_mask;
7531         }
7532     }
7533   return TRUE;
7534 }
7535
7536 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
7537    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7538    type suitable for optimization, and 1 otherwise.  */
7539
7540 static int
7541 get_tls_mask (unsigned char **tls_maskp,
7542               unsigned long *toc_symndx,
7543               bfd_vma *toc_addend,
7544               Elf_Internal_Sym **locsymsp,
7545               const Elf_Internal_Rela *rel,
7546               bfd *ibfd)
7547 {
7548   unsigned long r_symndx;
7549   int next_r;
7550   struct elf_link_hash_entry *h;
7551   Elf_Internal_Sym *sym;
7552   asection *sec;
7553   bfd_vma off;
7554
7555   r_symndx = ELF64_R_SYM (rel->r_info);
7556   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7557     return 0;
7558
7559   if ((*tls_maskp != NULL && **tls_maskp != 0)
7560       || sec == NULL
7561       || ppc64_elf_section_data (sec) == NULL
7562       || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7563     return 1;
7564
7565   /* Look inside a TOC section too.  */
7566   if (h != NULL)
7567     {
7568       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7569       off = h->root.u.def.value;
7570     }
7571   else
7572     off = sym->st_value;
7573   off += rel->r_addend;
7574   BFD_ASSERT (off % 8 == 0);
7575   r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7576   next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7577   if (toc_symndx != NULL)
7578     *toc_symndx = r_symndx;
7579   if (toc_addend != NULL)
7580     *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7581   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7582     return 0;
7583   if ((h == NULL || is_static_defined (h))
7584       && (next_r == -1 || next_r == -2))
7585     return 1 - next_r;
7586   return 1;
7587 }
7588
7589 /* Find (or create) an entry in the tocsave hash table.  */
7590
7591 static struct tocsave_entry *
7592 tocsave_find (struct ppc_link_hash_table *htab,
7593               enum insert_option insert,
7594               Elf_Internal_Sym **local_syms,
7595               const Elf_Internal_Rela *irela,
7596               bfd *ibfd)
7597 {
7598   unsigned long r_indx;
7599   struct elf_link_hash_entry *h;
7600   Elf_Internal_Sym *sym;
7601   struct tocsave_entry ent, *p;
7602   hashval_t hash;
7603   struct tocsave_entry **slot;
7604
7605   r_indx = ELF64_R_SYM (irela->r_info);
7606   if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7607     return NULL;
7608   if (ent.sec == NULL || ent.sec->output_section == NULL)
7609     {
7610       _bfd_error_handler
7611         (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"));
7612       return NULL;
7613     }
7614
7615   if (h != NULL)
7616     ent.offset = h->root.u.def.value;
7617   else
7618     ent.offset = sym->st_value;
7619   ent.offset += irela->r_addend;
7620
7621   hash = tocsave_htab_hash (&ent);
7622   slot = ((struct tocsave_entry **)
7623           htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7624   if (slot == NULL)
7625     return NULL;
7626
7627   if (*slot == NULL)
7628     {
7629       p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7630       if (p == NULL)
7631         return NULL;
7632       *p = ent;
7633       *slot = p;
7634     }
7635   return *slot;
7636 }
7637
7638 /* Adjust all global syms defined in opd sections.  In gcc generated
7639    code for the old ABI, these will already have been done.  */
7640
7641 static bfd_boolean
7642 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7643 {
7644   struct ppc_link_hash_entry *eh;
7645   asection *sym_sec;
7646   struct _opd_sec_data *opd;
7647
7648   if (h->root.type == bfd_link_hash_indirect)
7649     return TRUE;
7650
7651   if (h->root.type != bfd_link_hash_defined
7652       && h->root.type != bfd_link_hash_defweak)
7653     return TRUE;
7654
7655   eh = (struct ppc_link_hash_entry *) h;
7656   if (eh->adjust_done)
7657     return TRUE;
7658
7659   sym_sec = eh->elf.root.u.def.section;
7660   opd = get_opd_info (sym_sec);
7661   if (opd != NULL && opd->adjust != NULL)
7662     {
7663       long adjust = opd->adjust[OPD_NDX (eh->elf.root.u.def.value)];
7664       if (adjust == -1)
7665         {
7666           /* This entry has been deleted.  */
7667           asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7668           if (dsec == NULL)
7669             {
7670               for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7671                 if (discarded_section (dsec))
7672                   {
7673                     ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7674                     break;
7675                   }
7676             }
7677           eh->elf.root.u.def.value = 0;
7678           eh->elf.root.u.def.section = dsec;
7679         }
7680       else
7681         eh->elf.root.u.def.value += adjust;
7682       eh->adjust_done = 1;
7683     }
7684   return TRUE;
7685 }
7686
7687 /* Handles decrementing dynamic reloc counts for the reloc specified by
7688    R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM
7689    have already been determined.  */
7690
7691 static bfd_boolean
7692 dec_dynrel_count (bfd_vma r_info,
7693                   asection *sec,
7694                   struct bfd_link_info *info,
7695                   Elf_Internal_Sym **local_syms,
7696                   struct elf_link_hash_entry *h,
7697                   Elf_Internal_Sym *sym)
7698 {
7699   enum elf_ppc64_reloc_type r_type;
7700   asection *sym_sec = NULL;
7701
7702   /* Can this reloc be dynamic?  This switch, and later tests here
7703      should be kept in sync with the code in check_relocs.  */
7704   r_type = ELF64_R_TYPE (r_info);
7705   switch (r_type)
7706     {
7707     default:
7708       return TRUE;
7709
7710     case R_PPC64_TPREL16:
7711     case R_PPC64_TPREL16_LO:
7712     case R_PPC64_TPREL16_HI:
7713     case R_PPC64_TPREL16_HA:
7714     case R_PPC64_TPREL16_DS:
7715     case R_PPC64_TPREL16_LO_DS:
7716     case R_PPC64_TPREL16_HIGH:
7717     case R_PPC64_TPREL16_HIGHA:
7718     case R_PPC64_TPREL16_HIGHER:
7719     case R_PPC64_TPREL16_HIGHERA:
7720     case R_PPC64_TPREL16_HIGHEST:
7721     case R_PPC64_TPREL16_HIGHESTA:
7722       if (!bfd_link_pic (info))
7723         return TRUE;
7724
7725     case R_PPC64_TPREL64:
7726     case R_PPC64_DTPMOD64:
7727     case R_PPC64_DTPREL64:
7728     case R_PPC64_ADDR64:
7729     case R_PPC64_REL30:
7730     case R_PPC64_REL32:
7731     case R_PPC64_REL64:
7732     case R_PPC64_ADDR14:
7733     case R_PPC64_ADDR14_BRNTAKEN:
7734     case R_PPC64_ADDR14_BRTAKEN:
7735     case R_PPC64_ADDR16:
7736     case R_PPC64_ADDR16_DS:
7737     case R_PPC64_ADDR16_HA:
7738     case R_PPC64_ADDR16_HI:
7739     case R_PPC64_ADDR16_HIGH:
7740     case R_PPC64_ADDR16_HIGHA:
7741     case R_PPC64_ADDR16_HIGHER:
7742     case R_PPC64_ADDR16_HIGHERA:
7743     case R_PPC64_ADDR16_HIGHEST:
7744     case R_PPC64_ADDR16_HIGHESTA:
7745     case R_PPC64_ADDR16_LO:
7746     case R_PPC64_ADDR16_LO_DS:
7747     case R_PPC64_ADDR24:
7748     case R_PPC64_ADDR32:
7749     case R_PPC64_UADDR16:
7750     case R_PPC64_UADDR32:
7751     case R_PPC64_UADDR64:
7752     case R_PPC64_TOC:
7753       break;
7754     }
7755
7756   if (local_syms != NULL)
7757     {
7758       unsigned long r_symndx;
7759       bfd *ibfd = sec->owner;
7760
7761       r_symndx = ELF64_R_SYM (r_info);
7762       if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7763         return FALSE;
7764     }
7765
7766   if ((bfd_link_pic (info)
7767        && (must_be_dyn_reloc (info, r_type)
7768            || (h != NULL
7769                && (!SYMBOLIC_BIND (info, h)
7770                    || h->root.type == bfd_link_hash_defweak
7771                    || !h->def_regular))))
7772       || (ELIMINATE_COPY_RELOCS
7773           && !bfd_link_pic (info)
7774           && h != NULL
7775           && (h->root.type == bfd_link_hash_defweak
7776               || !h->def_regular)))
7777     ;
7778   else
7779     return TRUE;
7780
7781   if (h != NULL)
7782     {
7783       struct elf_dyn_relocs *p;
7784       struct elf_dyn_relocs **pp;
7785       pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7786
7787       /* elf_gc_sweep may have already removed all dyn relocs associated
7788          with local syms for a given section.  Also, symbol flags are
7789          changed by elf_gc_sweep_symbol, confusing the test above.  Don't
7790          report a dynreloc miscount.  */
7791       if (*pp == NULL && info->gc_sections)
7792         return TRUE;
7793
7794       while ((p = *pp) != NULL)
7795         {
7796           if (p->sec == sec)
7797             {
7798               if (!must_be_dyn_reloc (info, r_type))
7799                 p->pc_count -= 1;
7800               p->count -= 1;
7801               if (p->count == 0)
7802                 *pp = p->next;
7803               return TRUE;
7804             }
7805           pp = &p->next;
7806         }
7807     }
7808   else
7809     {
7810       struct ppc_dyn_relocs *p;
7811       struct ppc_dyn_relocs **pp;
7812       void *vpp;
7813       bfd_boolean is_ifunc;
7814
7815       if (local_syms == NULL)
7816         sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7817       if (sym_sec == NULL)
7818         sym_sec = sec;
7819
7820       vpp = &elf_section_data (sym_sec)->local_dynrel;
7821       pp = (struct ppc_dyn_relocs **) vpp;
7822
7823       if (*pp == NULL && info->gc_sections)
7824         return TRUE;
7825
7826       is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7827       while ((p = *pp) != NULL)
7828         {
7829           if (p->sec == sec && p->ifunc == is_ifunc)
7830             {
7831               p->count -= 1;
7832               if (p->count == 0)
7833                 *pp = p->next;
7834               return TRUE;
7835             }
7836           pp = &p->next;
7837         }
7838     }
7839
7840   /* xgettext:c-format */
7841   info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7842                           sec->owner, sec);
7843   bfd_set_error (bfd_error_bad_value);
7844   return FALSE;
7845 }
7846
7847 /* Remove unused Official Procedure Descriptor entries.  Currently we
7848    only remove those associated with functions in discarded link-once
7849    sections, or weakly defined functions that have been overridden.  It
7850    would be possible to remove many more entries for statically linked
7851    applications.  */
7852
7853 bfd_boolean
7854 ppc64_elf_edit_opd (struct bfd_link_info *info)
7855 {
7856   bfd *ibfd;
7857   bfd_boolean some_edited = FALSE;
7858   asection *need_pad = NULL;
7859   struct ppc_link_hash_table *htab;
7860
7861   htab = ppc_hash_table (info);
7862   if (htab == NULL)
7863     return FALSE;
7864
7865   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
7866     {
7867       asection *sec;
7868       Elf_Internal_Rela *relstart, *rel, *relend;
7869       Elf_Internal_Shdr *symtab_hdr;
7870       Elf_Internal_Sym *local_syms;
7871       struct _opd_sec_data *opd;
7872       bfd_boolean need_edit, add_aux_fields, broken;
7873       bfd_size_type cnt_16b = 0;
7874
7875       if (!is_ppc64_elf (ibfd))
7876         continue;
7877
7878       sec = bfd_get_section_by_name (ibfd, ".opd");
7879       if (sec == NULL || sec->size == 0)
7880         continue;
7881
7882       if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7883         continue;
7884
7885       if (sec->output_section == bfd_abs_section_ptr)
7886         continue;
7887
7888       /* Look through the section relocs.  */
7889       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7890         continue;
7891
7892       local_syms = NULL;
7893       symtab_hdr = &elf_symtab_hdr (ibfd);
7894
7895       /* Read the relocations.  */
7896       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7897                                             info->keep_memory);
7898       if (relstart == NULL)
7899         return FALSE;
7900
7901       /* First run through the relocs to check they are sane, and to
7902          determine whether we need to edit this opd section.  */
7903       need_edit = FALSE;
7904       broken = FALSE;
7905       need_pad = sec;
7906       relend = relstart + sec->reloc_count;
7907       for (rel = relstart; rel < relend; )
7908         {
7909           enum elf_ppc64_reloc_type r_type;
7910           unsigned long r_symndx;
7911           asection *sym_sec;
7912           struct elf_link_hash_entry *h;
7913           Elf_Internal_Sym *sym;
7914           bfd_vma offset;
7915
7916           /* .opd contains an array of 16 or 24 byte entries.  We're
7917              only interested in the reloc pointing to a function entry
7918              point.  */
7919           offset = rel->r_offset;
7920           if (rel + 1 == relend
7921               || rel[1].r_offset != offset + 8)
7922             {
7923               /* If someone messes with .opd alignment then after a
7924                  "ld -r" we might have padding in the middle of .opd.
7925                  Also, there's nothing to prevent someone putting
7926                  something silly in .opd with the assembler.  No .opd
7927                  optimization for them!  */
7928             broken_opd:
7929               _bfd_error_handler
7930                 (_("%B: .opd is not a regular array of opd entries"), ibfd);
7931               broken = TRUE;
7932               break;
7933             }
7934
7935           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7936               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7937             {
7938               _bfd_error_handler
7939                 /* xgettext:c-format */
7940                 (_("%B: unexpected reloc type %u in .opd section"),
7941                  ibfd, r_type);
7942               broken = TRUE;
7943               break;
7944             }
7945
7946           r_symndx = ELF64_R_SYM (rel->r_info);
7947           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7948                           r_symndx, ibfd))
7949             goto error_ret;
7950
7951           if (sym_sec == NULL || sym_sec->owner == NULL)
7952             {
7953               const char *sym_name;
7954               if (h != NULL)
7955                 sym_name = h->root.root.string;
7956               else
7957                 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7958                                              sym_sec);
7959
7960               _bfd_error_handler
7961                 /* xgettext:c-format */
7962                 (_("%B: undefined sym `%s' in .opd section"),
7963                  ibfd, sym_name);
7964               broken = TRUE;
7965               break;
7966             }
7967
7968           /* opd entries are always for functions defined in the
7969              current input bfd.  If the symbol isn't defined in the
7970              input bfd, then we won't be using the function in this
7971              bfd;  It must be defined in a linkonce section in another
7972              bfd, or is weak.  It's also possible that we are
7973              discarding the function due to a linker script /DISCARD/,
7974              which we test for via the output_section.  */
7975           if (sym_sec->owner != ibfd
7976               || sym_sec->output_section == bfd_abs_section_ptr)
7977             need_edit = TRUE;
7978
7979           rel += 2;
7980           if (rel + 1 == relend
7981               || (rel + 2 < relend
7982                   && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC))
7983             ++rel;
7984
7985           if (rel == relend)
7986             {
7987               if (sec->size == offset + 24)
7988                 {
7989                   need_pad = NULL;
7990                   break;
7991                 }
7992               if (sec->size == offset + 16)
7993                 {
7994                   cnt_16b++;
7995                   break;
7996                 }
7997               goto broken_opd;
7998             }
7999           else if (rel + 1 < relend
8000                    && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
8001                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
8002             {
8003               if (rel[0].r_offset == offset + 16)
8004                 cnt_16b++;
8005               else if (rel[0].r_offset != offset + 24)
8006                 goto broken_opd;
8007             }
8008           else
8009             goto broken_opd;
8010         }
8011
8012       add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
8013
8014       if (!broken && (need_edit || add_aux_fields))
8015         {
8016           Elf_Internal_Rela *write_rel;
8017           Elf_Internal_Shdr *rel_hdr;
8018           bfd_byte *rptr, *wptr;
8019           bfd_byte *new_contents;
8020           bfd_size_type amt;
8021
8022           new_contents = NULL;
8023           amt = OPD_NDX (sec->size) * sizeof (long);
8024           opd = &ppc64_elf_section_data (sec)->u.opd;
8025           opd->adjust = bfd_zalloc (sec->owner, amt);
8026           if (opd->adjust == NULL)
8027             return FALSE;
8028           ppc64_elf_section_data (sec)->sec_type = sec_opd;
8029
8030           /* This seems a waste of time as input .opd sections are all
8031              zeros as generated by gcc, but I suppose there's no reason
8032              this will always be so.  We might start putting something in
8033              the third word of .opd entries.  */
8034           if ((sec->flags & SEC_IN_MEMORY) == 0)
8035             {
8036               bfd_byte *loc;
8037               if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
8038                 {
8039                   if (loc != NULL)
8040                     free (loc);
8041                 error_ret:
8042                   if (local_syms != NULL
8043                       && symtab_hdr->contents != (unsigned char *) local_syms)
8044                     free (local_syms);
8045                   if (elf_section_data (sec)->relocs != relstart)
8046                     free (relstart);
8047                   return FALSE;
8048                 }
8049               sec->contents = loc;
8050               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8051             }
8052
8053           elf_section_data (sec)->relocs = relstart;
8054
8055           new_contents = sec->contents;
8056           if (add_aux_fields)
8057             {
8058               new_contents = bfd_malloc (sec->size + cnt_16b * 8);
8059               if (new_contents == NULL)
8060                 return FALSE;
8061               need_pad = NULL;
8062             }
8063           wptr = new_contents;
8064           rptr = sec->contents;
8065           write_rel = relstart;
8066           for (rel = relstart; rel < relend; )
8067             {
8068               unsigned long r_symndx;
8069               asection *sym_sec;
8070               struct elf_link_hash_entry *h;
8071               struct ppc_link_hash_entry *fdh = NULL;
8072               Elf_Internal_Sym *sym;
8073               long opd_ent_size;
8074               Elf_Internal_Rela *next_rel;
8075               bfd_boolean skip;
8076
8077               r_symndx = ELF64_R_SYM (rel->r_info);
8078               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8079                               r_symndx, ibfd))
8080                 goto error_ret;
8081
8082               next_rel = rel + 2;
8083               if (next_rel + 1 == relend
8084                   || (next_rel + 2 < relend
8085                       && ELF64_R_TYPE (next_rel[2].r_info) == R_PPC64_TOC))
8086                 ++next_rel;
8087
8088               /* See if the .opd entry is full 24 byte or
8089                  16 byte (with fd_aux entry overlapped with next
8090                  fd_func).  */
8091               opd_ent_size = 24;
8092               if (next_rel == relend)
8093                 {
8094                   if (sec->size == rel->r_offset + 16)
8095                     opd_ent_size = 16;
8096                 }
8097               else if (next_rel->r_offset == rel->r_offset + 16)
8098                 opd_ent_size = 16;
8099
8100               if (h != NULL
8101                   && h->root.root.string[0] == '.')
8102                 {
8103                   fdh = lookup_fdh ((struct ppc_link_hash_entry *) h, htab);
8104                   if (fdh != NULL
8105                       && fdh->elf.root.type != bfd_link_hash_defined
8106                       && fdh->elf.root.type != bfd_link_hash_defweak)
8107                     fdh = NULL;
8108                 }
8109
8110               skip = (sym_sec->owner != ibfd
8111                       || sym_sec->output_section == bfd_abs_section_ptr);
8112               if (skip)
8113                 {
8114                   if (fdh != NULL && sym_sec->owner == ibfd)
8115                     {
8116                       /* Arrange for the function descriptor sym
8117                          to be dropped.  */
8118                       fdh->elf.root.u.def.value = 0;
8119                       fdh->elf.root.u.def.section = sym_sec;
8120                     }
8121                   opd->adjust[OPD_NDX (rel->r_offset)] = -1;
8122
8123                   if (NO_OPD_RELOCS || bfd_link_relocatable (info))
8124                     rel = next_rel;
8125                   else
8126                     while (1)
8127                       {
8128                         if (!dec_dynrel_count (rel->r_info, sec, info,
8129                                                NULL, h, sym))
8130                           goto error_ret;
8131
8132                         if (++rel == next_rel)
8133                           break;
8134
8135                         r_symndx = ELF64_R_SYM (rel->r_info);
8136                         if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8137                                         r_symndx, ibfd))
8138                           goto error_ret;
8139                       }
8140                 }
8141               else
8142                 {
8143                   /* We'll be keeping this opd entry.  */
8144                   long adjust;
8145
8146                   if (fdh != NULL)
8147                     {
8148                       /* Redefine the function descriptor symbol to
8149                          this location in the opd section.  It is
8150                          necessary to update the value here rather
8151                          than using an array of adjustments as we do
8152                          for local symbols, because various places
8153                          in the generic ELF code use the value
8154                          stored in u.def.value.  */
8155                       fdh->elf.root.u.def.value = wptr - new_contents;
8156                       fdh->adjust_done = 1;
8157                     }
8158
8159                   /* Local syms are a bit tricky.  We could
8160                      tweak them as they can be cached, but
8161                      we'd need to look through the local syms
8162                      for the function descriptor sym which we
8163                      don't have at the moment.  So keep an
8164                      array of adjustments.  */
8165                   adjust = (wptr - new_contents) - (rptr - sec->contents);
8166                   opd->adjust[OPD_NDX (rel->r_offset)] = adjust;
8167
8168                   if (wptr != rptr)
8169                     memcpy (wptr, rptr, opd_ent_size);
8170                   wptr += opd_ent_size;
8171                   if (add_aux_fields && opd_ent_size == 16)
8172                     {
8173                       memset (wptr, '\0', 8);
8174                       wptr += 8;
8175                     }
8176
8177                   /* We need to adjust any reloc offsets to point to the
8178                      new opd entries.  */
8179                   for ( ; rel != next_rel; ++rel)
8180                     {
8181                       rel->r_offset += adjust;
8182                       if (write_rel != rel)
8183                         memcpy (write_rel, rel, sizeof (*rel));
8184                       ++write_rel;
8185                     }
8186                 }
8187
8188               rptr += opd_ent_size;
8189             }
8190
8191           sec->size = wptr - new_contents;
8192           sec->reloc_count = write_rel - relstart;
8193           if (add_aux_fields)
8194             {
8195               free (sec->contents);
8196               sec->contents = new_contents;
8197             }
8198
8199           /* Fudge the header size too, as this is used later in
8200              elf_bfd_final_link if we are emitting relocs.  */
8201           rel_hdr = _bfd_elf_single_rel_hdr (sec);
8202           rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
8203           some_edited = TRUE;
8204         }
8205       else if (elf_section_data (sec)->relocs != relstart)
8206         free (relstart);
8207
8208       if (local_syms != NULL
8209           && symtab_hdr->contents != (unsigned char *) local_syms)
8210         {
8211           if (!info->keep_memory)
8212             free (local_syms);
8213           else
8214             symtab_hdr->contents = (unsigned char *) local_syms;
8215         }
8216     }
8217
8218   if (some_edited)
8219     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
8220
8221   /* If we are doing a final link and the last .opd entry is just 16 byte
8222      long, add a 8 byte padding after it.  */
8223   if (need_pad != NULL && !bfd_link_relocatable (info))
8224     {
8225       bfd_byte *p;
8226
8227       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
8228         {
8229           BFD_ASSERT (need_pad->size > 0);
8230
8231           p = bfd_malloc (need_pad->size + 8);
8232           if (p == NULL)
8233             return FALSE;
8234
8235           if (! bfd_get_section_contents (need_pad->owner, need_pad,
8236                                           p, 0, need_pad->size))
8237             return FALSE;
8238
8239           need_pad->contents = p;
8240           need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8241         }
8242       else
8243         {
8244           p = bfd_realloc (need_pad->contents, need_pad->size + 8);
8245           if (p == NULL)
8246             return FALSE;
8247
8248           need_pad->contents = p;
8249         }
8250
8251       memset (need_pad->contents + need_pad->size, 0, 8);
8252       need_pad->size += 8;
8253     }
8254
8255   return TRUE;
8256 }
8257
8258 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
8259
8260 asection *
8261 ppc64_elf_tls_setup (struct bfd_link_info *info)
8262 {
8263   struct ppc_link_hash_table *htab;
8264
8265   htab = ppc_hash_table (info);
8266   if (htab == NULL)
8267     return NULL;
8268
8269   if (abiversion (info->output_bfd) == 1)
8270     htab->opd_abi = 1;
8271
8272   if (htab->params->no_multi_toc)
8273     htab->do_multi_toc = 0;
8274   else if (!htab->do_multi_toc)
8275     htab->params->no_multi_toc = 1;
8276
8277   htab->tls_get_addr = ((struct ppc_link_hash_entry *)
8278                         elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
8279                                               FALSE, FALSE, TRUE));
8280   /* Move dynamic linking info to the function descriptor sym.  */
8281   if (htab->tls_get_addr != NULL)
8282     func_desc_adjust (&htab->tls_get_addr->elf, info);
8283   htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
8284                            elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
8285                                                  FALSE, FALSE, TRUE));
8286   if (htab->params->tls_get_addr_opt)
8287     {
8288       struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
8289
8290       opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
8291                                   FALSE, FALSE, TRUE);
8292       if (opt != NULL)
8293         func_desc_adjust (opt, info);
8294       opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
8295                                      FALSE, FALSE, TRUE);
8296       if (opt_fd != NULL
8297           && (opt_fd->root.type == bfd_link_hash_defined
8298               || opt_fd->root.type == bfd_link_hash_defweak))
8299         {
8300           /* If glibc supports an optimized __tls_get_addr call stub,
8301              signalled by the presence of __tls_get_addr_opt, and we'll
8302              be calling __tls_get_addr via a plt call stub, then
8303              make __tls_get_addr point to __tls_get_addr_opt.  */
8304           tga_fd = &htab->tls_get_addr_fd->elf;
8305           if (htab->elf.dynamic_sections_created
8306               && tga_fd != NULL
8307               && (tga_fd->type == STT_FUNC
8308                   || tga_fd->needs_plt)
8309               && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
8310                    || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
8311                        && tga_fd->root.type == bfd_link_hash_undefweak)))
8312             {
8313               struct plt_entry *ent;
8314
8315               for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
8316                 if (ent->plt.refcount > 0)
8317                   break;
8318               if (ent != NULL)
8319                 {
8320                   tga_fd->root.type = bfd_link_hash_indirect;
8321                   tga_fd->root.u.i.link = &opt_fd->root;
8322                   ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
8323                   opt_fd->forced_local = 0;
8324                   if (opt_fd->dynindx != -1)
8325                     {
8326                       /* Use __tls_get_addr_opt in dynamic relocations.  */
8327                       opt_fd->dynindx = -1;
8328                       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8329                                               opt_fd->dynstr_index);
8330                       if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8331                         return NULL;
8332                     }
8333                   htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8334                   tga = &htab->tls_get_addr->elf;
8335                   if (opt != NULL && tga != NULL)
8336                     {
8337                       tga->root.type = bfd_link_hash_indirect;
8338                       tga->root.u.i.link = &opt->root;
8339                       ppc64_elf_copy_indirect_symbol (info, opt, tga);
8340                       opt->forced_local = 0;
8341                       _bfd_elf_link_hash_hide_symbol (info, opt,
8342                                                       tga->forced_local);
8343                       htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8344                     }
8345                   htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8346                   htab->tls_get_addr_fd->is_func_descriptor = 1;
8347                   if (htab->tls_get_addr != NULL)
8348                     {
8349                       htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8350                       htab->tls_get_addr->is_func = 1;
8351                     }
8352                 }
8353             }
8354         }
8355       else if (htab->params->tls_get_addr_opt < 0)
8356         htab->params->tls_get_addr_opt = 0;
8357     }
8358   return _bfd_elf_tls_setup (info->output_bfd, info);
8359 }
8360
8361 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8362    HASH1 or HASH2.  */
8363
8364 static bfd_boolean
8365 branch_reloc_hash_match (const bfd *ibfd,
8366                          const Elf_Internal_Rela *rel,
8367                          const struct ppc_link_hash_entry *hash1,
8368                          const struct ppc_link_hash_entry *hash2)
8369 {
8370   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8371   enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8372   unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8373
8374   if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8375     {
8376       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8377       struct elf_link_hash_entry *h;
8378
8379       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8380       h = elf_follow_link (h);
8381       if (h == &hash1->elf || h == &hash2->elf)
8382         return TRUE;
8383     }
8384   return FALSE;
8385 }
8386
8387 /* Run through all the TLS relocs looking for optimization
8388    opportunities.  The linker has been hacked (see ppc64elf.em) to do
8389    a preliminary section layout so that we know the TLS segment
8390    offsets.  We can't optimize earlier because some optimizations need
8391    to know the tp offset, and we need to optimize before allocating
8392    dynamic relocations.  */
8393
8394 bfd_boolean
8395 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8396 {
8397   bfd *ibfd;
8398   asection *sec;
8399   struct ppc_link_hash_table *htab;
8400   unsigned char *toc_ref;
8401   int pass;
8402
8403   if (!bfd_link_executable (info))
8404     return TRUE;
8405
8406   htab = ppc_hash_table (info);
8407   if (htab == NULL)
8408     return FALSE;
8409
8410   /* Make two passes over the relocs.  On the first pass, mark toc
8411      entries involved with tls relocs, and check that tls relocs
8412      involved in setting up a tls_get_addr call are indeed followed by
8413      such a call.  If they are not, we can't do any tls optimization.
8414      On the second pass twiddle tls_mask flags to notify
8415      relocate_section that optimization can be done, and adjust got
8416      and plt refcounts.  */
8417   toc_ref = NULL;
8418   for (pass = 0; pass < 2; ++pass)
8419     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8420       {
8421         Elf_Internal_Sym *locsyms = NULL;
8422         asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8423
8424         for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8425           if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8426             {
8427               Elf_Internal_Rela *relstart, *rel, *relend;
8428               bfd_boolean found_tls_get_addr_arg = 0;
8429
8430               /* Read the relocations.  */
8431               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8432                                                     info->keep_memory);
8433               if (relstart == NULL)
8434                 {
8435                   free (toc_ref);
8436                   return FALSE;
8437                 }
8438
8439               relend = relstart + sec->reloc_count;
8440               for (rel = relstart; rel < relend; rel++)
8441                 {
8442                   enum elf_ppc64_reloc_type r_type;
8443                   unsigned long r_symndx;
8444                   struct elf_link_hash_entry *h;
8445                   Elf_Internal_Sym *sym;
8446                   asection *sym_sec;
8447                   unsigned char *tls_mask;
8448                   unsigned char tls_set, tls_clear, tls_type = 0;
8449                   bfd_vma value;
8450                   bfd_boolean ok_tprel, is_local;
8451                   long toc_ref_index = 0;
8452                   int expecting_tls_get_addr = 0;
8453                   bfd_boolean ret = FALSE;
8454
8455                   r_symndx = ELF64_R_SYM (rel->r_info);
8456                   if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8457                                   r_symndx, ibfd))
8458                     {
8459                     err_free_rel:
8460                       if (elf_section_data (sec)->relocs != relstart)
8461                         free (relstart);
8462                       if (toc_ref != NULL)
8463                         free (toc_ref);
8464                       if (locsyms != NULL
8465                           && (elf_symtab_hdr (ibfd).contents
8466                               != (unsigned char *) locsyms))
8467                         free (locsyms);
8468                       return ret;
8469                     }
8470
8471                   if (h != NULL)
8472                     {
8473                       if (h->root.type == bfd_link_hash_defined
8474                           || h->root.type == bfd_link_hash_defweak)
8475                         value = h->root.u.def.value;
8476                       else if (h->root.type == bfd_link_hash_undefweak)
8477                         value = 0;
8478                       else
8479                         {
8480                           found_tls_get_addr_arg = 0;
8481                           continue;
8482                         }
8483                     }
8484                   else
8485                     /* Symbols referenced by TLS relocs must be of type
8486                        STT_TLS.  So no need for .opd local sym adjust.  */
8487                     value = sym->st_value;
8488
8489                   ok_tprel = FALSE;
8490                   is_local = FALSE;
8491                   if (h == NULL
8492                       || !h->def_dynamic)
8493                     {
8494                       is_local = TRUE;
8495                       if (h != NULL
8496                           && h->root.type == bfd_link_hash_undefweak)
8497                         ok_tprel = TRUE;
8498                       else if (sym_sec != NULL
8499                                && sym_sec->output_section != NULL)
8500                         {
8501                           value += sym_sec->output_offset;
8502                           value += sym_sec->output_section->vma;
8503                           value -= htab->elf.tls_sec->vma;
8504                           ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8505                                       < (bfd_vma) 1 << 32);
8506                         }
8507                     }
8508
8509                   r_type = ELF64_R_TYPE (rel->r_info);
8510                   /* If this section has old-style __tls_get_addr calls
8511                      without marker relocs, then check that each
8512                      __tls_get_addr call reloc is preceded by a reloc
8513                      that conceivably belongs to the __tls_get_addr arg
8514                      setup insn.  If we don't find matching arg setup
8515                      relocs, don't do any tls optimization.  */
8516                   if (pass == 0
8517                       && sec->has_tls_get_addr_call
8518                       && h != NULL
8519                       && (h == &htab->tls_get_addr->elf
8520                           || h == &htab->tls_get_addr_fd->elf)
8521                       && !found_tls_get_addr_arg
8522                       && is_branch_reloc (r_type))
8523                     {
8524                       info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8525                                                 "TLS optimization disabled\n"),
8526                                               ibfd, sec, rel->r_offset);
8527                       ret = TRUE;
8528                       goto err_free_rel;
8529                     }
8530
8531                   found_tls_get_addr_arg = 0;
8532                   switch (r_type)
8533                     {
8534                     case R_PPC64_GOT_TLSLD16:
8535                     case R_PPC64_GOT_TLSLD16_LO:
8536                       expecting_tls_get_addr = 1;
8537                       found_tls_get_addr_arg = 1;
8538                       /* Fall through.  */
8539
8540                     case R_PPC64_GOT_TLSLD16_HI:
8541                     case R_PPC64_GOT_TLSLD16_HA:
8542                       /* These relocs should never be against a symbol
8543                          defined in a shared lib.  Leave them alone if
8544                          that turns out to be the case.  */
8545                       if (!is_local)
8546                         continue;
8547
8548                       /* LD -> LE */
8549                       tls_set = 0;
8550                       tls_clear = TLS_LD;
8551                       tls_type = TLS_TLS | TLS_LD;
8552                       break;
8553
8554                     case R_PPC64_GOT_TLSGD16:
8555                     case R_PPC64_GOT_TLSGD16_LO:
8556                       expecting_tls_get_addr = 1;
8557                       found_tls_get_addr_arg = 1;
8558                       /* Fall through. */
8559
8560                     case R_PPC64_GOT_TLSGD16_HI:
8561                     case R_PPC64_GOT_TLSGD16_HA:
8562                       if (ok_tprel)
8563                         /* GD -> LE */
8564                         tls_set = 0;
8565                       else
8566                         /* GD -> IE */
8567                         tls_set = TLS_TLS | TLS_TPRELGD;
8568                       tls_clear = TLS_GD;
8569                       tls_type = TLS_TLS | TLS_GD;
8570                       break;
8571
8572                     case R_PPC64_GOT_TPREL16_DS:
8573                     case R_PPC64_GOT_TPREL16_LO_DS:
8574                     case R_PPC64_GOT_TPREL16_HI:
8575                     case R_PPC64_GOT_TPREL16_HA:
8576                       if (ok_tprel)
8577                         {
8578                           /* IE -> LE */
8579                           tls_set = 0;
8580                           tls_clear = TLS_TPREL;
8581                           tls_type = TLS_TLS | TLS_TPREL;
8582                           break;
8583                         }
8584                       continue;
8585
8586                     case R_PPC64_TLSGD:
8587                     case R_PPC64_TLSLD:
8588                       found_tls_get_addr_arg = 1;
8589                       /* Fall through.  */
8590
8591                     case R_PPC64_TLS:
8592                     case R_PPC64_TOC16:
8593                     case R_PPC64_TOC16_LO:
8594                       if (sym_sec == NULL || sym_sec != toc)
8595                         continue;
8596
8597                       /* Mark this toc entry as referenced by a TLS
8598                          code sequence.  We can do that now in the
8599                          case of R_PPC64_TLS, and after checking for
8600                          tls_get_addr for the TOC16 relocs.  */
8601                       if (toc_ref == NULL)
8602                         toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8603                       if (toc_ref == NULL)
8604                         goto err_free_rel;
8605
8606                       if (h != NULL)
8607                         value = h->root.u.def.value;
8608                       else
8609                         value = sym->st_value;
8610                       value += rel->r_addend;
8611                       if (value % 8 != 0)
8612                         continue;
8613                       BFD_ASSERT (value < toc->size
8614                                   && toc->output_offset % 8 == 0);
8615                       toc_ref_index = (value + toc->output_offset) / 8;
8616                       if (r_type == R_PPC64_TLS
8617                           || r_type == R_PPC64_TLSGD
8618                           || r_type == R_PPC64_TLSLD)
8619                         {
8620                           toc_ref[toc_ref_index] = 1;
8621                           continue;
8622                         }
8623
8624                       if (pass != 0 && toc_ref[toc_ref_index] == 0)
8625                         continue;
8626
8627                       tls_set = 0;
8628                       tls_clear = 0;
8629                       expecting_tls_get_addr = 2;
8630                       break;
8631
8632                     case R_PPC64_TPREL64:
8633                       if (pass == 0
8634                           || sec != toc
8635                           || toc_ref == NULL
8636                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8637                         continue;
8638                       if (ok_tprel)
8639                         {
8640                           /* IE -> LE */
8641                           tls_set = TLS_EXPLICIT;
8642                           tls_clear = TLS_TPREL;
8643                           break;
8644                         }
8645                       continue;
8646
8647                     case R_PPC64_DTPMOD64:
8648                       if (pass == 0
8649                           || sec != toc
8650                           || toc_ref == NULL
8651                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8652                         continue;
8653                       if (rel + 1 < relend
8654                           && (rel[1].r_info
8655                               == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8656                           && rel[1].r_offset == rel->r_offset + 8)
8657                         {
8658                           if (ok_tprel)
8659                             /* GD -> LE */
8660                             tls_set = TLS_EXPLICIT | TLS_GD;
8661                           else
8662                             /* GD -> IE */
8663                             tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8664                           tls_clear = TLS_GD;
8665                         }
8666                       else
8667                         {
8668                           if (!is_local)
8669                             continue;
8670
8671                           /* LD -> LE */
8672                           tls_set = TLS_EXPLICIT;
8673                           tls_clear = TLS_LD;
8674                         }
8675                       break;
8676
8677                     default:
8678                       continue;
8679                     }
8680
8681                   if (pass == 0)
8682                     {
8683                       if (!expecting_tls_get_addr
8684                           || !sec->has_tls_get_addr_call)
8685                         continue;
8686
8687                       if (rel + 1 < relend
8688                           && branch_reloc_hash_match (ibfd, rel + 1,
8689                                                       htab->tls_get_addr,
8690                                                       htab->tls_get_addr_fd))
8691                         {
8692                           if (expecting_tls_get_addr == 2)
8693                             {
8694                               /* Check for toc tls entries.  */
8695                               unsigned char *toc_tls;
8696                               int retval;
8697
8698                               retval = get_tls_mask (&toc_tls, NULL, NULL,
8699                                                      &locsyms,
8700                                                      rel, ibfd);
8701                               if (retval == 0)
8702                                 goto err_free_rel;
8703                               if (toc_tls != NULL)
8704                                 {
8705                                   if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8706                                     found_tls_get_addr_arg = 1;
8707                                   if (retval > 1)
8708                                     toc_ref[toc_ref_index] = 1;
8709                                 }
8710                             }
8711                           continue;
8712                         }
8713
8714                       if (expecting_tls_get_addr != 1)
8715                         continue;
8716
8717                       /* Uh oh, we didn't find the expected call.  We
8718                          could just mark this symbol to exclude it
8719                          from tls optimization but it's safer to skip
8720                          the entire optimization.  */
8721                       /* xgettext:c-format */
8722                       info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8723                                                 "TLS optimization disabled\n"),
8724                                               ibfd, sec, rel->r_offset);
8725                       ret = TRUE;
8726                       goto err_free_rel;
8727                     }
8728
8729                   if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8730                     {
8731                       struct plt_entry *ent;
8732                       for (ent = htab->tls_get_addr->elf.plt.plist;
8733                            ent != NULL;
8734                            ent = ent->next)
8735                         if (ent->addend == 0)
8736                           {
8737                             if (ent->plt.refcount > 0)
8738                               {
8739                                 ent->plt.refcount -= 1;
8740                                 expecting_tls_get_addr = 0;
8741                               }
8742                             break;
8743                           }
8744                     }
8745
8746                   if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8747                     {
8748                       struct plt_entry *ent;
8749                       for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8750                            ent != NULL;
8751                            ent = ent->next)
8752                         if (ent->addend == 0)
8753                           {
8754                             if (ent->plt.refcount > 0)
8755                               ent->plt.refcount -= 1;
8756                             break;
8757                           }
8758                     }
8759
8760                   if (tls_clear == 0)
8761                     continue;
8762
8763                   if ((tls_set & TLS_EXPLICIT) == 0)
8764                     {
8765                       struct got_entry *ent;
8766
8767                       /* Adjust got entry for this reloc.  */
8768                       if (h != NULL)
8769                         ent = h->got.glist;
8770                       else
8771                         ent = elf_local_got_ents (ibfd)[r_symndx];
8772
8773                       for (; ent != NULL; ent = ent->next)
8774                         if (ent->addend == rel->r_addend
8775                             && ent->owner == ibfd
8776                             && ent->tls_type == tls_type)
8777                           break;
8778                       if (ent == NULL)
8779                         abort ();
8780
8781                       if (tls_set == 0)
8782                         {
8783                           /* We managed to get rid of a got entry.  */
8784                           if (ent->got.refcount > 0)
8785                             ent->got.refcount -= 1;
8786                         }
8787                     }
8788                   else
8789                     {
8790                       /* If we got rid of a DTPMOD/DTPREL reloc pair then
8791                          we'll lose one or two dyn relocs.  */
8792                       if (!dec_dynrel_count (rel->r_info, sec, info,
8793                                              NULL, h, sym))
8794                         return FALSE;
8795
8796                       if (tls_set == (TLS_EXPLICIT | TLS_GD))
8797                         {
8798                           if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8799                                                  NULL, h, sym))
8800                             return FALSE;
8801                         }
8802                     }
8803
8804                   *tls_mask |= tls_set;
8805                   *tls_mask &= ~tls_clear;
8806                 }
8807
8808               if (elf_section_data (sec)->relocs != relstart)
8809                 free (relstart);
8810             }
8811
8812         if (locsyms != NULL
8813             && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8814           {
8815             if (!info->keep_memory)
8816               free (locsyms);
8817             else
8818               elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8819           }
8820       }
8821
8822   if (toc_ref != NULL)
8823     free (toc_ref);
8824   return TRUE;
8825 }
8826
8827 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8828    the values of any global symbols in a toc section that has been
8829    edited.  Globals in toc sections should be a rarity, so this function
8830    sets a flag if any are found in toc sections other than the one just
8831    edited, so that futher hash table traversals can be avoided.  */
8832
8833 struct adjust_toc_info
8834 {
8835   asection *toc;
8836   unsigned long *skip;
8837   bfd_boolean global_toc_syms;
8838 };
8839
8840 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8841
8842 static bfd_boolean
8843 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8844 {
8845   struct ppc_link_hash_entry *eh;
8846   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8847   unsigned long i;
8848
8849   if (h->root.type != bfd_link_hash_defined
8850       && h->root.type != bfd_link_hash_defweak)
8851     return TRUE;
8852
8853   eh = (struct ppc_link_hash_entry *) h;
8854   if (eh->adjust_done)
8855     return TRUE;
8856
8857   if (eh->elf.root.u.def.section == toc_inf->toc)
8858     {
8859       if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8860         i = toc_inf->toc->rawsize >> 3;
8861       else
8862         i = eh->elf.root.u.def.value >> 3;
8863
8864       if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8865         {
8866           _bfd_error_handler
8867             (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8868           do
8869             ++i;
8870           while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8871           eh->elf.root.u.def.value = (bfd_vma) i << 3;
8872         }
8873
8874       eh->elf.root.u.def.value -= toc_inf->skip[i];
8875       eh->adjust_done = 1;
8876     }
8877   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8878     toc_inf->global_toc_syms = TRUE;
8879
8880   return TRUE;
8881 }
8882
8883 /* Return TRUE iff INSN is one we expect on a _LO variety toc/got reloc.  */
8884
8885 static bfd_boolean
8886 ok_lo_toc_insn (unsigned int insn)
8887 {
8888   return ((insn & (0x3f << 26)) == 14u << 26 /* addi */
8889           || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8890           || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8891           || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8892           || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8893           || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8894           || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8895           || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8896           || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8897           || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8898           || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8899           || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8900           || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8901           || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8902           || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
8903               && (insn & 3) != 1)
8904           || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
8905               && ((insn & 3) == 0 || (insn & 3) == 3))
8906           || (insn & (0x3f << 26)) == 12u << 26 /* addic */);
8907 }
8908
8909 /* Examine all relocs referencing .toc sections in order to remove
8910    unused .toc entries.  */
8911
8912 bfd_boolean
8913 ppc64_elf_edit_toc (struct bfd_link_info *info)
8914 {
8915   bfd *ibfd;
8916   struct adjust_toc_info toc_inf;
8917   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8918
8919   htab->do_toc_opt = 1;
8920   toc_inf.global_toc_syms = TRUE;
8921   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8922     {
8923       asection *toc, *sec;
8924       Elf_Internal_Shdr *symtab_hdr;
8925       Elf_Internal_Sym *local_syms;
8926       Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8927       unsigned long *skip, *drop;
8928       unsigned char *used;
8929       unsigned char *keep, last, some_unused;
8930
8931       if (!is_ppc64_elf (ibfd))
8932         continue;
8933
8934       toc = bfd_get_section_by_name (ibfd, ".toc");
8935       if (toc == NULL
8936           || toc->size == 0
8937           || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8938           || discarded_section (toc))
8939         continue;
8940
8941       toc_relocs = NULL;
8942       local_syms = NULL;
8943       symtab_hdr = &elf_symtab_hdr (ibfd);
8944
8945       /* Look at sections dropped from the final link.  */
8946       skip = NULL;
8947       relstart = NULL;
8948       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8949         {
8950           if (sec->reloc_count == 0
8951               || !discarded_section (sec)
8952               || get_opd_info (sec)
8953               || (sec->flags & SEC_ALLOC) == 0
8954               || (sec->flags & SEC_DEBUGGING) != 0)
8955             continue;
8956
8957           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8958           if (relstart == NULL)
8959             goto error_ret;
8960
8961           /* Run through the relocs to see which toc entries might be
8962              unused.  */
8963           for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8964             {
8965               enum elf_ppc64_reloc_type r_type;
8966               unsigned long r_symndx;
8967               asection *sym_sec;
8968               struct elf_link_hash_entry *h;
8969               Elf_Internal_Sym *sym;
8970               bfd_vma val;
8971
8972               r_type = ELF64_R_TYPE (rel->r_info);
8973               switch (r_type)
8974                 {
8975                 default:
8976                   continue;
8977
8978                 case R_PPC64_TOC16:
8979                 case R_PPC64_TOC16_LO:
8980                 case R_PPC64_TOC16_HI:
8981                 case R_PPC64_TOC16_HA:
8982                 case R_PPC64_TOC16_DS:
8983                 case R_PPC64_TOC16_LO_DS:
8984                   break;
8985                 }
8986
8987               r_symndx = ELF64_R_SYM (rel->r_info);
8988               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8989                               r_symndx, ibfd))
8990                 goto error_ret;
8991
8992               if (sym_sec != toc)
8993                 continue;
8994
8995               if (h != NULL)
8996                 val = h->root.u.def.value;
8997               else
8998                 val = sym->st_value;
8999               val += rel->r_addend;
9000
9001               if (val >= toc->size)
9002                 continue;
9003
9004               /* Anything in the toc ought to be aligned to 8 bytes.
9005                  If not, don't mark as unused.  */
9006               if (val & 7)
9007                 continue;
9008
9009               if (skip == NULL)
9010                 {
9011                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9012                   if (skip == NULL)
9013                     goto error_ret;
9014                 }
9015
9016               skip[val >> 3] = ref_from_discarded;
9017             }
9018
9019           if (elf_section_data (sec)->relocs != relstart)
9020             free (relstart);
9021         }
9022
9023       /* For largetoc loads of address constants, we can convert
9024          .  addis rx,2,addr@got@ha
9025          .  ld ry,addr@got@l(rx)
9026          to
9027          .  addis rx,2,addr@toc@ha
9028          .  addi ry,rx,addr@toc@l
9029          when addr is within 2G of the toc pointer.  This then means
9030          that the word storing "addr" in the toc is no longer needed.  */
9031
9032       if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
9033           && toc->output_section->rawsize < (bfd_vma) 1 << 31
9034           && toc->reloc_count != 0)
9035         {
9036           /* Read toc relocs.  */
9037           toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9038                                                   info->keep_memory);
9039           if (toc_relocs == NULL)
9040             goto error_ret;
9041
9042           for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9043             {
9044               enum elf_ppc64_reloc_type r_type;
9045               unsigned long r_symndx;
9046               asection *sym_sec;
9047               struct elf_link_hash_entry *h;
9048               Elf_Internal_Sym *sym;
9049               bfd_vma val, addr;
9050
9051               r_type = ELF64_R_TYPE (rel->r_info);
9052               if (r_type != R_PPC64_ADDR64)
9053                 continue;
9054
9055               r_symndx = ELF64_R_SYM (rel->r_info);
9056               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9057                               r_symndx, ibfd))
9058                 goto error_ret;
9059
9060               if (sym_sec == NULL
9061                   || sym_sec->output_section == NULL
9062                   || discarded_section (sym_sec))
9063                 continue;
9064
9065               if (!SYMBOL_REFERENCES_LOCAL (info, h))
9066                 continue;
9067
9068               if (h != NULL)
9069                 {
9070                   if (h->type == STT_GNU_IFUNC)
9071                     continue;
9072                   val = h->root.u.def.value;
9073                 }
9074               else
9075                 {
9076                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
9077                     continue;
9078                   val = sym->st_value;
9079                 }
9080               val += rel->r_addend;
9081               val += sym_sec->output_section->vma + sym_sec->output_offset;
9082
9083               /* We don't yet know the exact toc pointer value, but we
9084                  know it will be somewhere in the toc section.  Don't
9085                  optimize if the difference from any possible toc
9086                  pointer is outside [ff..f80008000, 7fff7fff].  */
9087               addr = toc->output_section->vma + TOC_BASE_OFF;
9088               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9089                 continue;
9090
9091               addr = toc->output_section->vma + toc->output_section->rawsize;
9092               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9093                 continue;
9094
9095               if (skip == NULL)
9096                 {
9097                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9098                   if (skip == NULL)
9099                     goto error_ret;
9100                 }
9101
9102               skip[rel->r_offset >> 3]
9103                 |= can_optimize | ((rel - toc_relocs) << 2);
9104             }
9105         }
9106
9107       if (skip == NULL)
9108         continue;
9109
9110       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
9111       if (used == NULL)
9112         {
9113         error_ret:
9114           if (local_syms != NULL
9115               && symtab_hdr->contents != (unsigned char *) local_syms)
9116             free (local_syms);
9117           if (sec != NULL
9118               && relstart != NULL
9119               && elf_section_data (sec)->relocs != relstart)
9120             free (relstart);
9121           if (toc_relocs != NULL
9122               && elf_section_data (toc)->relocs != toc_relocs)
9123             free (toc_relocs);
9124           if (skip != NULL)
9125             free (skip);
9126           return FALSE;
9127         }
9128
9129       /* Now check all kept sections that might reference the toc.
9130          Check the toc itself last.  */
9131       for (sec = (ibfd->sections == toc && toc->next ? toc->next
9132                   : ibfd->sections);
9133            sec != NULL;
9134            sec = (sec == toc ? NULL
9135                   : sec->next == NULL ? toc
9136                   : sec->next == toc && toc->next ? toc->next
9137                   : sec->next))
9138         {
9139           int repeat;
9140
9141           if (sec->reloc_count == 0
9142               || discarded_section (sec)
9143               || get_opd_info (sec)
9144               || (sec->flags & SEC_ALLOC) == 0
9145               || (sec->flags & SEC_DEBUGGING) != 0)
9146             continue;
9147
9148           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9149                                                 info->keep_memory);
9150           if (relstart == NULL)
9151             {
9152               free (used);
9153               goto error_ret;
9154             }
9155
9156           /* Mark toc entries referenced as used.  */
9157           do
9158             {
9159               repeat = 0;
9160               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9161                 {
9162                   enum elf_ppc64_reloc_type r_type;
9163                   unsigned long r_symndx;
9164                   asection *sym_sec;
9165                   struct elf_link_hash_entry *h;
9166                   Elf_Internal_Sym *sym;
9167                   bfd_vma val;
9168                   enum {no_check, check_lo, check_ha} insn_check;
9169
9170                   r_type = ELF64_R_TYPE (rel->r_info);
9171                   switch (r_type)
9172                     {
9173                     default:
9174                       insn_check = no_check;
9175                       break;
9176
9177                     case R_PPC64_GOT_TLSLD16_HA:
9178                     case R_PPC64_GOT_TLSGD16_HA:
9179                     case R_PPC64_GOT_TPREL16_HA:
9180                     case R_PPC64_GOT_DTPREL16_HA:
9181                     case R_PPC64_GOT16_HA:
9182                     case R_PPC64_TOC16_HA:
9183                       insn_check = check_ha;
9184                       break;
9185
9186                     case R_PPC64_GOT_TLSLD16_LO:
9187                     case R_PPC64_GOT_TLSGD16_LO:
9188                     case R_PPC64_GOT_TPREL16_LO_DS:
9189                     case R_PPC64_GOT_DTPREL16_LO_DS:
9190                     case R_PPC64_GOT16_LO:
9191                     case R_PPC64_GOT16_LO_DS:
9192                     case R_PPC64_TOC16_LO:
9193                     case R_PPC64_TOC16_LO_DS:
9194                       insn_check = check_lo;
9195                       break;
9196                     }
9197
9198                   if (insn_check != no_check)
9199                     {
9200                       bfd_vma off = rel->r_offset & ~3;
9201                       unsigned char buf[4];
9202                       unsigned int insn;
9203
9204                       if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
9205                         {
9206                           free (used);
9207                           goto error_ret;
9208                         }
9209                       insn = bfd_get_32 (ibfd, buf);
9210                       if (insn_check == check_lo
9211                           ? !ok_lo_toc_insn (insn)
9212                           : ((insn & ((0x3f << 26) | 0x1f << 16))
9213                              != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9214                         {
9215                           char str[12];
9216
9217                           ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
9218                           sprintf (str, "%#08x", insn);
9219                           info->callbacks->einfo
9220                             /* xgettext:c-format */
9221                             (_("%P: %H: toc optimization is not supported for"
9222                                " %s instruction.\n"),
9223                              ibfd, sec, rel->r_offset & ~3, str);
9224                         }
9225                     }
9226
9227                   switch (r_type)
9228                     {
9229                     case R_PPC64_TOC16:
9230                     case R_PPC64_TOC16_LO:
9231                     case R_PPC64_TOC16_HI:
9232                     case R_PPC64_TOC16_HA:
9233                     case R_PPC64_TOC16_DS:
9234                     case R_PPC64_TOC16_LO_DS:
9235                       /* In case we're taking addresses of toc entries.  */
9236                     case R_PPC64_ADDR64:
9237                       break;
9238
9239                     default:
9240                       continue;
9241                     }
9242
9243                   r_symndx = ELF64_R_SYM (rel->r_info);
9244                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9245                                   r_symndx, ibfd))
9246                     {
9247                       free (used);
9248                       goto error_ret;
9249                     }
9250
9251                   if (sym_sec != toc)
9252                     continue;
9253
9254                   if (h != NULL)
9255                     val = h->root.u.def.value;
9256                   else
9257                     val = sym->st_value;
9258                   val += rel->r_addend;
9259
9260                   if (val >= toc->size)
9261                     continue;
9262
9263                   if ((skip[val >> 3] & can_optimize) != 0)
9264                     {
9265                       bfd_vma off;
9266                       unsigned char opc;
9267
9268                       switch (r_type)
9269                         {
9270                         case R_PPC64_TOC16_HA:
9271                           break;
9272
9273                         case R_PPC64_TOC16_LO_DS:
9274                           off = rel->r_offset;
9275                           off += (bfd_big_endian (ibfd) ? -2 : 3);
9276                           if (!bfd_get_section_contents (ibfd, sec, &opc,
9277                                                          off, 1))
9278                             {
9279                               free (used);
9280                               goto error_ret;
9281                             }
9282                           if ((opc & (0x3f << 2)) == (58u << 2))
9283                             break;
9284                           /* Fall through.  */
9285
9286                         default:
9287                           /* Wrong sort of reloc, or not a ld.  We may
9288                              as well clear ref_from_discarded too.  */
9289                           skip[val >> 3] = 0;
9290                         }
9291                     }
9292
9293                   if (sec != toc)
9294                     used[val >> 3] = 1;
9295                   /* For the toc section, we only mark as used if this
9296                      entry itself isn't unused.  */
9297                   else if ((used[rel->r_offset >> 3]
9298                             || !(skip[rel->r_offset >> 3] & ref_from_discarded))
9299                            && !used[val >> 3])
9300                     {
9301                       /* Do all the relocs again, to catch reference
9302                          chains.  */
9303                       repeat = 1;
9304                       used[val >> 3] = 1;
9305                     }
9306                 }
9307             }
9308           while (repeat);
9309
9310           if (elf_section_data (sec)->relocs != relstart)
9311             free (relstart);
9312         }
9313
9314       /* Merge the used and skip arrays.  Assume that TOC
9315          doublewords not appearing as either used or unused belong
9316          to to an entry more than one doubleword in size.  */
9317       for (drop = skip, keep = used, last = 0, some_unused = 0;
9318            drop < skip + (toc->size + 7) / 8;
9319            ++drop, ++keep)
9320         {
9321           if (*keep)
9322             {
9323               *drop &= ~ref_from_discarded;
9324               if ((*drop & can_optimize) != 0)
9325                 some_unused = 1;
9326               last = 0;
9327             }
9328           else if ((*drop & ref_from_discarded) != 0)
9329             {
9330               some_unused = 1;
9331               last = ref_from_discarded;
9332             }
9333           else
9334             *drop = last;
9335         }
9336
9337       free (used);
9338
9339       if (some_unused)
9340         {
9341           bfd_byte *contents, *src;
9342           unsigned long off;
9343           Elf_Internal_Sym *sym;
9344           bfd_boolean local_toc_syms = FALSE;
9345
9346           /* Shuffle the toc contents, and at the same time convert the
9347              skip array from booleans into offsets.  */
9348           if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9349             goto error_ret;
9350
9351           elf_section_data (toc)->this_hdr.contents = contents;
9352
9353           for (src = contents, off = 0, drop = skip;
9354                src < contents + toc->size;
9355                src += 8, ++drop)
9356             {
9357               if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9358                 off += 8;
9359               else if (off != 0)
9360                 {
9361                   *drop = off;
9362                   memcpy (src - off, src, 8);
9363                 }
9364             }
9365           *drop = off;
9366           toc->rawsize = toc->size;
9367           toc->size = src - contents - off;
9368
9369           /* Adjust addends for relocs against the toc section sym,
9370              and optimize any accesses we can.  */
9371           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9372             {
9373               if (sec->reloc_count == 0
9374                   || discarded_section (sec))
9375                 continue;
9376
9377               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9378                                                     info->keep_memory);
9379               if (relstart == NULL)
9380                 goto error_ret;
9381
9382               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9383                 {
9384                   enum elf_ppc64_reloc_type r_type;
9385                   unsigned long r_symndx;
9386                   asection *sym_sec;
9387                   struct elf_link_hash_entry *h;
9388                   bfd_vma val;
9389
9390                   r_type = ELF64_R_TYPE (rel->r_info);
9391                   switch (r_type)
9392                     {
9393                     default:
9394                       continue;
9395
9396                     case R_PPC64_TOC16:
9397                     case R_PPC64_TOC16_LO:
9398                     case R_PPC64_TOC16_HI:
9399                     case R_PPC64_TOC16_HA:
9400                     case R_PPC64_TOC16_DS:
9401                     case R_PPC64_TOC16_LO_DS:
9402                     case R_PPC64_ADDR64:
9403                       break;
9404                     }
9405
9406                   r_symndx = ELF64_R_SYM (rel->r_info);
9407                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9408                                   r_symndx, ibfd))
9409                     goto error_ret;
9410
9411                   if (sym_sec != toc)
9412                     continue;
9413
9414                   if (h != NULL)
9415                     val = h->root.u.def.value;
9416                   else
9417                     {
9418                       val = sym->st_value;
9419                       if (val != 0)
9420                         local_toc_syms = TRUE;
9421                     }
9422
9423                   val += rel->r_addend;
9424
9425                   if (val > toc->rawsize)
9426                     val = toc->rawsize;
9427                   else if ((skip[val >> 3] & ref_from_discarded) != 0)
9428                     continue;
9429                   else if ((skip[val >> 3] & can_optimize) != 0)
9430                     {
9431                       Elf_Internal_Rela *tocrel
9432                         = toc_relocs + (skip[val >> 3] >> 2);
9433                       unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9434
9435                       switch (r_type)
9436                         {
9437                         case R_PPC64_TOC16_HA:
9438                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9439                           break;
9440
9441                         case R_PPC64_TOC16_LO_DS:
9442                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9443                           break;
9444
9445                         default:
9446                           if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9447                             ppc_howto_init ();
9448                           info->callbacks->einfo
9449                             /* xgettext:c-format */
9450                             (_("%P: %H: %s references "
9451                                "optimized away TOC entry\n"),
9452                              ibfd, sec, rel->r_offset,
9453                              ppc64_elf_howto_table[r_type]->name);
9454                           bfd_set_error (bfd_error_bad_value);
9455                           goto error_ret;
9456                         }
9457                       rel->r_addend = tocrel->r_addend;
9458                       elf_section_data (sec)->relocs = relstart;
9459                       continue;
9460                     }
9461
9462                   if (h != NULL || sym->st_value != 0)
9463                     continue;
9464
9465                   rel->r_addend -= skip[val >> 3];
9466                   elf_section_data (sec)->relocs = relstart;
9467                 }
9468
9469               if (elf_section_data (sec)->relocs != relstart)
9470                 free (relstart);
9471             }
9472
9473           /* We shouldn't have local or global symbols defined in the TOC,
9474              but handle them anyway.  */
9475           if (local_syms != NULL)
9476             for (sym = local_syms;
9477                  sym < local_syms + symtab_hdr->sh_info;
9478                  ++sym)
9479               if (sym->st_value != 0
9480                   && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9481                 {
9482                   unsigned long i;
9483
9484                   if (sym->st_value > toc->rawsize)
9485                     i = toc->rawsize >> 3;
9486                   else
9487                     i = sym->st_value >> 3;
9488
9489                   if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9490                     {
9491                       if (local_toc_syms)
9492                         _bfd_error_handler
9493                           (_("%s defined on removed toc entry"),
9494                            bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9495                       do
9496                         ++i;
9497                       while ((skip[i] & (ref_from_discarded | can_optimize)));
9498                       sym->st_value = (bfd_vma) i << 3;
9499                     }
9500
9501                   sym->st_value -= skip[i];
9502                   symtab_hdr->contents = (unsigned char *) local_syms;
9503                 }
9504
9505           /* Adjust any global syms defined in this toc input section.  */
9506           if (toc_inf.global_toc_syms)
9507             {
9508               toc_inf.toc = toc;
9509               toc_inf.skip = skip;
9510               toc_inf.global_toc_syms = FALSE;
9511               elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9512                                       &toc_inf);
9513             }
9514
9515           if (toc->reloc_count != 0)
9516             {
9517               Elf_Internal_Shdr *rel_hdr;
9518               Elf_Internal_Rela *wrel;
9519               bfd_size_type sz;
9520
9521               /* Remove unused toc relocs, and adjust those we keep.  */
9522               if (toc_relocs == NULL)
9523                 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9524                                                         info->keep_memory);
9525               if (toc_relocs == NULL)
9526                 goto error_ret;
9527
9528               wrel = toc_relocs;
9529               for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9530                 if ((skip[rel->r_offset >> 3]
9531                      & (ref_from_discarded | can_optimize)) == 0)
9532                   {
9533                     wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9534                     wrel->r_info = rel->r_info;
9535                     wrel->r_addend = rel->r_addend;
9536                     ++wrel;
9537                   }
9538                 else if (!dec_dynrel_count (rel->r_info, toc, info,
9539                                             &local_syms, NULL, NULL))
9540                   goto error_ret;
9541
9542               elf_section_data (toc)->relocs = toc_relocs;
9543               toc->reloc_count = wrel - toc_relocs;
9544               rel_hdr = _bfd_elf_single_rel_hdr (toc);
9545               sz = rel_hdr->sh_entsize;
9546               rel_hdr->sh_size = toc->reloc_count * sz;
9547             }
9548         }
9549       else if (toc_relocs != NULL
9550                && elf_section_data (toc)->relocs != toc_relocs)
9551         free (toc_relocs);
9552
9553       if (local_syms != NULL
9554           && symtab_hdr->contents != (unsigned char *) local_syms)
9555         {
9556           if (!info->keep_memory)
9557             free (local_syms);
9558           else
9559             symtab_hdr->contents = (unsigned char *) local_syms;
9560         }
9561       free (skip);
9562     }
9563
9564   return TRUE;
9565 }
9566
9567 /* Return true iff input section I references the TOC using
9568    instructions limited to +/-32k offsets.  */
9569
9570 bfd_boolean
9571 ppc64_elf_has_small_toc_reloc (asection *i)
9572 {
9573   return (is_ppc64_elf (i->owner)
9574           && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9575 }
9576
9577 /* Allocate space for one GOT entry.  */
9578
9579 static void
9580 allocate_got (struct elf_link_hash_entry *h,
9581               struct bfd_link_info *info,
9582               struct got_entry *gent)
9583 {
9584   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9585   bfd_boolean dyn;
9586   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9587   int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9588                  ? 16 : 8);
9589   int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9590                   ? 2 : 1) * sizeof (Elf64_External_Rela);
9591   asection *got = ppc64_elf_tdata (gent->owner)->got;
9592
9593   gent->got.offset = got->size;
9594   got->size += entsize;
9595
9596   dyn = htab->elf.dynamic_sections_created;
9597   if (h->type == STT_GNU_IFUNC)
9598     {
9599       htab->elf.irelplt->size += rentsize;
9600       htab->got_reli_size += rentsize;
9601     }
9602   else if ((bfd_link_pic (info)
9603             || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
9604            && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9605                || h->root.type != bfd_link_hash_undefweak))
9606     {
9607       asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9608       relgot->size += rentsize;
9609     }
9610 }
9611
9612 /* This function merges got entries in the same toc group.  */
9613
9614 static void
9615 merge_got_entries (struct got_entry **pent)
9616 {
9617   struct got_entry *ent, *ent2;
9618
9619   for (ent = *pent; ent != NULL; ent = ent->next)
9620     if (!ent->is_indirect)
9621       for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9622         if (!ent2->is_indirect
9623             && ent2->addend == ent->addend
9624             && ent2->tls_type == ent->tls_type
9625             && elf_gp (ent2->owner) == elf_gp (ent->owner))
9626           {
9627             ent2->is_indirect = TRUE;
9628             ent2->got.ent = ent;
9629           }
9630 }
9631
9632 /* Allocate space in .plt, .got and associated reloc sections for
9633    dynamic relocs.  */
9634
9635 static bfd_boolean
9636 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9637 {
9638   struct bfd_link_info *info;
9639   struct ppc_link_hash_table *htab;
9640   asection *s;
9641   struct ppc_link_hash_entry *eh;
9642   struct got_entry **pgent, *gent;
9643
9644   if (h->root.type == bfd_link_hash_indirect)
9645     return TRUE;
9646
9647   info = (struct bfd_link_info *) inf;
9648   htab = ppc_hash_table (info);
9649   if (htab == NULL)
9650     return FALSE;
9651
9652   eh = (struct ppc_link_hash_entry *) h;
9653   /* Run through the TLS GD got entries first if we're changing them
9654      to TPREL.  */
9655   if ((eh->tls_mask & TLS_TPRELGD) != 0)
9656     for (gent = h->got.glist; gent != NULL; gent = gent->next)
9657       if (gent->got.refcount > 0
9658           && (gent->tls_type & TLS_GD) != 0)
9659         {
9660           /* This was a GD entry that has been converted to TPREL.  If
9661              there happens to be a TPREL entry we can use that one.  */
9662           struct got_entry *ent;
9663           for (ent = h->got.glist; ent != NULL; ent = ent->next)
9664             if (ent->got.refcount > 0
9665                 && (ent->tls_type & TLS_TPREL) != 0
9666                 && ent->addend == gent->addend
9667                 && ent->owner == gent->owner)
9668               {
9669                 gent->got.refcount = 0;
9670                 break;
9671               }
9672
9673           /* If not, then we'll be using our own TPREL entry.  */
9674           if (gent->got.refcount != 0)
9675             gent->tls_type = TLS_TLS | TLS_TPREL;
9676         }
9677
9678   /* Remove any list entry that won't generate a word in the GOT before
9679      we call merge_got_entries.  Otherwise we risk merging to empty
9680      entries.  */
9681   pgent = &h->got.glist;
9682   while ((gent = *pgent) != NULL)
9683     if (gent->got.refcount > 0)
9684       {
9685         if ((gent->tls_type & TLS_LD) != 0
9686             && !h->def_dynamic)
9687           {
9688             ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9689             *pgent = gent->next;
9690           }
9691         else
9692           pgent = &gent->next;
9693       }
9694     else
9695       *pgent = gent->next;
9696
9697   if (!htab->do_multi_toc)
9698     merge_got_entries (&h->got.glist);
9699
9700   for (gent = h->got.glist; gent != NULL; gent = gent->next)
9701     if (!gent->is_indirect)
9702       {
9703         /* Make sure this symbol is output as a dynamic symbol.
9704            Undefined weak syms won't yet be marked as dynamic,
9705            nor will all TLS symbols.  */
9706         if (h->dynindx == -1
9707             && !h->forced_local
9708             && h->type != STT_GNU_IFUNC
9709             && htab->elf.dynamic_sections_created)
9710           {
9711             if (! bfd_elf_link_record_dynamic_symbol (info, h))
9712               return FALSE;
9713           }
9714
9715         if (!is_ppc64_elf (gent->owner))
9716           abort ();
9717
9718         allocate_got (h, info, gent);
9719       }
9720
9721   if (!htab->elf.dynamic_sections_created
9722       && h->type != STT_GNU_IFUNC)
9723     eh->dyn_relocs = NULL;
9724
9725   if (eh->dyn_relocs != NULL)
9726     {
9727       struct elf_dyn_relocs *p, **pp;
9728
9729       /* In the shared -Bsymbolic case, discard space allocated for
9730          dynamic pc-relative relocs against symbols which turn out to
9731          be defined in regular objects.  For the normal shared case,
9732          discard space for relocs that have become local due to symbol
9733          visibility changes.  */
9734
9735       if (bfd_link_pic (info))
9736         {
9737           /* Relocs that use pc_count are those that appear on a call
9738              insn, or certain REL relocs (see must_be_dyn_reloc) that
9739              can be generated via assembly.  We want calls to
9740              protected symbols to resolve directly to the function
9741              rather than going via the plt.  If people want function
9742              pointer comparisons to work as expected then they should
9743              avoid writing weird assembly.  */
9744           if (SYMBOL_CALLS_LOCAL (info, h))
9745             {
9746               for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9747                 {
9748                   p->count -= p->pc_count;
9749                   p->pc_count = 0;
9750                   if (p->count == 0)
9751                     *pp = p->next;
9752                   else
9753                     pp = &p->next;
9754                 }
9755             }
9756
9757           /* Also discard relocs on undefined weak syms with
9758              non-default visibility.  */
9759           if (eh->dyn_relocs != NULL
9760               && h->root.type == bfd_link_hash_undefweak)
9761             {
9762               if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9763                 eh->dyn_relocs = NULL;
9764
9765               /* Make sure this symbol is output as a dynamic symbol.
9766                  Undefined weak syms won't yet be marked as dynamic.  */
9767               else if (h->dynindx == -1
9768                        && !h->forced_local)
9769                 {
9770                   if (! bfd_elf_link_record_dynamic_symbol (info, h))
9771                     return FALSE;
9772                 }
9773             }
9774         }
9775       else if (h->type == STT_GNU_IFUNC)
9776         {
9777           /* A plt entry is always created when making direct calls to
9778              an ifunc, even when building a static executable, but
9779              that doesn't cover all cases.  We may have only an ifunc
9780              initialised function pointer for a given ifunc symbol.
9781
9782              For ELFv2, dynamic relocations are not required when
9783              generating a global entry PLT stub.  */
9784           if (abiversion (info->output_bfd) >= 2)
9785             {
9786               if (global_entry_stub (h))
9787                 eh->dyn_relocs = NULL;
9788             }
9789
9790           /* For ELFv1 we have function descriptors.  Descriptors need
9791              to be treated like PLT entries and thus have dynamic
9792              relocations.  One exception is when the function
9793              descriptor is copied into .dynbss (which should only
9794              happen with ancient versions of gcc).  */
9795           else if (h->needs_copy)
9796             eh->dyn_relocs = NULL;
9797         }
9798       else if (ELIMINATE_COPY_RELOCS)
9799         {
9800           /* For the non-pic case, discard space for relocs against
9801              symbols which turn out to need copy relocs or are not
9802              dynamic.  */
9803
9804           /* First make sure this symbol is output as a dynamic symbol.
9805              Undefined weak syms won't yet be marked as dynamic.  */
9806           if (h->root.type == bfd_link_hash_undefweak
9807               && !h->non_got_ref
9808               && !h->def_regular
9809               && h->dynindx == -1
9810               && !h->forced_local
9811               && !bfd_elf_link_record_dynamic_symbol (info, h))
9812             return FALSE;
9813
9814           if (h->non_got_ref
9815               || h->def_regular
9816               || h->dynindx == -1)
9817             eh->dyn_relocs = NULL;
9818         }
9819
9820       /* Finally, allocate space.  */
9821       for (p = eh->dyn_relocs; p != NULL; p = p->next)
9822         {
9823           asection *sreloc = elf_section_data (p->sec)->sreloc;
9824           if (eh->elf.type == STT_GNU_IFUNC)
9825             sreloc = htab->elf.irelplt;
9826           sreloc->size += p->count * sizeof (Elf64_External_Rela);
9827         }
9828     }
9829
9830   if ((htab->elf.dynamic_sections_created
9831        && h->dynindx != -1
9832        && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
9833       || h->type == STT_GNU_IFUNC)
9834     {
9835       struct plt_entry *pent;
9836       bfd_boolean doneone = FALSE;
9837       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9838         if (pent->plt.refcount > 0)
9839           {
9840             if (!htab->elf.dynamic_sections_created
9841                 || h->dynindx == -1)
9842               {
9843                 s = htab->elf.iplt;
9844                 pent->plt.offset = s->size;
9845                 s->size += PLT_ENTRY_SIZE (htab);
9846                 s = htab->elf.irelplt;
9847               }
9848             else
9849               {
9850                 /* If this is the first .plt entry, make room for the special
9851                    first entry.  */
9852                 s = htab->elf.splt;
9853                 if (s->size == 0)
9854                   s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9855
9856                 pent->plt.offset = s->size;
9857
9858                 /* Make room for this entry.  */
9859                 s->size += PLT_ENTRY_SIZE (htab);
9860
9861                 /* Make room for the .glink code.  */
9862                 s = htab->glink;
9863                 if (s->size == 0)
9864                   s->size += GLINK_CALL_STUB_SIZE;
9865                 if (htab->opd_abi)
9866                   {
9867                     /* We need bigger stubs past index 32767.  */
9868                     if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9869                       s->size += 4;
9870                     s->size += 2*4;
9871                   }
9872                 else
9873                   s->size += 4;
9874
9875                 /* We also need to make an entry in the .rela.plt section.  */
9876                 s = htab->elf.srelplt;
9877               }
9878             s->size += sizeof (Elf64_External_Rela);
9879             doneone = TRUE;
9880           }
9881         else
9882           pent->plt.offset = (bfd_vma) -1;
9883       if (!doneone)
9884         {
9885           h->plt.plist = NULL;
9886           h->needs_plt = 0;
9887         }
9888     }
9889   else
9890     {
9891       h->plt.plist = NULL;
9892       h->needs_plt = 0;
9893     }
9894
9895   return TRUE;
9896 }
9897
9898 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9899    to set up space for global entry stubs.  These are put in glink,
9900    after the branch table.  */
9901
9902 static bfd_boolean
9903 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
9904 {
9905   struct bfd_link_info *info;
9906   struct ppc_link_hash_table *htab;
9907   struct plt_entry *pent;
9908   asection *s;
9909
9910   if (h->root.type == bfd_link_hash_indirect)
9911     return TRUE;
9912
9913   if (!h->pointer_equality_needed)
9914     return TRUE;
9915
9916   if (h->def_regular)
9917     return TRUE;
9918
9919   info = inf;
9920   htab = ppc_hash_table (info);
9921   if (htab == NULL)
9922     return FALSE;
9923
9924   s = htab->glink;
9925   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9926     if (pent->plt.offset != (bfd_vma) -1
9927         && pent->addend == 0)
9928       {
9929         /* For ELFv2, if this symbol is not defined in a regular file
9930            and we are not generating a shared library or pie, then we
9931            need to define the symbol in the executable on a call stub.
9932            This is to avoid text relocations.  */
9933         s->size = (s->size + 15) & -16;
9934         h->root.type = bfd_link_hash_defined;
9935         h->root.u.def.section = s;
9936         h->root.u.def.value = s->size;
9937         s->size += 16;
9938         break;
9939       }
9940   return TRUE;
9941 }
9942
9943 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9944    read-only sections.  */
9945
9946 static bfd_boolean
9947 maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
9948 {
9949   if (h->root.type == bfd_link_hash_indirect)
9950     return TRUE;
9951
9952   if (readonly_dynrelocs (h))
9953     {
9954       ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
9955
9956       /* Not an error, just cut short the traversal.  */
9957       return FALSE;
9958     }
9959   return TRUE;
9960 }
9961
9962 /* Set the sizes of the dynamic sections.  */
9963
9964 static bfd_boolean
9965 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
9966                                  struct bfd_link_info *info)
9967 {
9968   struct ppc_link_hash_table *htab;
9969   bfd *dynobj;
9970   asection *s;
9971   bfd_boolean relocs;
9972   bfd *ibfd;
9973   struct got_entry *first_tlsld;
9974
9975   htab = ppc_hash_table (info);
9976   if (htab == NULL)
9977     return FALSE;
9978
9979   dynobj = htab->elf.dynobj;
9980   if (dynobj == NULL)
9981     abort ();
9982
9983   if (htab->elf.dynamic_sections_created)
9984     {
9985       /* Set the contents of the .interp section to the interpreter.  */
9986       if (bfd_link_executable (info) && !info->nointerp)
9987         {
9988           s = bfd_get_linker_section (dynobj, ".interp");
9989           if (s == NULL)
9990             abort ();
9991           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
9992           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
9993         }
9994     }
9995
9996   /* Set up .got offsets for local syms, and space for local dynamic
9997      relocs.  */
9998   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9999     {
10000       struct got_entry **lgot_ents;
10001       struct got_entry **end_lgot_ents;
10002       struct plt_entry **local_plt;
10003       struct plt_entry **end_local_plt;
10004       unsigned char *lgot_masks;
10005       bfd_size_type locsymcount;
10006       Elf_Internal_Shdr *symtab_hdr;
10007
10008       if (!is_ppc64_elf (ibfd))
10009         continue;
10010
10011       for (s = ibfd->sections; s != NULL; s = s->next)
10012         {
10013           struct ppc_dyn_relocs *p;
10014
10015           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
10016             {
10017               if (!bfd_is_abs_section (p->sec)
10018                   && bfd_is_abs_section (p->sec->output_section))
10019                 {
10020                   /* Input section has been discarded, either because
10021                      it is a copy of a linkonce section or due to
10022                      linker script /DISCARD/, so we'll be discarding
10023                      the relocs too.  */
10024                 }
10025               else if (p->count != 0)
10026                 {
10027                   asection *srel = elf_section_data (p->sec)->sreloc;
10028                   if (p->ifunc)
10029                     srel = htab->elf.irelplt;
10030                   srel->size += p->count * sizeof (Elf64_External_Rela);
10031                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
10032                     info->flags |= DF_TEXTREL;
10033                 }
10034             }
10035         }
10036
10037       lgot_ents = elf_local_got_ents (ibfd);
10038       if (!lgot_ents)
10039         continue;
10040
10041       symtab_hdr = &elf_symtab_hdr (ibfd);
10042       locsymcount = symtab_hdr->sh_info;
10043       end_lgot_ents = lgot_ents + locsymcount;
10044       local_plt = (struct plt_entry **) end_lgot_ents;
10045       end_local_plt = local_plt + locsymcount;
10046       lgot_masks = (unsigned char *) end_local_plt;
10047       s = ppc64_elf_tdata (ibfd)->got;
10048       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
10049         {
10050           struct got_entry **pent, *ent;
10051
10052           pent = lgot_ents;
10053           while ((ent = *pent) != NULL)
10054             if (ent->got.refcount > 0)
10055               {
10056                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
10057                   {
10058                     ppc64_tlsld_got (ibfd)->got.refcount += 1;
10059                     *pent = ent->next;
10060                   }
10061                 else
10062                   {
10063                     unsigned int ent_size = 8;
10064                     unsigned int rel_size = sizeof (Elf64_External_Rela);
10065
10066                     ent->got.offset = s->size;
10067                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
10068                       {
10069                         ent_size *= 2;
10070                         rel_size *= 2;
10071                       }
10072                     s->size += ent_size;
10073                     if ((*lgot_masks & PLT_IFUNC) != 0)
10074                       {
10075                         htab->elf.irelplt->size += rel_size;
10076                         htab->got_reli_size += rel_size;
10077                       }
10078                     else if (bfd_link_pic (info))
10079                       {
10080                         asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10081                         srel->size += rel_size;
10082                       }
10083                     pent = &ent->next;
10084                   }
10085               }
10086             else
10087               *pent = ent->next;
10088         }
10089
10090       /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt.  */
10091       for (; local_plt < end_local_plt; ++local_plt)
10092         {
10093           struct plt_entry *ent;
10094
10095           for (ent = *local_plt; ent != NULL; ent = ent->next)
10096             if (ent->plt.refcount > 0)
10097               {
10098                 s = htab->elf.iplt;
10099                 ent->plt.offset = s->size;
10100                 s->size += PLT_ENTRY_SIZE (htab);
10101
10102                 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
10103               }
10104             else
10105               ent->plt.offset = (bfd_vma) -1;
10106         }
10107     }
10108
10109   /* Allocate global sym .plt and .got entries, and space for global
10110      sym dynamic relocs.  */
10111   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
10112   /* Stash the end of glink branch table.  */
10113   if (htab->glink != NULL)
10114     htab->glink->rawsize = htab->glink->size;
10115
10116   if (!htab->opd_abi && !bfd_link_pic (info))
10117     elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
10118
10119   first_tlsld = NULL;
10120   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10121     {
10122       struct got_entry *ent;
10123
10124       if (!is_ppc64_elf (ibfd))
10125         continue;
10126
10127       ent = ppc64_tlsld_got (ibfd);
10128       if (ent->got.refcount > 0)
10129         {
10130           if (!htab->do_multi_toc && first_tlsld != NULL)
10131             {
10132               ent->is_indirect = TRUE;
10133               ent->got.ent = first_tlsld;
10134             }
10135           else
10136             {
10137               if (first_tlsld == NULL)
10138                 first_tlsld = ent;
10139               s = ppc64_elf_tdata (ibfd)->got;
10140               ent->got.offset = s->size;
10141               ent->owner = ibfd;
10142               s->size += 16;
10143               if (bfd_link_pic (info))
10144                 {
10145                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10146                   srel->size += sizeof (Elf64_External_Rela);
10147                 }
10148             }
10149         }
10150       else
10151         ent->got.offset = (bfd_vma) -1;
10152     }
10153
10154   /* We now have determined the sizes of the various dynamic sections.
10155      Allocate memory for them.  */
10156   relocs = FALSE;
10157   for (s = dynobj->sections; s != NULL; s = s->next)
10158     {
10159       if ((s->flags & SEC_LINKER_CREATED) == 0)
10160         continue;
10161
10162       if (s == htab->brlt || s == htab->relbrlt)
10163         /* These haven't been allocated yet;  don't strip.  */
10164         continue;
10165       else if (s == htab->elf.sgot
10166                || s == htab->elf.splt
10167                || s == htab->elf.iplt
10168                || s == htab->glink
10169                || s == htab->dynbss)
10170         {
10171           /* Strip this section if we don't need it; see the
10172              comment below.  */
10173         }
10174       else if (s == htab->glink_eh_frame)
10175         {
10176           if (!bfd_is_abs_section (s->output_section))
10177             /* Not sized yet.  */
10178             continue;
10179         }
10180       else if (CONST_STRNEQ (s->name, ".rela"))
10181         {
10182           if (s->size != 0)
10183             {
10184               if (s != htab->elf.srelplt)
10185                 relocs = TRUE;
10186
10187               /* We use the reloc_count field as a counter if we need
10188                  to copy relocs into the output file.  */
10189               s->reloc_count = 0;
10190             }
10191         }
10192       else
10193         {
10194           /* It's not one of our sections, so don't allocate space.  */
10195           continue;
10196         }
10197
10198       if (s->size == 0)
10199         {
10200           /* If we don't need this section, strip it from the
10201              output file.  This is mostly to handle .rela.bss and
10202              .rela.plt.  We must create both sections in
10203              create_dynamic_sections, because they must be created
10204              before the linker maps input sections to output
10205              sections.  The linker does that before
10206              adjust_dynamic_symbol is called, and it is that
10207              function which decides whether anything needs to go
10208              into these sections.  */
10209           s->flags |= SEC_EXCLUDE;
10210           continue;
10211         }
10212
10213       if ((s->flags & SEC_HAS_CONTENTS) == 0)
10214         continue;
10215
10216       /* Allocate memory for the section contents.  We use bfd_zalloc
10217          here in case unused entries are not reclaimed before the
10218          section's contents are written out.  This should not happen,
10219          but this way if it does we get a R_PPC64_NONE reloc in .rela
10220          sections instead of garbage.
10221          We also rely on the section contents being zero when writing
10222          the GOT.  */
10223       s->contents = bfd_zalloc (dynobj, s->size);
10224       if (s->contents == NULL)
10225         return FALSE;
10226     }
10227
10228   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10229     {
10230       if (!is_ppc64_elf (ibfd))
10231         continue;
10232
10233       s = ppc64_elf_tdata (ibfd)->got;
10234       if (s != NULL && s != htab->elf.sgot)
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             }
10244         }
10245       s = ppc64_elf_tdata (ibfd)->relgot;
10246       if (s != NULL)
10247         {
10248           if (s->size == 0)
10249             s->flags |= SEC_EXCLUDE;
10250           else
10251             {
10252               s->contents = bfd_zalloc (ibfd, s->size);
10253               if (s->contents == NULL)
10254                 return FALSE;
10255               relocs = TRUE;
10256               s->reloc_count = 0;
10257             }
10258         }
10259     }
10260
10261   if (htab->elf.dynamic_sections_created)
10262     {
10263       bfd_boolean tls_opt;
10264
10265       /* Add some entries to the .dynamic section.  We fill in the
10266          values later, in ppc64_elf_finish_dynamic_sections, but we
10267          must add the entries now so that we get the correct size for
10268          the .dynamic section.  The DT_DEBUG entry is filled in by the
10269          dynamic linker and used by the debugger.  */
10270 #define add_dynamic_entry(TAG, VAL) \
10271   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10272
10273       if (bfd_link_executable (info))
10274         {
10275           if (!add_dynamic_entry (DT_DEBUG, 0))
10276             return FALSE;
10277         }
10278
10279       if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
10280         {
10281           if (!add_dynamic_entry (DT_PLTGOT, 0)
10282               || !add_dynamic_entry (DT_PLTRELSZ, 0)
10283               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
10284               || !add_dynamic_entry (DT_JMPREL, 0)
10285               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
10286             return FALSE;
10287         }
10288
10289       if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
10290         {
10291           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
10292               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
10293             return FALSE;
10294         }
10295
10296       tls_opt = (htab->params->tls_get_addr_opt
10297                  && htab->tls_get_addr_fd != NULL
10298                  && htab->tls_get_addr_fd->elf.plt.plist != NULL);
10299       if (tls_opt || !htab->opd_abi)
10300         {
10301           if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
10302             return FALSE;
10303         }
10304
10305       if (relocs)
10306         {
10307           if (!add_dynamic_entry (DT_RELA, 0)
10308               || !add_dynamic_entry (DT_RELASZ, 0)
10309               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
10310             return FALSE;
10311
10312           /* If any dynamic relocs apply to a read-only section,
10313              then we need a DT_TEXTREL entry.  */
10314           if ((info->flags & DF_TEXTREL) == 0)
10315             elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
10316
10317           if ((info->flags & DF_TEXTREL) != 0)
10318             {
10319               if (!add_dynamic_entry (DT_TEXTREL, 0))
10320                 return FALSE;
10321             }
10322         }
10323     }
10324 #undef add_dynamic_entry
10325
10326   return TRUE;
10327 }
10328
10329 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
10330
10331 static bfd_boolean
10332 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
10333 {
10334   if (h->plt.plist != NULL
10335       && !h->def_regular
10336       && !h->pointer_equality_needed)
10337     return FALSE;
10338
10339   return _bfd_elf_hash_symbol (h);
10340 }
10341
10342 /* Determine the type of stub needed, if any, for a call.  */
10343
10344 static inline enum ppc_stub_type
10345 ppc_type_of_stub (asection *input_sec,
10346                   const Elf_Internal_Rela *rel,
10347                   struct ppc_link_hash_entry **hash,
10348                   struct plt_entry **plt_ent,
10349                   bfd_vma destination,
10350                   unsigned long local_off)
10351 {
10352   struct ppc_link_hash_entry *h = *hash;
10353   bfd_vma location;
10354   bfd_vma branch_offset;
10355   bfd_vma max_branch_offset;
10356   enum elf_ppc64_reloc_type r_type;
10357
10358   if (h != NULL)
10359     {
10360       struct plt_entry *ent;
10361       struct ppc_link_hash_entry *fdh = h;
10362       if (h->oh != NULL
10363           && h->oh->is_func_descriptor)
10364         {
10365           fdh = ppc_follow_link (h->oh);
10366           *hash = fdh;
10367         }
10368
10369       for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10370         if (ent->addend == rel->r_addend
10371             && ent->plt.offset != (bfd_vma) -1)
10372           {
10373             *plt_ent = ent;
10374             return ppc_stub_plt_call;
10375           }
10376
10377       /* Here, we know we don't have a plt entry.  If we don't have a
10378          either a defined function descriptor or a defined entry symbol
10379          in a regular object file, then it is pointless trying to make
10380          any other type of stub.  */
10381       if (!is_static_defined (&fdh->elf)
10382           && !is_static_defined (&h->elf))
10383         return ppc_stub_none;
10384     }
10385   else if (elf_local_got_ents (input_sec->owner) != NULL)
10386     {
10387       Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10388       struct plt_entry **local_plt = (struct plt_entry **)
10389         elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10390       unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10391
10392       if (local_plt[r_symndx] != NULL)
10393         {
10394           struct plt_entry *ent;
10395
10396           for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10397             if (ent->addend == rel->r_addend
10398                 && ent->plt.offset != (bfd_vma) -1)
10399               {
10400                 *plt_ent = ent;
10401                 return ppc_stub_plt_call;
10402               }
10403         }
10404     }
10405
10406   /* Determine where the call point is.  */
10407   location = (input_sec->output_offset
10408               + input_sec->output_section->vma
10409               + rel->r_offset);
10410
10411   branch_offset = destination - location;
10412   r_type = ELF64_R_TYPE (rel->r_info);
10413
10414   /* Determine if a long branch stub is needed.  */
10415   max_branch_offset = 1 << 25;
10416   if (r_type != R_PPC64_REL24)
10417     max_branch_offset = 1 << 15;
10418
10419   if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10420     /* We need a stub.  Figure out whether a long_branch or plt_branch
10421        is needed later.  */
10422     return ppc_stub_long_branch;
10423
10424   return ppc_stub_none;
10425 }
10426
10427 /* With power7 weakly ordered memory model, it is possible for ld.so
10428    to update a plt entry in one thread and have another thread see a
10429    stale zero toc entry.  To avoid this we need some sort of acquire
10430    barrier in the call stub.  One solution is to make the load of the
10431    toc word seem to appear to depend on the load of the function entry
10432    word.  Another solution is to test for r2 being zero, and branch to
10433    the appropriate glink entry if so.
10434
10435    .    fake dep barrier        compare
10436    .    ld 12,xxx(2)            ld 12,xxx(2)
10437    .    mtctr 12                mtctr 12
10438    .    xor 11,12,12            ld 2,xxx+8(2)
10439    .    add 2,2,11              cmpldi 2,0
10440    .    ld 2,xxx+8(2)           bnectr+
10441    .    bctr                    b <glink_entry>
10442
10443    The solution involving the compare turns out to be faster, so
10444    that's what we use unless the branch won't reach.  */
10445
10446 #define ALWAYS_USE_FAKE_DEP 0
10447 #define ALWAYS_EMIT_R2SAVE 0
10448
10449 #define PPC_LO(v) ((v) & 0xffff)
10450 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10451 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10452
10453 static inline unsigned int
10454 plt_stub_size (struct ppc_link_hash_table *htab,
10455                struct ppc_stub_hash_entry *stub_entry,
10456                bfd_vma off)
10457 {
10458   unsigned size = 12;
10459
10460   if (ALWAYS_EMIT_R2SAVE
10461       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10462     size += 4;
10463   if (PPC_HA (off) != 0)
10464     size += 4;
10465   if (htab->opd_abi)
10466     {
10467       size += 4;
10468       if (htab->params->plt_static_chain)
10469         size += 4;
10470       if (htab->params->plt_thread_safe
10471           && htab->elf.dynamic_sections_created
10472           && stub_entry->h != NULL
10473           && stub_entry->h->elf.dynindx != -1)
10474         size += 8;
10475       if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
10476         size += 4;
10477     }
10478   if (stub_entry->h != NULL
10479       && (stub_entry->h == htab->tls_get_addr_fd
10480           || stub_entry->h == htab->tls_get_addr)
10481       && htab->params->tls_get_addr_opt)
10482     size += 13 * 4;
10483   return size;
10484 }
10485
10486 /* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
10487    then return the padding needed to do so.  */
10488 static inline unsigned int
10489 plt_stub_pad (struct ppc_link_hash_table *htab,
10490               struct ppc_stub_hash_entry *stub_entry,
10491               bfd_vma plt_off)
10492 {
10493   int stub_align = 1 << htab->params->plt_stub_align;
10494   unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10495   bfd_vma stub_off = stub_entry->group->stub_sec->size;
10496
10497   if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10498       > ((stub_size - 1) & -stub_align))
10499     return stub_align - (stub_off & (stub_align - 1));
10500   return 0;
10501 }
10502
10503 /* Build a .plt call stub.  */
10504
10505 static inline bfd_byte *
10506 build_plt_stub (struct ppc_link_hash_table *htab,
10507                 struct ppc_stub_hash_entry *stub_entry,
10508                 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10509 {
10510   bfd *obfd = htab->params->stub_bfd;
10511   bfd_boolean plt_load_toc = htab->opd_abi;
10512   bfd_boolean plt_static_chain = htab->params->plt_static_chain;
10513   bfd_boolean plt_thread_safe = (htab->params->plt_thread_safe
10514                                  && htab->elf.dynamic_sections_created
10515                                  && stub_entry->h != NULL
10516                                  && stub_entry->h->elf.dynindx != -1);
10517   bfd_boolean use_fake_dep = plt_thread_safe;
10518   bfd_vma cmp_branch_off = 0;
10519
10520   if (!ALWAYS_USE_FAKE_DEP
10521       && plt_load_toc
10522       && plt_thread_safe
10523       && !((stub_entry->h == htab->tls_get_addr_fd
10524             || stub_entry->h == htab->tls_get_addr)
10525            && htab->params->tls_get_addr_opt))
10526     {
10527       bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10528       bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10529                           / PLT_ENTRY_SIZE (htab));
10530       bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10531       bfd_vma to, from;
10532
10533       if (pltindex > 32768)
10534         glinkoff += (pltindex - 32768) * 4;
10535       to = (glinkoff
10536             + htab->glink->output_offset
10537             + htab->glink->output_section->vma);
10538       from = (p - stub_entry->group->stub_sec->contents
10539               + 4 * (ALWAYS_EMIT_R2SAVE
10540                      || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10541               + 4 * (PPC_HA (offset) != 0)
10542               + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10543                      != PPC_HA (offset))
10544               + 4 * (plt_static_chain != 0)
10545               + 20
10546               + stub_entry->group->stub_sec->output_offset
10547               + stub_entry->group->stub_sec->output_section->vma);
10548       cmp_branch_off = to - from;
10549       use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10550     }
10551
10552   if (PPC_HA (offset) != 0)
10553     {
10554       if (r != NULL)
10555         {
10556           if (ALWAYS_EMIT_R2SAVE
10557               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10558             r[0].r_offset += 4;
10559           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10560           r[1].r_offset = r[0].r_offset + 4;
10561           r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10562           r[1].r_addend = r[0].r_addend;
10563           if (plt_load_toc)
10564             {
10565               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10566                 {
10567                   r[2].r_offset = r[1].r_offset + 4;
10568                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10569                   r[2].r_addend = r[0].r_addend;
10570                 }
10571               else
10572                 {
10573                   r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10574                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10575                   r[2].r_addend = r[0].r_addend + 8;
10576                   if (plt_static_chain)
10577                     {
10578                       r[3].r_offset = r[2].r_offset + 4;
10579                       r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10580                       r[3].r_addend = r[0].r_addend + 16;
10581                     }
10582                 }
10583             }
10584         }
10585       if (ALWAYS_EMIT_R2SAVE
10586           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10587         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10588       if (plt_load_toc)
10589         {
10590           bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10591           bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p),  p += 4;
10592         }
10593       else
10594         {
10595           bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
10596           bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p),  p += 4;
10597         }
10598       if (plt_load_toc
10599           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10600         {
10601           bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10602           offset = 0;
10603         }
10604       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10605       if (plt_load_toc)
10606         {
10607           if (use_fake_dep)
10608             {
10609               bfd_put_32 (obfd, XOR_R2_R12_R12, p),             p += 4;
10610               bfd_put_32 (obfd, ADD_R11_R11_R2, p),             p += 4;
10611             }
10612           bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10613           if (plt_static_chain)
10614             bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10615         }
10616     }
10617   else
10618     {
10619       if (r != NULL)
10620         {
10621           if (ALWAYS_EMIT_R2SAVE
10622               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10623             r[0].r_offset += 4;
10624           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10625           if (plt_load_toc)
10626             {
10627               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10628                 {
10629                   r[1].r_offset = r[0].r_offset + 4;
10630                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10631                   r[1].r_addend = r[0].r_addend;
10632                 }
10633               else
10634                 {
10635                   r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10636                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10637                   r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10638                   if (plt_static_chain)
10639                     {
10640                       r[2].r_offset = r[1].r_offset + 4;
10641                       r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10642                       r[2].r_addend = r[0].r_addend + 8;
10643                     }
10644                 }
10645             }
10646         }
10647       if (ALWAYS_EMIT_R2SAVE
10648           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10649         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10650       bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p),       p += 4;
10651       if (plt_load_toc
10652           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10653         {
10654           bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),   p += 4;
10655           offset = 0;
10656         }
10657       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10658       if (plt_load_toc)
10659         {
10660           if (use_fake_dep)
10661             {
10662               bfd_put_32 (obfd, XOR_R11_R12_R12, p),            p += 4;
10663               bfd_put_32 (obfd, ADD_R2_R2_R11, p),              p += 4;
10664             }
10665           if (plt_static_chain)
10666             bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10667           bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10668         }
10669     }
10670   if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10671     {
10672       bfd_put_32 (obfd, CMPLDI_R2_0, p),                        p += 4;
10673       bfd_put_32 (obfd, BNECTR_P4, p),                          p += 4;
10674       bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10675     }
10676   else
10677     bfd_put_32 (obfd, BCTR, p),                                 p += 4;
10678   return p;
10679 }
10680
10681 /* Build a special .plt call stub for __tls_get_addr.  */
10682
10683 #define LD_R11_0R3      0xe9630000
10684 #define LD_R12_0R3      0xe9830000
10685 #define MR_R0_R3        0x7c601b78
10686 #define CMPDI_R11_0     0x2c2b0000
10687 #define ADD_R3_R12_R13  0x7c6c6a14
10688 #define BEQLR           0x4d820020
10689 #define MR_R3_R0        0x7c030378
10690 #define STD_R11_0R1     0xf9610000
10691 #define BCTRL           0x4e800421
10692 #define LD_R11_0R1      0xe9610000
10693 #define MTLR_R11        0x7d6803a6
10694
10695 static inline bfd_byte *
10696 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10697                          struct ppc_stub_hash_entry *stub_entry,
10698                          bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10699 {
10700   bfd *obfd = htab->params->stub_bfd;
10701
10702   bfd_put_32 (obfd, LD_R11_0R3 + 0, p),         p += 4;
10703   bfd_put_32 (obfd, LD_R12_0R3 + 8, p),         p += 4;
10704   bfd_put_32 (obfd, MR_R0_R3, p),               p += 4;
10705   bfd_put_32 (obfd, CMPDI_R11_0, p),            p += 4;
10706   bfd_put_32 (obfd, ADD_R3_R12_R13, p),         p += 4;
10707   bfd_put_32 (obfd, BEQLR, p),                  p += 4;
10708   bfd_put_32 (obfd, MR_R3_R0, p),               p += 4;
10709   bfd_put_32 (obfd, MFLR_R11, p),               p += 4;
10710   bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10711
10712   if (r != NULL)
10713     r[0].r_offset += 9 * 4;
10714   p = build_plt_stub (htab, stub_entry, p, offset, r);
10715   bfd_put_32 (obfd, BCTRL, p - 4);
10716
10717   bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p),     p += 4;
10718   bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10719   bfd_put_32 (obfd, MTLR_R11, p),               p += 4;
10720   bfd_put_32 (obfd, BLR, p),                    p += 4;
10721
10722   return p;
10723 }
10724
10725 static Elf_Internal_Rela *
10726 get_relocs (asection *sec, int count)
10727 {
10728   Elf_Internal_Rela *relocs;
10729   struct bfd_elf_section_data *elfsec_data;
10730
10731   elfsec_data = elf_section_data (sec);
10732   relocs = elfsec_data->relocs;
10733   if (relocs == NULL)
10734     {
10735       bfd_size_type relsize;
10736       relsize = sec->reloc_count * sizeof (*relocs);
10737       relocs = bfd_alloc (sec->owner, relsize);
10738       if (relocs == NULL)
10739         return NULL;
10740       elfsec_data->relocs = relocs;
10741       elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10742                                           sizeof (Elf_Internal_Shdr));
10743       if (elfsec_data->rela.hdr == NULL)
10744         return NULL;
10745       elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10746                                         * sizeof (Elf64_External_Rela));
10747       elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10748       sec->reloc_count = 0;
10749     }
10750   relocs += sec->reloc_count;
10751   sec->reloc_count += count;
10752   return relocs;
10753 }
10754
10755 static bfd_vma
10756 get_r2off (struct bfd_link_info *info,
10757            struct ppc_stub_hash_entry *stub_entry)
10758 {
10759   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10760   bfd_vma r2off = htab->sec_info[stub_entry->target_section->id].toc_off;
10761
10762   if (r2off == 0)
10763     {
10764       /* Support linking -R objects.  Get the toc pointer from the
10765          opd entry.  */
10766       char buf[8];
10767       if (!htab->opd_abi)
10768         return r2off;
10769       asection *opd = stub_entry->h->elf.root.u.def.section;
10770       bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10771
10772       if (strcmp (opd->name, ".opd") != 0
10773           || opd->reloc_count != 0)
10774         {
10775           info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
10776                                   stub_entry->h->elf.root.root.string);
10777           bfd_set_error (bfd_error_bad_value);
10778           return (bfd_vma) -1;
10779         }
10780       if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10781         return (bfd_vma) -1;
10782       r2off = bfd_get_64 (opd->owner, buf);
10783       r2off -= elf_gp (info->output_bfd);
10784     }
10785   r2off -= htab->sec_info[stub_entry->group->link_sec->id].toc_off;
10786   return r2off;
10787 }
10788
10789 static bfd_boolean
10790 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10791 {
10792   struct ppc_stub_hash_entry *stub_entry;
10793   struct ppc_branch_hash_entry *br_entry;
10794   struct bfd_link_info *info;
10795   struct ppc_link_hash_table *htab;
10796   bfd_byte *loc;
10797   bfd_byte *p;
10798   bfd_vma dest, off;
10799   int size;
10800   Elf_Internal_Rela *r;
10801   asection *plt;
10802
10803   /* Massage our args to the form they really have.  */
10804   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10805   info = in_arg;
10806
10807   htab = ppc_hash_table (info);
10808   if (htab == NULL)
10809     return FALSE;
10810
10811   /* Make a note of the offset within the stubs for this entry.  */
10812   stub_entry->stub_offset = stub_entry->group->stub_sec->size;
10813   loc = stub_entry->group->stub_sec->contents + stub_entry->stub_offset;
10814
10815   htab->stub_count[stub_entry->stub_type - 1] += 1;
10816   switch (stub_entry->stub_type)
10817     {
10818     case ppc_stub_long_branch:
10819     case ppc_stub_long_branch_r2off:
10820       /* Branches are relative.  This is where we are going to.  */
10821       dest = (stub_entry->target_value
10822               + stub_entry->target_section->output_offset
10823               + stub_entry->target_section->output_section->vma);
10824       dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10825       off = dest;
10826
10827       /* And this is where we are coming from.  */
10828       off -= (stub_entry->stub_offset
10829               + stub_entry->group->stub_sec->output_offset
10830               + stub_entry->group->stub_sec->output_section->vma);
10831
10832       size = 4;
10833       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10834         {
10835           bfd_vma r2off = get_r2off (info, stub_entry);
10836
10837           if (r2off == (bfd_vma) -1)
10838             {
10839               htab->stub_error = TRUE;
10840               return FALSE;
10841             }
10842           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10843           loc += 4;
10844           size = 8;
10845           if (PPC_HA (r2off) != 0)
10846             {
10847               bfd_put_32 (htab->params->stub_bfd,
10848                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
10849               loc += 4;
10850               size += 4;
10851             }
10852           if (PPC_LO (r2off) != 0)
10853             {
10854               bfd_put_32 (htab->params->stub_bfd,
10855                           ADDI_R2_R2 | PPC_LO (r2off), loc);
10856               loc += 4;
10857               size += 4;
10858             }
10859           off -= size - 4;
10860         }
10861       bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10862
10863       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10864         {
10865           info->callbacks->einfo
10866             (_("%P: long branch stub `%s' offset overflow\n"),
10867              stub_entry->root.string);
10868           htab->stub_error = TRUE;
10869           return FALSE;
10870         }
10871
10872       if (info->emitrelocations)
10873         {
10874           r = get_relocs (stub_entry->group->stub_sec, 1);
10875           if (r == NULL)
10876             return FALSE;
10877           r->r_offset = loc - stub_entry->group->stub_sec->contents;
10878           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10879           r->r_addend = dest;
10880           if (stub_entry->h != NULL)
10881             {
10882               struct elf_link_hash_entry **hashes;
10883               unsigned long symndx;
10884               struct ppc_link_hash_entry *h;
10885
10886               hashes = elf_sym_hashes (htab->params->stub_bfd);
10887               if (hashes == NULL)
10888                 {
10889                   bfd_size_type hsize;
10890
10891                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10892                   hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
10893                   if (hashes == NULL)
10894                     return FALSE;
10895                   elf_sym_hashes (htab->params->stub_bfd) = hashes;
10896                   htab->stub_globals = 1;
10897                 }
10898               symndx = htab->stub_globals++;
10899               h = stub_entry->h;
10900               hashes[symndx] = &h->elf;
10901               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10902               if (h->oh != NULL && h->oh->is_func)
10903                 h = ppc_follow_link (h->oh);
10904               if (h->elf.root.u.def.section != stub_entry->target_section)
10905                 /* H is an opd symbol.  The addend must be zero.  */
10906                 r->r_addend = 0;
10907               else
10908                 {
10909                   off = (h->elf.root.u.def.value
10910                          + h->elf.root.u.def.section->output_offset
10911                          + h->elf.root.u.def.section->output_section->vma);
10912                   r->r_addend -= off;
10913                 }
10914             }
10915         }
10916       break;
10917
10918     case ppc_stub_plt_branch:
10919     case ppc_stub_plt_branch_r2off:
10920       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10921                                          stub_entry->root.string + 9,
10922                                          FALSE, FALSE);
10923       if (br_entry == NULL)
10924         {
10925           info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
10926                                   stub_entry->root.string);
10927           htab->stub_error = TRUE;
10928           return FALSE;
10929         }
10930
10931       dest = (stub_entry->target_value
10932               + stub_entry->target_section->output_offset
10933               + stub_entry->target_section->output_section->vma);
10934       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10935         dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10936
10937       bfd_put_64 (htab->brlt->owner, dest,
10938                   htab->brlt->contents + br_entry->offset);
10939
10940       if (br_entry->iter == htab->stub_iteration)
10941         {
10942           br_entry->iter = 0;
10943
10944           if (htab->relbrlt != NULL)
10945             {
10946               /* Create a reloc for the branch lookup table entry.  */
10947               Elf_Internal_Rela rela;
10948               bfd_byte *rl;
10949
10950               rela.r_offset = (br_entry->offset
10951                                + htab->brlt->output_offset
10952                                + htab->brlt->output_section->vma);
10953               rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10954               rela.r_addend = dest;
10955
10956               rl = htab->relbrlt->contents;
10957               rl += (htab->relbrlt->reloc_count++
10958                      * sizeof (Elf64_External_Rela));
10959               bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
10960             }
10961           else if (info->emitrelocations)
10962             {
10963               r = get_relocs (htab->brlt, 1);
10964               if (r == NULL)
10965                 return FALSE;
10966               /* brlt, being SEC_LINKER_CREATED does not go through the
10967                  normal reloc processing.  Symbols and offsets are not
10968                  translated from input file to output file form, so
10969                  set up the offset per the output file.  */
10970               r->r_offset = (br_entry->offset
10971                              + htab->brlt->output_offset
10972                              + htab->brlt->output_section->vma);
10973               r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10974               r->r_addend = dest;
10975             }
10976         }
10977
10978       dest = (br_entry->offset
10979               + htab->brlt->output_offset
10980               + htab->brlt->output_section->vma);
10981
10982       off = (dest
10983              - elf_gp (htab->brlt->output_section->owner)
10984              - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
10985
10986       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10987         {
10988           info->callbacks->einfo
10989             (_("%P: linkage table error against `%T'\n"),
10990              stub_entry->root.string);
10991           bfd_set_error (bfd_error_bad_value);
10992           htab->stub_error = TRUE;
10993           return FALSE;
10994         }
10995
10996       if (info->emitrelocations)
10997         {
10998           r = get_relocs (stub_entry->group->stub_sec, 1 + (PPC_HA (off) != 0));
10999           if (r == NULL)
11000             return FALSE;
11001           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11002           if (bfd_big_endian (info->output_bfd))
11003             r[0].r_offset += 2;
11004           if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
11005             r[0].r_offset += 4;
11006           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
11007           r[0].r_addend = dest;
11008           if (PPC_HA (off) != 0)
11009             {
11010               r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
11011               r[1].r_offset = r[0].r_offset + 4;
11012               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
11013               r[1].r_addend = r[0].r_addend;
11014             }
11015         }
11016
11017       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11018         {
11019           if (PPC_HA (off) != 0)
11020             {
11021               size = 16;
11022               bfd_put_32 (htab->params->stub_bfd,
11023                           ADDIS_R12_R2 | PPC_HA (off), loc);
11024               loc += 4;
11025               bfd_put_32 (htab->params->stub_bfd,
11026                           LD_R12_0R12 | PPC_LO (off), loc);
11027             }
11028           else
11029             {
11030               size = 12;
11031               bfd_put_32 (htab->params->stub_bfd,
11032                           LD_R12_0R2 | PPC_LO (off), loc);
11033             }
11034         }
11035       else
11036         {
11037           bfd_vma r2off = get_r2off (info, stub_entry);
11038
11039           if (r2off == (bfd_vma) -1)
11040             {
11041               htab->stub_error = TRUE;
11042               return FALSE;
11043             }
11044
11045           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
11046           loc += 4;
11047           size = 16;
11048           if (PPC_HA (off) != 0)
11049             {
11050               size += 4;
11051               bfd_put_32 (htab->params->stub_bfd,
11052                           ADDIS_R12_R2 | PPC_HA (off), loc);
11053               loc += 4;
11054               bfd_put_32 (htab->params->stub_bfd,
11055                           LD_R12_0R12 | PPC_LO (off), loc);
11056             }
11057           else
11058             bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
11059
11060           if (PPC_HA (r2off) != 0)
11061             {
11062               size += 4;
11063               loc += 4;
11064               bfd_put_32 (htab->params->stub_bfd,
11065                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
11066             }
11067           if (PPC_LO (r2off) != 0)
11068             {
11069               size += 4;
11070               loc += 4;
11071               bfd_put_32 (htab->params->stub_bfd,
11072                           ADDI_R2_R2 | PPC_LO (r2off), loc);
11073             }
11074         }
11075       loc += 4;
11076       bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, loc);
11077       loc += 4;
11078       bfd_put_32 (htab->params->stub_bfd, BCTR, loc);
11079       break;
11080
11081     case ppc_stub_plt_call:
11082     case ppc_stub_plt_call_r2save:
11083       if (stub_entry->h != NULL
11084           && stub_entry->h->is_func_descriptor
11085           && stub_entry->h->oh != NULL)
11086         {
11087           struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
11088
11089           /* If the old-ABI "dot-symbol" is undefined make it weak so
11090              we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.  */
11091           if (fh->elf.root.type == bfd_link_hash_undefined)
11092             fh->elf.root.type = bfd_link_hash_undefweak;
11093           /* Stop undo_symbol_twiddle changing it back to undefined.  */
11094           fh->was_undefined = 0;
11095         }
11096
11097       /* Now build the stub.  */
11098       dest = stub_entry->plt_ent->plt.offset & ~1;
11099       if (dest >= (bfd_vma) -2)
11100         abort ();
11101
11102       plt = htab->elf.splt;
11103       if (!htab->elf.dynamic_sections_created
11104           || stub_entry->h == NULL
11105           || stub_entry->h->elf.dynindx == -1)
11106         plt = htab->elf.iplt;
11107
11108       dest += plt->output_offset + plt->output_section->vma;
11109
11110       if (stub_entry->h == NULL
11111           && (stub_entry->plt_ent->plt.offset & 1) == 0)
11112         {
11113           Elf_Internal_Rela rela;
11114           bfd_byte *rl;
11115
11116           rela.r_offset = dest;
11117           if (htab->opd_abi)
11118             rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
11119           else
11120             rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
11121           rela.r_addend = (stub_entry->target_value
11122                            + stub_entry->target_section->output_offset
11123                            + stub_entry->target_section->output_section->vma);
11124
11125           rl = (htab->elf.irelplt->contents
11126                 + (htab->elf.irelplt->reloc_count++
11127                    * sizeof (Elf64_External_Rela)));
11128           bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
11129           stub_entry->plt_ent->plt.offset |= 1;
11130         }
11131
11132       off = (dest
11133              - elf_gp (plt->output_section->owner)
11134              - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11135
11136       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11137         {
11138           info->callbacks->einfo
11139             /* xgettext:c-format */
11140             (_("%P: linkage table error against `%T'\n"),
11141              stub_entry->h != NULL
11142              ? stub_entry->h->elf.root.root.string
11143              : "<local sym>");
11144           bfd_set_error (bfd_error_bad_value);
11145           htab->stub_error = TRUE;
11146           return FALSE;
11147         }
11148
11149       if (htab->params->plt_stub_align != 0)
11150         {
11151           unsigned pad = plt_stub_pad (htab, stub_entry, off);
11152
11153           stub_entry->group->stub_sec->size += pad;
11154           stub_entry->stub_offset = stub_entry->group->stub_sec->size;
11155           loc += pad;
11156         }
11157
11158       r = NULL;
11159       if (info->emitrelocations)
11160         {
11161           r = get_relocs (stub_entry->group->stub_sec,
11162                           ((PPC_HA (off) != 0)
11163                            + (htab->opd_abi
11164                               ? 2 + (htab->params->plt_static_chain
11165                                      && PPC_HA (off + 16) == PPC_HA (off))
11166                               : 1)));
11167           if (r == NULL)
11168             return FALSE;
11169           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11170           if (bfd_big_endian (info->output_bfd))
11171             r[0].r_offset += 2;
11172           r[0].r_addend = dest;
11173         }
11174       if (stub_entry->h != NULL
11175           && (stub_entry->h == htab->tls_get_addr_fd
11176               || stub_entry->h == htab->tls_get_addr)
11177           && htab->params->tls_get_addr_opt)
11178         p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
11179       else
11180         p = build_plt_stub (htab, stub_entry, loc, off, r);
11181       size = p - loc;
11182       break;
11183
11184     case ppc_stub_save_res:
11185       return TRUE;
11186
11187     default:
11188       BFD_FAIL ();
11189       return FALSE;
11190     }
11191
11192   stub_entry->group->stub_sec->size += size;
11193
11194   if (htab->params->emit_stub_syms)
11195     {
11196       struct elf_link_hash_entry *h;
11197       size_t len1, len2;
11198       char *name;
11199       const char *const stub_str[] = { "long_branch",
11200                                        "long_branch_r2off",
11201                                        "plt_branch",
11202                                        "plt_branch_r2off",
11203                                        "plt_call",
11204                                        "plt_call" };
11205
11206       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
11207       len2 = strlen (stub_entry->root.string);
11208       name = bfd_malloc (len1 + len2 + 2);
11209       if (name == NULL)
11210         return FALSE;
11211       memcpy (name, stub_entry->root.string, 9);
11212       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
11213       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
11214       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
11215       if (h == NULL)
11216         return FALSE;
11217       if (h->root.type == bfd_link_hash_new)
11218         {
11219           h->root.type = bfd_link_hash_defined;
11220           h->root.u.def.section = stub_entry->group->stub_sec;
11221           h->root.u.def.value = stub_entry->stub_offset;
11222           h->ref_regular = 1;
11223           h->def_regular = 1;
11224           h->ref_regular_nonweak = 1;
11225           h->forced_local = 1;
11226           h->non_elf = 0;
11227           h->root.linker_def = 1;
11228         }
11229     }
11230
11231   return TRUE;
11232 }
11233
11234 /* As above, but don't actually build the stub.  Just bump offset so
11235    we know stub section sizes, and select plt_branch stubs where
11236    long_branch stubs won't do.  */
11237
11238 static bfd_boolean
11239 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11240 {
11241   struct ppc_stub_hash_entry *stub_entry;
11242   struct bfd_link_info *info;
11243   struct ppc_link_hash_table *htab;
11244   bfd_vma off;
11245   int size;
11246
11247   /* Massage our args to the form they really have.  */
11248   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11249   info = in_arg;
11250
11251   htab = ppc_hash_table (info);
11252   if (htab == NULL)
11253     return FALSE;
11254
11255   if (stub_entry->h != NULL
11256       && stub_entry->h->save_res
11257       && stub_entry->h->elf.root.type == bfd_link_hash_defined
11258       && stub_entry->h->elf.root.u.def.section == htab->sfpr)
11259     {
11260       /* Don't make stubs to out-of-line register save/restore
11261          functions.  Instead, emit copies of the functions.  */
11262       stub_entry->group->needs_save_res = 1;
11263       stub_entry->stub_type = ppc_stub_save_res;
11264       return TRUE;
11265     }
11266
11267   if (stub_entry->stub_type == ppc_stub_plt_call
11268       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11269     {
11270       asection *plt;
11271       off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
11272       if (off >= (bfd_vma) -2)
11273         abort ();
11274       plt = htab->elf.splt;
11275       if (!htab->elf.dynamic_sections_created
11276           || stub_entry->h == NULL
11277           || stub_entry->h->elf.dynindx == -1)
11278         plt = htab->elf.iplt;
11279       off += (plt->output_offset
11280               + plt->output_section->vma
11281               - elf_gp (plt->output_section->owner)
11282               - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11283
11284       size = plt_stub_size (htab, stub_entry, off);
11285       if (htab->params->plt_stub_align)
11286         size += plt_stub_pad (htab, stub_entry, off);
11287       if (info->emitrelocations)
11288         {
11289           stub_entry->group->stub_sec->reloc_count
11290             += ((PPC_HA (off) != 0)
11291                 + (htab->opd_abi
11292                    ? 2 + (htab->params->plt_static_chain
11293                           && PPC_HA (off + 16) == PPC_HA (off))
11294                    : 1));
11295           stub_entry->group->stub_sec->flags |= SEC_RELOC;
11296         }
11297     }
11298   else
11299     {
11300       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
11301          variants.  */
11302       bfd_vma r2off = 0;
11303       bfd_vma local_off = 0;
11304
11305       off = (stub_entry->target_value
11306              + stub_entry->target_section->output_offset
11307              + stub_entry->target_section->output_section->vma);
11308       off -= (stub_entry->group->stub_sec->size
11309               + stub_entry->group->stub_sec->output_offset
11310               + stub_entry->group->stub_sec->output_section->vma);
11311
11312       /* Reset the stub type from the plt variant in case we now
11313          can reach with a shorter stub.  */
11314       if (stub_entry->stub_type >= ppc_stub_plt_branch)
11315         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
11316
11317       size = 4;
11318       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11319         {
11320           r2off = get_r2off (info, stub_entry);
11321           if (r2off == (bfd_vma) -1)
11322             {
11323               htab->stub_error = TRUE;
11324               return FALSE;
11325             }
11326           size = 8;
11327           if (PPC_HA (r2off) != 0)
11328             size += 4;
11329           if (PPC_LO (r2off) != 0)
11330             size += 4;
11331           off -= size - 4;
11332         }
11333
11334       local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11335
11336       /* If the branch offset if too big, use a ppc_stub_plt_branch.
11337          Do the same for -R objects without function descriptors.  */
11338       if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
11339           || (stub_entry->stub_type == ppc_stub_long_branch_r2off
11340               && r2off == 0
11341               && htab->sec_info[stub_entry->target_section->id].toc_off == 0))
11342         {
11343           struct ppc_branch_hash_entry *br_entry;
11344
11345           br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11346                                              stub_entry->root.string + 9,
11347                                              TRUE, FALSE);
11348           if (br_entry == NULL)
11349             {
11350               info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
11351                                       stub_entry->root.string);
11352               htab->stub_error = TRUE;
11353               return FALSE;
11354             }
11355
11356           if (br_entry->iter != htab->stub_iteration)
11357             {
11358               br_entry->iter = htab->stub_iteration;
11359               br_entry->offset = htab->brlt->size;
11360               htab->brlt->size += 8;
11361
11362               if (htab->relbrlt != NULL)
11363                 htab->relbrlt->size += sizeof (Elf64_External_Rela);
11364               else if (info->emitrelocations)
11365                 {
11366                   htab->brlt->reloc_count += 1;
11367                   htab->brlt->flags |= SEC_RELOC;
11368                 }
11369             }
11370
11371           stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
11372           off = (br_entry->offset
11373                  + htab->brlt->output_offset
11374                  + htab->brlt->output_section->vma
11375                  - elf_gp (htab->brlt->output_section->owner)
11376                  - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11377
11378           if (info->emitrelocations)
11379             {
11380               stub_entry->group->stub_sec->reloc_count
11381                 += 1 + (PPC_HA (off) != 0);
11382               stub_entry->group->stub_sec->flags |= SEC_RELOC;
11383             }
11384
11385           if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11386             {
11387               size = 12;
11388               if (PPC_HA (off) != 0)
11389                 size = 16;
11390             }
11391           else
11392             {
11393               size = 16;
11394               if (PPC_HA (off) != 0)
11395                 size += 4;
11396
11397               if (PPC_HA (r2off) != 0)
11398                 size += 4;
11399               if (PPC_LO (r2off) != 0)
11400                 size += 4;
11401             }
11402         }
11403       else if (info->emitrelocations)
11404         {
11405           stub_entry->group->stub_sec->reloc_count += 1;
11406           stub_entry->group->stub_sec->flags |= SEC_RELOC;
11407         }
11408     }
11409
11410   stub_entry->group->stub_sec->size += size;
11411   return TRUE;
11412 }
11413
11414 /* Set up various things so that we can make a list of input sections
11415    for each output section included in the link.  Returns -1 on error,
11416    0 when no stubs will be needed, and 1 on success.  */
11417
11418 int
11419 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
11420 {
11421   unsigned int id;
11422   bfd_size_type amt;
11423   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11424
11425   if (htab == NULL)
11426     return -1;
11427
11428   htab->sec_info_arr_size = bfd_get_next_section_id ();
11429   amt = sizeof (*htab->sec_info) * (htab->sec_info_arr_size);
11430   htab->sec_info = bfd_zmalloc (amt);
11431   if (htab->sec_info == NULL)
11432     return -1;
11433
11434   /* Set toc_off for com, und, abs and ind sections.  */
11435   for (id = 0; id < 3; id++)
11436     htab->sec_info[id].toc_off = TOC_BASE_OFF;
11437
11438   return 1;
11439 }
11440
11441 /* Set up for first pass at multitoc partitioning.  */
11442
11443 void
11444 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11445 {
11446   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11447
11448   htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11449   htab->toc_bfd = NULL;
11450   htab->toc_first_sec = NULL;
11451 }
11452
11453 /* The linker repeatedly calls this function for each TOC input section
11454    and linker generated GOT section.  Group input bfds such that the toc
11455    within a group is less than 64k in size.  */
11456
11457 bfd_boolean
11458 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11459 {
11460   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11461   bfd_vma addr, off, limit;
11462
11463   if (htab == NULL)
11464     return FALSE;
11465
11466   if (!htab->second_toc_pass)
11467     {
11468       /* Keep track of the first .toc or .got section for this input bfd.  */
11469       bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11470
11471       if (new_bfd)
11472         {
11473           htab->toc_bfd = isec->owner;
11474           htab->toc_first_sec = isec;
11475         }
11476
11477       addr = isec->output_offset + isec->output_section->vma;
11478       off = addr - htab->toc_curr;
11479       limit = 0x80008000;
11480       if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11481         limit = 0x10000;
11482       if (off + isec->size > limit)
11483         {
11484           addr = (htab->toc_first_sec->output_offset
11485                   + htab->toc_first_sec->output_section->vma);
11486           htab->toc_curr = addr;
11487           htab->toc_curr &= -TOC_BASE_ALIGN;
11488         }
11489
11490       /* toc_curr is the base address of this toc group.  Set elf_gp
11491          for the input section to be the offset relative to the
11492          output toc base plus 0x8000.  Making the input elf_gp an
11493          offset allows us to move the toc as a whole without
11494          recalculating input elf_gp.  */
11495       off = htab->toc_curr - elf_gp (isec->output_section->owner);
11496       off += TOC_BASE_OFF;
11497
11498       /* Die if someone uses a linker script that doesn't keep input
11499          file .toc and .got together.  */
11500       if (new_bfd
11501           && elf_gp (isec->owner) != 0
11502           && elf_gp (isec->owner) != off)
11503         return FALSE;
11504
11505       elf_gp (isec->owner) = off;
11506       return TRUE;
11507     }
11508
11509   /* During the second pass toc_first_sec points to the start of
11510      a toc group, and toc_curr is used to track the old elf_gp.
11511      We use toc_bfd to ensure we only look at each bfd once.  */
11512   if (htab->toc_bfd == isec->owner)
11513     return TRUE;
11514   htab->toc_bfd = isec->owner;
11515
11516   if (htab->toc_first_sec == NULL
11517       || htab->toc_curr != elf_gp (isec->owner))
11518     {
11519       htab->toc_curr = elf_gp (isec->owner);
11520       htab->toc_first_sec = isec;
11521     }
11522   addr = (htab->toc_first_sec->output_offset
11523           + htab->toc_first_sec->output_section->vma);
11524   off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
11525   elf_gp (isec->owner) = off;
11526
11527   return TRUE;
11528 }
11529
11530 /* Called via elf_link_hash_traverse to merge GOT entries for global
11531    symbol H.  */
11532
11533 static bfd_boolean
11534 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11535 {
11536   if (h->root.type == bfd_link_hash_indirect)
11537     return TRUE;
11538
11539   merge_got_entries (&h->got.glist);
11540
11541   return TRUE;
11542 }
11543
11544 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11545    symbol H.  */
11546
11547 static bfd_boolean
11548 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11549 {
11550   struct got_entry *gent;
11551
11552   if (h->root.type == bfd_link_hash_indirect)
11553     return TRUE;
11554
11555   for (gent = h->got.glist; gent != NULL; gent = gent->next)
11556     if (!gent->is_indirect)
11557       allocate_got (h, (struct bfd_link_info *) inf, gent);
11558   return TRUE;
11559 }
11560
11561 /* Called on the first multitoc pass after the last call to
11562    ppc64_elf_next_toc_section.  This function removes duplicate GOT
11563    entries.  */
11564
11565 bfd_boolean
11566 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11567 {
11568   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11569   struct bfd *ibfd, *ibfd2;
11570   bfd_boolean done_something;
11571
11572   htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11573
11574   if (!htab->do_multi_toc)
11575     return FALSE;
11576
11577   /* Merge global sym got entries within a toc group.  */
11578   elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11579
11580   /* And tlsld_got.  */
11581   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11582     {
11583       struct got_entry *ent, *ent2;
11584
11585       if (!is_ppc64_elf (ibfd))
11586         continue;
11587
11588       ent = ppc64_tlsld_got (ibfd);
11589       if (!ent->is_indirect
11590           && ent->got.offset != (bfd_vma) -1)
11591         {
11592           for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
11593             {
11594               if (!is_ppc64_elf (ibfd2))
11595                 continue;
11596
11597               ent2 = ppc64_tlsld_got (ibfd2);
11598               if (!ent2->is_indirect
11599                   && ent2->got.offset != (bfd_vma) -1
11600                   && elf_gp (ibfd2) == elf_gp (ibfd))
11601                 {
11602                   ent2->is_indirect = TRUE;
11603                   ent2->got.ent = ent;
11604                 }
11605             }
11606         }
11607     }
11608
11609   /* Zap sizes of got sections.  */
11610   htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11611   htab->elf.irelplt->size -= htab->got_reli_size;
11612   htab->got_reli_size = 0;
11613
11614   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11615     {
11616       asection *got, *relgot;
11617
11618       if (!is_ppc64_elf (ibfd))
11619         continue;
11620
11621       got = ppc64_elf_tdata (ibfd)->got;
11622       if (got != NULL)
11623         {
11624           got->rawsize = got->size;
11625           got->size = 0;
11626           relgot = ppc64_elf_tdata (ibfd)->relgot;
11627           relgot->rawsize = relgot->size;
11628           relgot->size = 0;
11629         }
11630     }
11631
11632   /* Now reallocate the got, local syms first.  We don't need to
11633      allocate section contents again since we never increase size.  */
11634   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11635     {
11636       struct got_entry **lgot_ents;
11637       struct got_entry **end_lgot_ents;
11638       struct plt_entry **local_plt;
11639       struct plt_entry **end_local_plt;
11640       unsigned char *lgot_masks;
11641       bfd_size_type locsymcount;
11642       Elf_Internal_Shdr *symtab_hdr;
11643       asection *s;
11644
11645       if (!is_ppc64_elf (ibfd))
11646         continue;
11647
11648       lgot_ents = elf_local_got_ents (ibfd);
11649       if (!lgot_ents)
11650         continue;
11651
11652       symtab_hdr = &elf_symtab_hdr (ibfd);
11653       locsymcount = symtab_hdr->sh_info;
11654       end_lgot_ents = lgot_ents + locsymcount;
11655       local_plt = (struct plt_entry **) end_lgot_ents;
11656       end_local_plt = local_plt + locsymcount;
11657       lgot_masks = (unsigned char *) end_local_plt;
11658       s = ppc64_elf_tdata (ibfd)->got;
11659       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11660         {
11661           struct got_entry *ent;
11662
11663           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11664             {
11665               unsigned int ent_size = 8;
11666               unsigned int rel_size = sizeof (Elf64_External_Rela);
11667
11668               ent->got.offset = s->size;
11669               if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11670                 {
11671                   ent_size *= 2;
11672                   rel_size *= 2;
11673                 }
11674               s->size += ent_size;
11675               if ((*lgot_masks & PLT_IFUNC) != 0)
11676                 {
11677                   htab->elf.irelplt->size += rel_size;
11678                   htab->got_reli_size += rel_size;
11679                 }
11680               else if (bfd_link_pic (info))
11681                 {
11682                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11683                   srel->size += rel_size;
11684                 }
11685             }
11686         }
11687     }
11688
11689   elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11690
11691   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11692     {
11693       struct got_entry *ent;
11694
11695       if (!is_ppc64_elf (ibfd))
11696         continue;
11697
11698       ent = ppc64_tlsld_got (ibfd);
11699       if (!ent->is_indirect
11700           && ent->got.offset != (bfd_vma) -1)
11701         {
11702           asection *s = ppc64_elf_tdata (ibfd)->got;
11703           ent->got.offset = s->size;
11704           s->size += 16;
11705           if (bfd_link_pic (info))
11706             {
11707               asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11708               srel->size += sizeof (Elf64_External_Rela);
11709             }
11710         }
11711     }
11712
11713   done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11714   if (!done_something)
11715     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11716       {
11717         asection *got;
11718
11719         if (!is_ppc64_elf (ibfd))
11720           continue;
11721
11722         got = ppc64_elf_tdata (ibfd)->got;
11723         if (got != NULL)
11724           {
11725             done_something = got->rawsize != got->size;
11726             if (done_something)
11727               break;
11728           }
11729       }
11730
11731   if (done_something)
11732     (*htab->params->layout_sections_again) ();
11733
11734   /* Set up for second pass over toc sections to recalculate elf_gp
11735      on input sections.  */
11736   htab->toc_bfd = NULL;
11737   htab->toc_first_sec = NULL;
11738   htab->second_toc_pass = TRUE;
11739   return done_something;
11740 }
11741
11742 /* Called after second pass of multitoc partitioning.  */
11743
11744 void
11745 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11746 {
11747   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11748
11749   /* After the second pass, toc_curr tracks the TOC offset used
11750      for code sections below in ppc64_elf_next_input_section.  */
11751   htab->toc_curr = TOC_BASE_OFF;
11752 }
11753
11754 /* No toc references were found in ISEC.  If the code in ISEC makes no
11755    calls, then there's no need to use toc adjusting stubs when branching
11756    into ISEC.  Actually, indirect calls from ISEC are OK as they will
11757    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
11758    needed, and 2 if a cyclical call-graph was found but no other reason
11759    for a stub was detected.  If called from the top level, a return of
11760    2 means the same as a return of 0.  */
11761
11762 static int
11763 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11764 {
11765   int ret;
11766
11767   /* Mark this section as checked.  */
11768   isec->call_check_done = 1;
11769
11770   /* We know none of our code bearing sections will need toc stubs.  */
11771   if ((isec->flags & SEC_LINKER_CREATED) != 0)
11772     return 0;
11773
11774   if (isec->size == 0)
11775     return 0;
11776
11777   if (isec->output_section == NULL)
11778     return 0;
11779
11780   ret = 0;
11781   if (isec->reloc_count != 0)
11782     {
11783       Elf_Internal_Rela *relstart, *rel;
11784       Elf_Internal_Sym *local_syms;
11785       struct ppc_link_hash_table *htab;
11786
11787       relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11788                                             info->keep_memory);
11789       if (relstart == NULL)
11790         return -1;
11791
11792       /* Look for branches to outside of this section.  */
11793       local_syms = NULL;
11794       htab = ppc_hash_table (info);
11795       if (htab == NULL)
11796         return -1;
11797
11798       for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11799         {
11800           enum elf_ppc64_reloc_type r_type;
11801           unsigned long r_symndx;
11802           struct elf_link_hash_entry *h;
11803           struct ppc_link_hash_entry *eh;
11804           Elf_Internal_Sym *sym;
11805           asection *sym_sec;
11806           struct _opd_sec_data *opd;
11807           bfd_vma sym_value;
11808           bfd_vma dest;
11809
11810           r_type = ELF64_R_TYPE (rel->r_info);
11811           if (r_type != R_PPC64_REL24
11812               && r_type != R_PPC64_REL14
11813               && r_type != R_PPC64_REL14_BRTAKEN
11814               && r_type != R_PPC64_REL14_BRNTAKEN)
11815             continue;
11816
11817           r_symndx = ELF64_R_SYM (rel->r_info);
11818           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11819                           isec->owner))
11820             {
11821               ret = -1;
11822               break;
11823             }
11824
11825           /* Calls to dynamic lib functions go through a plt call stub
11826              that uses r2.  */
11827           eh = (struct ppc_link_hash_entry *) h;
11828           if (eh != NULL
11829               && (eh->elf.plt.plist != NULL
11830                   || (eh->oh != NULL
11831                       && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11832             {
11833               ret = 1;
11834               break;
11835             }
11836
11837           if (sym_sec == NULL)
11838             /* Ignore other undefined symbols.  */
11839             continue;
11840
11841           /* Assume branches to other sections not included in the
11842              link need stubs too, to cover -R and absolute syms.  */
11843           if (sym_sec->output_section == NULL)
11844             {
11845               ret = 1;
11846               break;
11847             }
11848
11849           if (h == NULL)
11850             sym_value = sym->st_value;
11851           else
11852             {
11853               if (h->root.type != bfd_link_hash_defined
11854                   && h->root.type != bfd_link_hash_defweak)
11855                 abort ();
11856               sym_value = h->root.u.def.value;
11857             }
11858           sym_value += rel->r_addend;
11859
11860           /* If this branch reloc uses an opd sym, find the code section.  */
11861           opd = get_opd_info (sym_sec);
11862           if (opd != NULL)
11863             {
11864               if (h == NULL && opd->adjust != NULL)
11865                 {
11866                   long adjust;
11867
11868                   adjust = opd->adjust[OPD_NDX (sym_value)];
11869                   if (adjust == -1)
11870                     /* Assume deleted functions won't ever be called.  */
11871                     continue;
11872                   sym_value += adjust;
11873                 }
11874
11875               dest = opd_entry_value (sym_sec, sym_value,
11876                                       &sym_sec, NULL, FALSE);
11877               if (dest == (bfd_vma) -1)
11878                 continue;
11879             }
11880           else
11881             dest = (sym_value
11882                     + sym_sec->output_offset
11883                     + sym_sec->output_section->vma);
11884
11885           /* Ignore branch to self.  */
11886           if (sym_sec == isec)
11887             continue;
11888
11889           /* If the called function uses the toc, we need a stub.  */
11890           if (sym_sec->has_toc_reloc
11891               || sym_sec->makes_toc_func_call)
11892             {
11893               ret = 1;
11894               break;
11895             }
11896
11897           /* Assume any branch that needs a long branch stub might in fact
11898              need a plt_branch stub.  A plt_branch stub uses r2.  */
11899           else if (dest - (isec->output_offset
11900                            + isec->output_section->vma
11901                            + rel->r_offset) + (1 << 25)
11902                    >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
11903                                                              ? h->other
11904                                                              : sym->st_other))
11905             {
11906               ret = 1;
11907               break;
11908             }
11909
11910           /* If calling back to a section in the process of being
11911              tested, we can't say for sure that no toc adjusting stubs
11912              are needed, so don't return zero.  */
11913           else if (sym_sec->call_check_in_progress)
11914             ret = 2;
11915
11916           /* Branches to another section that itself doesn't have any TOC
11917              references are OK.  Recursively call ourselves to check.  */
11918           else if (!sym_sec->call_check_done)
11919             {
11920               int recur;
11921
11922               /* Mark current section as indeterminate, so that other
11923                  sections that call back to current won't be marked as
11924                  known.  */
11925               isec->call_check_in_progress = 1;
11926               recur = toc_adjusting_stub_needed (info, sym_sec);
11927               isec->call_check_in_progress = 0;
11928
11929               if (recur != 0)
11930                 {
11931                   ret = recur;
11932                   if (recur != 2)
11933                     break;
11934                 }
11935             }
11936         }
11937
11938       if (local_syms != NULL
11939           && (elf_symtab_hdr (isec->owner).contents
11940               != (unsigned char *) local_syms))
11941         free (local_syms);
11942       if (elf_section_data (isec)->relocs != relstart)
11943         free (relstart);
11944     }
11945
11946   if ((ret & 1) == 0
11947       && isec->map_head.s != NULL
11948       && (strcmp (isec->output_section->name, ".init") == 0
11949           || strcmp (isec->output_section->name, ".fini") == 0))
11950     {
11951       if (isec->map_head.s->has_toc_reloc
11952           || isec->map_head.s->makes_toc_func_call)
11953         ret = 1;
11954       else if (!isec->map_head.s->call_check_done)
11955         {
11956           int recur;
11957           isec->call_check_in_progress = 1;
11958           recur = toc_adjusting_stub_needed (info, isec->map_head.s);
11959           isec->call_check_in_progress = 0;
11960           if (recur != 0)
11961             ret = recur;
11962         }
11963     }
11964
11965   if (ret == 1)
11966     isec->makes_toc_func_call = 1;
11967
11968   return ret;
11969 }
11970
11971 /* The linker repeatedly calls this function for each input section,
11972    in the order that input sections are linked into output sections.
11973    Build lists of input sections to determine groupings between which
11974    we may insert linker stubs.  */
11975
11976 bfd_boolean
11977 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
11978 {
11979   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11980
11981   if (htab == NULL)
11982     return FALSE;
11983
11984   if ((isec->output_section->flags & SEC_CODE) != 0
11985       && isec->output_section->id < htab->sec_info_arr_size)
11986     {
11987       /* This happens to make the list in reverse order,
11988          which is what we want.  */
11989       htab->sec_info[isec->id].u.list
11990         = htab->sec_info[isec->output_section->id].u.list;
11991       htab->sec_info[isec->output_section->id].u.list = isec;
11992     }
11993
11994   if (htab->multi_toc_needed)
11995     {
11996       /* Analyse sections that aren't already flagged as needing a
11997          valid toc pointer.  Exclude .fixup for the linux kernel.
11998          .fixup contains branches, but only back to the function that
11999          hit an exception.  */
12000       if (!(isec->has_toc_reloc
12001             || (isec->flags & SEC_CODE) == 0
12002             || strcmp (isec->name, ".fixup") == 0
12003             || isec->call_check_done))
12004         {
12005           if (toc_adjusting_stub_needed (info, isec) < 0)
12006             return FALSE;
12007         }
12008       /* Make all sections use the TOC assigned for this object file.
12009          This will be wrong for pasted sections;  We fix that in
12010          check_pasted_section().  */
12011       if (elf_gp (isec->owner) != 0)
12012         htab->toc_curr = elf_gp (isec->owner);
12013     }
12014
12015   htab->sec_info[isec->id].toc_off = htab->toc_curr;
12016   return TRUE;
12017 }
12018
12019 /* Check that all .init and .fini sections use the same toc, if they
12020    have toc relocs.  */
12021
12022 static bfd_boolean
12023 check_pasted_section (struct bfd_link_info *info, const char *name)
12024 {
12025   asection *o = bfd_get_section_by_name (info->output_bfd, name);
12026
12027   if (o != NULL)
12028     {
12029       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12030       bfd_vma toc_off = 0;
12031       asection *i;
12032
12033       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12034         if (i->has_toc_reloc)
12035           {
12036             if (toc_off == 0)
12037               toc_off = htab->sec_info[i->id].toc_off;
12038             else if (toc_off != htab->sec_info[i->id].toc_off)
12039               return FALSE;
12040           }
12041
12042       if (toc_off == 0)
12043         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12044           if (i->makes_toc_func_call)
12045             {
12046               toc_off = htab->sec_info[i->id].toc_off;
12047               break;
12048             }
12049
12050       /* Make sure the whole pasted function uses the same toc offset.  */
12051       if (toc_off != 0)
12052         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12053           htab->sec_info[i->id].toc_off = toc_off;
12054     }
12055   return TRUE;
12056 }
12057
12058 bfd_boolean
12059 ppc64_elf_check_init_fini (struct bfd_link_info *info)
12060 {
12061   return (check_pasted_section (info, ".init")
12062           & check_pasted_section (info, ".fini"));
12063 }
12064
12065 /* See whether we can group stub sections together.  Grouping stub
12066    sections may result in fewer stubs.  More importantly, we need to
12067    put all .init* and .fini* stubs at the beginning of the .init or
12068    .fini output sections respectively, because glibc splits the
12069    _init and _fini functions into multiple parts.  Putting a stub in
12070    the middle of a function is not a good idea.  */
12071
12072 static bfd_boolean
12073 group_sections (struct bfd_link_info *info,
12074                 bfd_size_type stub_group_size,
12075                 bfd_boolean stubs_always_before_branch)
12076 {
12077   struct ppc_link_hash_table *htab;
12078   asection *osec;
12079   bfd_boolean suppress_size_errors;
12080
12081   htab = ppc_hash_table (info);
12082   if (htab == NULL)
12083     return FALSE;
12084
12085   suppress_size_errors = FALSE;
12086   if (stub_group_size == 1)
12087     {
12088       /* Default values.  */
12089       if (stubs_always_before_branch)
12090         stub_group_size = 0x1e00000;
12091       else
12092         stub_group_size = 0x1c00000;
12093       suppress_size_errors = TRUE;
12094     }
12095
12096   for (osec = info->output_bfd->sections; osec != NULL; osec = osec->next)
12097     {
12098       asection *tail;
12099
12100       if (osec->id >= htab->sec_info_arr_size)
12101         continue;
12102
12103       tail = htab->sec_info[osec->id].u.list;
12104       while (tail != NULL)
12105         {
12106           asection *curr;
12107           asection *prev;
12108           bfd_size_type total;
12109           bfd_boolean big_sec;
12110           bfd_vma curr_toc;
12111           struct map_stub *group;
12112           bfd_size_type group_size;
12113
12114           curr = tail;
12115           total = tail->size;
12116           group_size = (ppc64_elf_section_data (tail) != NULL
12117                         && ppc64_elf_section_data (tail)->has_14bit_branch
12118                         ? stub_group_size >> 10 : stub_group_size);
12119
12120           big_sec = total > group_size;
12121           if (big_sec && !suppress_size_errors)
12122             /* xgettext:c-format */
12123             _bfd_error_handler (_("%B section %A exceeds stub group size"),
12124                                 tail->owner, tail);
12125           curr_toc = htab->sec_info[tail->id].toc_off;
12126
12127           while ((prev = htab->sec_info[curr->id].u.list) != NULL
12128                  && ((total += curr->output_offset - prev->output_offset)
12129                      < (ppc64_elf_section_data (prev) != NULL
12130                         && ppc64_elf_section_data (prev)->has_14bit_branch
12131                         ? (group_size = stub_group_size >> 10) : group_size))
12132                  && htab->sec_info[prev->id].toc_off == curr_toc)
12133             curr = prev;
12134
12135           /* OK, the size from the start of CURR to the end is less
12136              than group_size and thus can be handled by one stub
12137              section.  (or the tail section is itself larger than
12138              group_size, in which case we may be toast.)  We should
12139              really be keeping track of the total size of stubs added
12140              here, as stubs contribute to the final output section
12141              size.  That's a little tricky, and this way will only
12142              break if stubs added make the total size more than 2^25,
12143              ie. for the default stub_group_size, if stubs total more
12144              than 2097152 bytes, or nearly 75000 plt call stubs.  */
12145           group = bfd_alloc (curr->owner, sizeof (*group));
12146           if (group == NULL)
12147             return FALSE;
12148           group->link_sec = curr;
12149           group->stub_sec = NULL;
12150           group->needs_save_res = 0;
12151           group->next = htab->group;
12152           htab->group = group;
12153           do
12154             {
12155               prev = htab->sec_info[tail->id].u.list;
12156               /* Set up this stub group.  */
12157               htab->sec_info[tail->id].u.group = group;
12158             }
12159           while (tail != curr && (tail = prev) != NULL);
12160
12161           /* But wait, there's more!  Input sections up to group_size
12162              bytes before the stub section can be handled by it too.
12163              Don't do this if we have a really large section after the
12164              stubs, as adding more stubs increases the chance that
12165              branches may not reach into the stub section.  */
12166           if (!stubs_always_before_branch && !big_sec)
12167             {
12168               total = 0;
12169               while (prev != NULL
12170                      && ((total += tail->output_offset - prev->output_offset)
12171                          < (ppc64_elf_section_data (prev) != NULL
12172                             && ppc64_elf_section_data (prev)->has_14bit_branch
12173                             ? (group_size = stub_group_size >> 10) : group_size))
12174                      && htab->sec_info[prev->id].toc_off == curr_toc)
12175                 {
12176                   tail = prev;
12177                   prev = htab->sec_info[tail->id].u.list;
12178                   htab->sec_info[tail->id].u.group = group;
12179                 }
12180             }
12181           tail = prev;
12182         }
12183     }
12184   return TRUE;
12185 }
12186
12187 static const unsigned char glink_eh_frame_cie[] =
12188 {
12189   0, 0, 0, 16,                          /* length.  */
12190   0, 0, 0, 0,                           /* id.  */
12191   1,                                    /* CIE version.  */
12192   'z', 'R', 0,                          /* Augmentation string.  */
12193   4,                                    /* Code alignment.  */
12194   0x78,                                 /* Data alignment.  */
12195   65,                                   /* RA reg.  */
12196   1,                                    /* Augmentation size.  */
12197   DW_EH_PE_pcrel | DW_EH_PE_sdata4,     /* FDE encoding.  */
12198   DW_CFA_def_cfa, 1, 0,                 /* def_cfa: r1 offset 0.  */
12199   0, 0, 0, 0
12200 };
12201
12202 /* Stripping output sections is normally done before dynamic section
12203    symbols have been allocated.  This function is called later, and
12204    handles cases like htab->brlt which is mapped to its own output
12205    section.  */
12206
12207 static void
12208 maybe_strip_output (struct bfd_link_info *info, asection *isec)
12209 {
12210   if (isec->size == 0
12211       && isec->output_section->size == 0
12212       && !(isec->output_section->flags & SEC_KEEP)
12213       && !bfd_section_removed_from_list (info->output_bfd,
12214                                          isec->output_section)
12215       && elf_section_data (isec->output_section)->dynindx == 0)
12216     {
12217       isec->output_section->flags |= SEC_EXCLUDE;
12218       bfd_section_list_remove (info->output_bfd, isec->output_section);
12219       info->output_bfd->section_count--;
12220     }
12221 }
12222
12223 /* Determine and set the size of the stub section for a final link.
12224
12225    The basic idea here is to examine all the relocations looking for
12226    PC-relative calls to a target that is unreachable with a "bl"
12227    instruction.  */
12228
12229 bfd_boolean
12230 ppc64_elf_size_stubs (struct bfd_link_info *info)
12231 {
12232   bfd_size_type stub_group_size;
12233   bfd_boolean stubs_always_before_branch;
12234   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12235
12236   if (htab == NULL)
12237     return FALSE;
12238
12239   if (htab->params->plt_thread_safe == -1 && !bfd_link_executable (info))
12240     htab->params->plt_thread_safe = 1;
12241   if (!htab->opd_abi)
12242     htab->params->plt_thread_safe = 0;
12243   else if (htab->params->plt_thread_safe == -1)
12244     {
12245       static const char *const thread_starter[] =
12246         {
12247           "pthread_create",
12248           /* libstdc++ */
12249           "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
12250           /* librt */
12251           "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
12252           "mq_notify", "create_timer",
12253           /* libanl */
12254           "getaddrinfo_a",
12255           /* libgomp */
12256           "GOMP_parallel",
12257           "GOMP_parallel_start",
12258           "GOMP_parallel_loop_static",
12259           "GOMP_parallel_loop_static_start",
12260           "GOMP_parallel_loop_dynamic",
12261           "GOMP_parallel_loop_dynamic_start",
12262           "GOMP_parallel_loop_guided",
12263           "GOMP_parallel_loop_guided_start",
12264           "GOMP_parallel_loop_runtime",
12265           "GOMP_parallel_loop_runtime_start",
12266           "GOMP_parallel_sections",
12267           "GOMP_parallel_sections_start",
12268           /* libgo */
12269           "__go_go",
12270         };
12271       unsigned i;
12272
12273       for (i = 0; i < ARRAY_SIZE (thread_starter); i++)
12274         {
12275           struct elf_link_hash_entry *h;
12276           h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
12277                                     FALSE, FALSE, TRUE);
12278           htab->params->plt_thread_safe = h != NULL && h->ref_regular;
12279           if (htab->params->plt_thread_safe)
12280             break;
12281         }
12282     }
12283   stubs_always_before_branch = htab->params->group_size < 0;
12284   if (htab->params->group_size < 0)
12285     stub_group_size = -htab->params->group_size;
12286   else
12287     stub_group_size = htab->params->group_size;
12288
12289   if (!group_sections (info, stub_group_size, stubs_always_before_branch))
12290     return FALSE;
12291
12292 #define STUB_SHRINK_ITER 20
12293   /* Loop until no stubs added.  After iteration 20 of this loop we may
12294      exit on a stub section shrinking.  This is to break out of a
12295      pathological case where adding stubs on one iteration decreases
12296      section gaps (perhaps due to alignment), which then requires
12297      fewer or smaller stubs on the next iteration.  */
12298
12299   while (1)
12300     {
12301       bfd *input_bfd;
12302       unsigned int bfd_indx;
12303       struct map_stub *group;
12304       asection *stub_sec;
12305
12306       htab->stub_iteration += 1;
12307
12308       for (input_bfd = info->input_bfds, bfd_indx = 0;
12309            input_bfd != NULL;
12310            input_bfd = input_bfd->link.next, bfd_indx++)
12311         {
12312           Elf_Internal_Shdr *symtab_hdr;
12313           asection *section;
12314           Elf_Internal_Sym *local_syms = NULL;
12315
12316           if (!is_ppc64_elf (input_bfd))
12317             continue;
12318
12319           /* We'll need the symbol table in a second.  */
12320           symtab_hdr = &elf_symtab_hdr (input_bfd);
12321           if (symtab_hdr->sh_info == 0)
12322             continue;
12323
12324           /* Walk over each section attached to the input bfd.  */
12325           for (section = input_bfd->sections;
12326                section != NULL;
12327                section = section->next)
12328             {
12329               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
12330
12331               /* If there aren't any relocs, then there's nothing more
12332                  to do.  */
12333               if ((section->flags & SEC_RELOC) == 0
12334                   || (section->flags & SEC_ALLOC) == 0
12335                   || (section->flags & SEC_LOAD) == 0
12336                   || (section->flags & SEC_CODE) == 0
12337                   || section->reloc_count == 0)
12338                 continue;
12339
12340               /* If this section is a link-once section that will be
12341                  discarded, then don't create any stubs.  */
12342               if (section->output_section == NULL
12343                   || section->output_section->owner != info->output_bfd)
12344                 continue;
12345
12346               /* Get the relocs.  */
12347               internal_relocs
12348                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
12349                                              info->keep_memory);
12350               if (internal_relocs == NULL)
12351                 goto error_ret_free_local;
12352
12353               /* Now examine each relocation.  */
12354               irela = internal_relocs;
12355               irelaend = irela + section->reloc_count;
12356               for (; irela < irelaend; irela++)
12357                 {
12358                   enum elf_ppc64_reloc_type r_type;
12359                   unsigned int r_indx;
12360                   enum ppc_stub_type stub_type;
12361                   struct ppc_stub_hash_entry *stub_entry;
12362                   asection *sym_sec, *code_sec;
12363                   bfd_vma sym_value, code_value;
12364                   bfd_vma destination;
12365                   unsigned long local_off;
12366                   bfd_boolean ok_dest;
12367                   struct ppc_link_hash_entry *hash;
12368                   struct ppc_link_hash_entry *fdh;
12369                   struct elf_link_hash_entry *h;
12370                   Elf_Internal_Sym *sym;
12371                   char *stub_name;
12372                   const asection *id_sec;
12373                   struct _opd_sec_data *opd;
12374                   struct plt_entry *plt_ent;
12375
12376                   r_type = ELF64_R_TYPE (irela->r_info);
12377                   r_indx = ELF64_R_SYM (irela->r_info);
12378
12379                   if (r_type >= R_PPC64_max)
12380                     {
12381                       bfd_set_error (bfd_error_bad_value);
12382                       goto error_ret_free_internal;
12383                     }
12384
12385                   /* Only look for stubs on branch instructions.  */
12386                   if (r_type != R_PPC64_REL24
12387                       && r_type != R_PPC64_REL14
12388                       && r_type != R_PPC64_REL14_BRTAKEN
12389                       && r_type != R_PPC64_REL14_BRNTAKEN)
12390                     continue;
12391
12392                   /* Now determine the call target, its name, value,
12393                      section.  */
12394                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12395                                   r_indx, input_bfd))
12396                     goto error_ret_free_internal;
12397                   hash = (struct ppc_link_hash_entry *) h;
12398
12399                   ok_dest = FALSE;
12400                   fdh = NULL;
12401                   sym_value = 0;
12402                   if (hash == NULL)
12403                     {
12404                       sym_value = sym->st_value;
12405                       if (sym_sec != NULL
12406                           && sym_sec->output_section != NULL)
12407                         ok_dest = TRUE;
12408                     }
12409                   else if (hash->elf.root.type == bfd_link_hash_defined
12410                            || hash->elf.root.type == bfd_link_hash_defweak)
12411                     {
12412                       sym_value = hash->elf.root.u.def.value;
12413                       if (sym_sec->output_section != NULL)
12414                         ok_dest = TRUE;
12415                     }
12416                   else if (hash->elf.root.type == bfd_link_hash_undefweak
12417                            || hash->elf.root.type == bfd_link_hash_undefined)
12418                     {
12419                       /* Recognise an old ABI func code entry sym, and
12420                          use the func descriptor sym instead if it is
12421                          defined.  */
12422                       if (hash->elf.root.root.string[0] == '.'
12423                           && (fdh = lookup_fdh (hash, htab)) != NULL)
12424                         {
12425                           if (fdh->elf.root.type == bfd_link_hash_defined
12426                               || fdh->elf.root.type == bfd_link_hash_defweak)
12427                             {
12428                               sym_sec = fdh->elf.root.u.def.section;
12429                               sym_value = fdh->elf.root.u.def.value;
12430                               if (sym_sec->output_section != NULL)
12431                                 ok_dest = TRUE;
12432                             }
12433                           else
12434                             fdh = NULL;
12435                         }
12436                     }
12437                   else
12438                     {
12439                       bfd_set_error (bfd_error_bad_value);
12440                       goto error_ret_free_internal;
12441                     }
12442
12443                   destination = 0;
12444                   local_off = 0;
12445                   if (ok_dest)
12446                     {
12447                       sym_value += irela->r_addend;
12448                       destination = (sym_value
12449                                      + sym_sec->output_offset
12450                                      + sym_sec->output_section->vma);
12451                       local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12452                                                             ? hash->elf.other
12453                                                             : sym->st_other);
12454                     }
12455
12456                   code_sec = sym_sec;
12457                   code_value = sym_value;
12458                   opd = get_opd_info (sym_sec);
12459                   if (opd != NULL)
12460                     {
12461                       bfd_vma dest;
12462
12463                       if (hash == NULL && opd->adjust != NULL)
12464                         {
12465                           long adjust = opd->adjust[OPD_NDX (sym_value)];
12466                           if (adjust == -1)
12467                             continue;
12468                           code_value += adjust;
12469                           sym_value += adjust;
12470                         }
12471                       dest = opd_entry_value (sym_sec, sym_value,
12472                                               &code_sec, &code_value, FALSE);
12473                       if (dest != (bfd_vma) -1)
12474                         {
12475                           destination = dest;
12476                           if (fdh != NULL)
12477                             {
12478                               /* Fixup old ABI sym to point at code
12479                                  entry.  */
12480                               hash->elf.root.type = bfd_link_hash_defweak;
12481                               hash->elf.root.u.def.section = code_sec;
12482                               hash->elf.root.u.def.value = code_value;
12483                             }
12484                         }
12485                     }
12486
12487                   /* Determine what (if any) linker stub is needed.  */
12488                   plt_ent = NULL;
12489                   stub_type = ppc_type_of_stub (section, irela, &hash,
12490                                                 &plt_ent, destination,
12491                                                 local_off);
12492
12493                   if (stub_type != ppc_stub_plt_call)
12494                     {
12495                       /* Check whether we need a TOC adjusting stub.
12496                          Since the linker pastes together pieces from
12497                          different object files when creating the
12498                          _init and _fini functions, it may be that a
12499                          call to what looks like a local sym is in
12500                          fact a call needing a TOC adjustment.  */
12501                       if (code_sec != NULL
12502                           && code_sec->output_section != NULL
12503                           && (htab->sec_info[code_sec->id].toc_off
12504                               != htab->sec_info[section->id].toc_off)
12505                           && (code_sec->has_toc_reloc
12506                               || code_sec->makes_toc_func_call))
12507                         stub_type = ppc_stub_long_branch_r2off;
12508                     }
12509
12510                   if (stub_type == ppc_stub_none)
12511                     continue;
12512
12513                   /* __tls_get_addr calls might be eliminated.  */
12514                   if (stub_type != ppc_stub_plt_call
12515                       && hash != NULL
12516                       && (hash == htab->tls_get_addr
12517                           || hash == htab->tls_get_addr_fd)
12518                       && section->has_tls_reloc
12519                       && irela != internal_relocs)
12520                     {
12521                       /* Get tls info.  */
12522                       unsigned char *tls_mask;
12523
12524                       if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12525                                          irela - 1, input_bfd))
12526                         goto error_ret_free_internal;
12527                       if (*tls_mask != 0)
12528                         continue;
12529                     }
12530
12531                   if (stub_type == ppc_stub_plt_call
12532                       && irela + 1 < irelaend
12533                       && irela[1].r_offset == irela->r_offset + 4
12534                       && ELF64_R_TYPE (irela[1].r_info) == R_PPC64_TOCSAVE)
12535                     {
12536                       if (!tocsave_find (htab, INSERT,
12537                                          &local_syms, irela + 1, input_bfd))
12538                         goto error_ret_free_internal;
12539                     }
12540                   else if (stub_type == ppc_stub_plt_call)
12541                     stub_type = ppc_stub_plt_call_r2save;
12542
12543                   /* Support for grouping stub sections.  */
12544                   id_sec = htab->sec_info[section->id].u.group->link_sec;
12545
12546                   /* Get the name of this stub.  */
12547                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12548                   if (!stub_name)
12549                     goto error_ret_free_internal;
12550
12551                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12552                                                      stub_name, FALSE, FALSE);
12553                   if (stub_entry != NULL)
12554                     {
12555                       /* The proper stub has already been created.  */
12556                       free (stub_name);
12557                       if (stub_type == ppc_stub_plt_call_r2save)
12558                         stub_entry->stub_type = stub_type;
12559                       continue;
12560                     }
12561
12562                   stub_entry = ppc_add_stub (stub_name, section, info);
12563                   if (stub_entry == NULL)
12564                     {
12565                       free (stub_name);
12566                     error_ret_free_internal:
12567                       if (elf_section_data (section)->relocs == NULL)
12568                         free (internal_relocs);
12569                     error_ret_free_local:
12570                       if (local_syms != NULL
12571                           && (symtab_hdr->contents
12572                               != (unsigned char *) local_syms))
12573                         free (local_syms);
12574                       return FALSE;
12575                     }
12576
12577                   stub_entry->stub_type = stub_type;
12578                   if (stub_type != ppc_stub_plt_call
12579                       && stub_type != ppc_stub_plt_call_r2save)
12580                     {
12581                       stub_entry->target_value = code_value;
12582                       stub_entry->target_section = code_sec;
12583                     }
12584                   else
12585                     {
12586                       stub_entry->target_value = sym_value;
12587                       stub_entry->target_section = sym_sec;
12588                     }
12589                   stub_entry->h = hash;
12590                   stub_entry->plt_ent = plt_ent;
12591                   stub_entry->other = hash ? hash->elf.other : sym->st_other;
12592
12593                   if (stub_entry->h != NULL)
12594                     htab->stub_globals += 1;
12595                 }
12596
12597               /* We're done with the internal relocs, free them.  */
12598               if (elf_section_data (section)->relocs != internal_relocs)
12599                 free (internal_relocs);
12600             }
12601
12602           if (local_syms != NULL
12603               && symtab_hdr->contents != (unsigned char *) local_syms)
12604             {
12605               if (!info->keep_memory)
12606                 free (local_syms);
12607               else
12608                 symtab_hdr->contents = (unsigned char *) local_syms;
12609             }
12610         }
12611
12612       /* We may have added some stubs.  Find out the new size of the
12613          stub sections.  */
12614       for (stub_sec = htab->params->stub_bfd->sections;
12615            stub_sec != NULL;
12616            stub_sec = stub_sec->next)
12617         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12618           {
12619             stub_sec->rawsize = stub_sec->size;
12620             stub_sec->size = 0;
12621             stub_sec->reloc_count = 0;
12622             stub_sec->flags &= ~SEC_RELOC;
12623           }
12624
12625       htab->brlt->size = 0;
12626       htab->brlt->reloc_count = 0;
12627       htab->brlt->flags &= ~SEC_RELOC;
12628       if (htab->relbrlt != NULL)
12629         htab->relbrlt->size = 0;
12630
12631       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12632
12633       for (group = htab->group; group != NULL; group = group->next)
12634         if (group->needs_save_res)
12635           group->stub_sec->size += htab->sfpr->size;
12636
12637       if (info->emitrelocations
12638           && htab->glink != NULL && htab->glink->size != 0)
12639         {
12640           htab->glink->reloc_count = 1;
12641           htab->glink->flags |= SEC_RELOC;
12642         }
12643
12644       if (htab->glink_eh_frame != NULL
12645           && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12646           && htab->glink_eh_frame->output_section->size != 0)
12647         {
12648           size_t size = 0, align;
12649
12650           for (stub_sec = htab->params->stub_bfd->sections;
12651                stub_sec != NULL;
12652                stub_sec = stub_sec->next)
12653             if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12654               size += 24;
12655           if (htab->glink != NULL && htab->glink->size != 0)
12656             size += 24;
12657           if (size != 0)
12658             size += sizeof (glink_eh_frame_cie);
12659           align = 1;
12660           align <<= htab->glink_eh_frame->output_section->alignment_power;
12661           align -= 1;
12662           size = (size + align) & ~align;
12663           htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12664           htab->glink_eh_frame->size = size;
12665         }
12666
12667       if (htab->params->plt_stub_align != 0)
12668         for (stub_sec = htab->params->stub_bfd->sections;
12669              stub_sec != NULL;
12670              stub_sec = stub_sec->next)
12671           if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12672             stub_sec->size = ((stub_sec->size
12673                                + (1 << htab->params->plt_stub_align) - 1)
12674                               & -(1 << htab->params->plt_stub_align));
12675
12676       for (stub_sec = htab->params->stub_bfd->sections;
12677            stub_sec != NULL;
12678            stub_sec = stub_sec->next)
12679         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12680             && stub_sec->rawsize != stub_sec->size
12681             && (htab->stub_iteration <= STUB_SHRINK_ITER
12682                 || stub_sec->rawsize < stub_sec->size))
12683           break;
12684
12685       if (stub_sec == NULL
12686           && (htab->glink_eh_frame == NULL
12687               || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12688         break;
12689
12690       /* Ask the linker to do its stuff.  */
12691       (*htab->params->layout_sections_again) ();
12692     }
12693
12694   if (htab->glink_eh_frame != NULL
12695       && htab->glink_eh_frame->size != 0)
12696     {
12697       bfd_vma val;
12698       bfd_byte *p, *last_fde;
12699       size_t last_fde_len, size, align, pad;
12700       asection *stub_sec;
12701
12702       p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12703       if (p == NULL)
12704         return FALSE;
12705       htab->glink_eh_frame->contents = p;
12706       last_fde = p;
12707
12708       memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12709       /* CIE length (rewrite in case little-endian).  */
12710       last_fde_len = sizeof (glink_eh_frame_cie) - 4;
12711       bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12712       p += sizeof (glink_eh_frame_cie);
12713
12714       for (stub_sec = htab->params->stub_bfd->sections;
12715            stub_sec != NULL;
12716            stub_sec = stub_sec->next)
12717         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12718           {
12719             last_fde = p;
12720             last_fde_len = 20;
12721             /* FDE length.  */
12722             bfd_put_32 (htab->elf.dynobj, 20, p);
12723             p += 4;
12724             /* CIE pointer.  */
12725             val = p - htab->glink_eh_frame->contents;
12726             bfd_put_32 (htab->elf.dynobj, val, p);
12727             p += 4;
12728             /* Offset to stub section, written later.  */
12729             p += 4;
12730             /* stub section size.  */
12731             bfd_put_32 (htab->elf.dynobj, stub_sec->size, p);
12732             p += 4;
12733             /* Augmentation.  */
12734             p += 1;
12735             /* Pad.  */
12736             p += 7;
12737           }
12738       if (htab->glink != NULL && htab->glink->size != 0)
12739         {
12740           last_fde = p;
12741           last_fde_len = 20;
12742           /* FDE length.  */
12743           bfd_put_32 (htab->elf.dynobj, 20, p);
12744           p += 4;
12745           /* CIE pointer.  */
12746           val = p - htab->glink_eh_frame->contents;
12747           bfd_put_32 (htab->elf.dynobj, val, p);
12748           p += 4;
12749           /* Offset to .glink, written later.  */
12750           p += 4;
12751           /* .glink size.  */
12752           bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12753           p += 4;
12754           /* Augmentation.  */
12755           p += 1;
12756
12757           *p++ = DW_CFA_advance_loc + 1;
12758           *p++ = DW_CFA_register;
12759           *p++ = 65;
12760           *p++ = htab->opd_abi ? 12 : 0;
12761           *p++ = DW_CFA_advance_loc + 4;
12762           *p++ = DW_CFA_restore_extended;
12763           *p++ = 65;
12764         }
12765       /* Subsume any padding into the last FDE if user .eh_frame
12766          sections are aligned more than glink_eh_frame.  Otherwise any
12767          zero padding will be seen as a terminator.  */
12768       size = p - htab->glink_eh_frame->contents;
12769       align = 1;
12770       align <<= htab->glink_eh_frame->output_section->alignment_power;
12771       align -= 1;
12772       pad = ((size + align) & ~align) - size;
12773       htab->glink_eh_frame->size = size + pad;
12774       bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12775     }
12776
12777   maybe_strip_output (info, htab->brlt);
12778   if (htab->glink_eh_frame != NULL)
12779     maybe_strip_output (info, htab->glink_eh_frame);
12780
12781   return TRUE;
12782 }
12783
12784 /* Called after we have determined section placement.  If sections
12785    move, we'll be called again.  Provide a value for TOCstart.  */
12786
12787 bfd_vma
12788 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12789 {
12790   asection *s;
12791   bfd_vma TOCstart, adjust;
12792
12793   if (info != NULL)
12794     {
12795       struct elf_link_hash_entry *h;
12796       struct elf_link_hash_table *htab = elf_hash_table (info);
12797
12798       if (is_elf_hash_table (htab)
12799           && htab->hgot != NULL)
12800         h = htab->hgot;
12801       else
12802         {
12803           h = elf_link_hash_lookup (htab, ".TOC.", FALSE, FALSE, TRUE);
12804           if (is_elf_hash_table (htab))
12805             htab->hgot = h;
12806         }
12807       if (h != NULL
12808           && h->root.type == bfd_link_hash_defined
12809           && !h->root.linker_def
12810           && (!is_elf_hash_table (htab)
12811               || h->def_regular))
12812         {
12813           TOCstart = (h->root.u.def.value - TOC_BASE_OFF
12814                       + h->root.u.def.section->output_offset
12815                       + h->root.u.def.section->output_section->vma);
12816           _bfd_set_gp_value (obfd, TOCstart);
12817           return TOCstart;
12818         }
12819     }
12820
12821   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12822      order.  The TOC starts where the first of these sections starts.  */
12823   s = bfd_get_section_by_name (obfd, ".got");
12824   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12825     s = bfd_get_section_by_name (obfd, ".toc");
12826   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12827     s = bfd_get_section_by_name (obfd, ".tocbss");
12828   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12829     s = bfd_get_section_by_name (obfd, ".plt");
12830   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12831     {
12832       /* This may happen for
12833          o  references to TOC base (SYM@toc / TOC[tc0]) without a
12834          .toc directive
12835          o  bad linker script
12836          o --gc-sections and empty TOC sections
12837
12838          FIXME: Warn user?  */
12839
12840       /* Look for a likely section.  We probably won't even be
12841          using TOCstart.  */
12842       for (s = obfd->sections; s != NULL; s = s->next)
12843         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
12844                          | SEC_EXCLUDE))
12845             == (SEC_ALLOC | SEC_SMALL_DATA))
12846           break;
12847       if (s == NULL)
12848         for (s = obfd->sections; s != NULL; s = s->next)
12849           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
12850               == (SEC_ALLOC | SEC_SMALL_DATA))
12851             break;
12852       if (s == NULL)
12853         for (s = obfd->sections; s != NULL; s = s->next)
12854           if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
12855               == SEC_ALLOC)
12856             break;
12857       if (s == NULL)
12858         for (s = obfd->sections; s != NULL; s = s->next)
12859           if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
12860             break;
12861     }
12862
12863   TOCstart = 0;
12864   if (s != NULL)
12865     TOCstart = s->output_section->vma + s->output_offset;
12866
12867   /* Force alignment.  */
12868   adjust = TOCstart & (TOC_BASE_ALIGN - 1);
12869   TOCstart -= adjust;
12870   _bfd_set_gp_value (obfd, TOCstart);
12871
12872   if (info != NULL && s != NULL)
12873     {
12874       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12875
12876       if (htab != NULL)
12877         {
12878           if (htab->elf.hgot != NULL)
12879             {
12880               htab->elf.hgot->root.u.def.value = TOC_BASE_OFF - adjust;
12881               htab->elf.hgot->root.u.def.section = s;
12882             }
12883         }
12884       else
12885         {
12886           struct bfd_link_hash_entry *bh = NULL;
12887           _bfd_generic_link_add_one_symbol (info, obfd, ".TOC.", BSF_GLOBAL,
12888                                             s, TOC_BASE_OFF - adjust,
12889                                             NULL, FALSE, FALSE, &bh);
12890         }
12891     }
12892   return TOCstart;
12893 }
12894
12895 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
12896    write out any global entry stubs.  */
12897
12898 static bfd_boolean
12899 build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
12900 {
12901   struct bfd_link_info *info;
12902   struct ppc_link_hash_table *htab;
12903   struct plt_entry *pent;
12904   asection *s;
12905
12906   if (h->root.type == bfd_link_hash_indirect)
12907     return TRUE;
12908
12909   if (!h->pointer_equality_needed)
12910     return TRUE;
12911
12912   if (h->def_regular)
12913     return TRUE;
12914
12915   info = inf;
12916   htab = ppc_hash_table (info);
12917   if (htab == NULL)
12918     return FALSE;
12919
12920   s = htab->glink;
12921   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
12922     if (pent->plt.offset != (bfd_vma) -1
12923         && pent->addend == 0)
12924       {
12925         bfd_byte *p;
12926         asection *plt;
12927         bfd_vma off;
12928
12929         p = s->contents + h->root.u.def.value;
12930         plt = htab->elf.splt;
12931         if (!htab->elf.dynamic_sections_created
12932             || h->dynindx == -1)
12933           plt = htab->elf.iplt;
12934         off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
12935         off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
12936
12937         if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
12938           {
12939             info->callbacks->einfo
12940               (_("%P: linkage table error against `%T'\n"),
12941                h->root.root.string);
12942             bfd_set_error (bfd_error_bad_value);
12943             htab->stub_error = TRUE;
12944           }
12945
12946         htab->stub_count[ppc_stub_global_entry - 1] += 1;
12947         if (htab->params->emit_stub_syms)
12948           {
12949             size_t len = strlen (h->root.root.string);
12950             char *name = bfd_malloc (sizeof "12345678.global_entry." + len);
12951
12952             if (name == NULL)
12953               return FALSE;
12954
12955             sprintf (name, "%08x.global_entry.%s", s->id, h->root.root.string);
12956             h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
12957             if (h == NULL)
12958               return FALSE;
12959             if (h->root.type == bfd_link_hash_new)
12960               {
12961                 h->root.type = bfd_link_hash_defined;
12962                 h->root.u.def.section = s;
12963                 h->root.u.def.value = p - s->contents;
12964                 h->ref_regular = 1;
12965                 h->def_regular = 1;
12966                 h->ref_regular_nonweak = 1;
12967                 h->forced_local = 1;
12968                 h->non_elf = 0;
12969                 h->root.linker_def = 1;
12970               }
12971           }
12972
12973         if (PPC_HA (off) != 0)
12974           {
12975             bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
12976             p += 4;
12977           }
12978         bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
12979         p += 4;
12980         bfd_put_32 (s->owner, MTCTR_R12, p);
12981         p += 4;
12982         bfd_put_32 (s->owner, BCTR, p);
12983         break;
12984       }
12985   return TRUE;
12986 }
12987
12988 /* Build all the stubs associated with the current output file.
12989    The stubs are kept in a hash table attached to the main linker
12990    hash table.  This function is called via gldelf64ppc_finish.  */
12991
12992 bfd_boolean
12993 ppc64_elf_build_stubs (struct bfd_link_info *info,
12994                        char **stats)
12995 {
12996   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12997   struct map_stub *group;
12998   asection *stub_sec;
12999   bfd_byte *p;
13000   int stub_sec_count = 0;
13001
13002   if (htab == NULL)
13003     return FALSE;
13004
13005   /* Allocate memory to hold the linker stubs.  */
13006   for (stub_sec = htab->params->stub_bfd->sections;
13007        stub_sec != NULL;
13008        stub_sec = stub_sec->next)
13009     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
13010         && stub_sec->size != 0)
13011       {
13012         stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
13013         if (stub_sec->contents == NULL)
13014           return FALSE;
13015         stub_sec->size = 0;
13016       }
13017
13018   if (htab->glink != NULL && htab->glink->size != 0)
13019     {
13020       unsigned int indx;
13021       bfd_vma plt0;
13022
13023       /* Build the .glink plt call stub.  */
13024       if (htab->params->emit_stub_syms)
13025         {
13026           struct elf_link_hash_entry *h;
13027           h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
13028                                     TRUE, FALSE, FALSE);
13029           if (h == NULL)
13030             return FALSE;
13031           if (h->root.type == bfd_link_hash_new)
13032             {
13033               h->root.type = bfd_link_hash_defined;
13034               h->root.u.def.section = htab->glink;
13035               h->root.u.def.value = 8;
13036               h->ref_regular = 1;
13037               h->def_regular = 1;
13038               h->ref_regular_nonweak = 1;
13039               h->forced_local = 1;
13040               h->non_elf = 0;
13041               h->root.linker_def = 1;
13042             }
13043         }
13044       plt0 = (htab->elf.splt->output_section->vma
13045               + htab->elf.splt->output_offset
13046               - 16);
13047       if (info->emitrelocations)
13048         {
13049           Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
13050           if (r == NULL)
13051             return FALSE;
13052           r->r_offset = (htab->glink->output_offset
13053                          + htab->glink->output_section->vma);
13054           r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
13055           r->r_addend = plt0;
13056         }
13057       p = htab->glink->contents;
13058       plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
13059       bfd_put_64 (htab->glink->owner, plt0, p);
13060       p += 8;
13061       if (htab->opd_abi)
13062         {
13063           bfd_put_32 (htab->glink->owner, MFLR_R12, p);
13064           p += 4;
13065           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13066           p += 4;
13067           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13068           p += 4;
13069           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13070           p += 4;
13071           bfd_put_32 (htab->glink->owner, MTLR_R12, p);
13072           p += 4;
13073           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13074           p += 4;
13075           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13076           p += 4;
13077           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
13078           p += 4;
13079           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13080           p += 4;
13081           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
13082           p += 4;
13083         }
13084       else
13085         {
13086           bfd_put_32 (htab->glink->owner, MFLR_R0, p);
13087           p += 4;
13088           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13089           p += 4;
13090           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13091           p += 4;
13092           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13093           p += 4;
13094           bfd_put_32 (htab->glink->owner, MTLR_R0, p);
13095           p += 4;
13096           bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
13097           p += 4;
13098           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13099           p += 4;
13100           bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
13101           p += 4;
13102           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13103           p += 4;
13104           bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
13105           p += 4;
13106           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13107           p += 4;
13108           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
13109           p += 4;
13110         }
13111       bfd_put_32 (htab->glink->owner, BCTR, p);
13112       p += 4;
13113       while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
13114         {
13115           bfd_put_32 (htab->glink->owner, NOP, p);
13116           p += 4;
13117         }
13118
13119       /* Build the .glink lazy link call stubs.  */
13120       indx = 0;
13121       while (p < htab->glink->contents + htab->glink->rawsize)
13122         {
13123           if (htab->opd_abi)
13124             {
13125               if (indx < 0x8000)
13126                 {
13127                   bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
13128                   p += 4;
13129                 }
13130               else
13131                 {
13132                   bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
13133                   p += 4;
13134                   bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
13135                               p);
13136                   p += 4;
13137                 }
13138             }
13139           bfd_put_32 (htab->glink->owner,
13140                       B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
13141           indx++;
13142           p += 4;
13143         }
13144
13145       /* Build .glink global entry stubs.  */
13146       if (htab->glink->size > htab->glink->rawsize)
13147         elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
13148     }
13149
13150   if (htab->brlt != NULL && htab->brlt->size != 0)
13151     {
13152       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
13153                                          htab->brlt->size);
13154       if (htab->brlt->contents == NULL)
13155         return FALSE;
13156     }
13157   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
13158     {
13159       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
13160                                             htab->relbrlt->size);
13161       if (htab->relbrlt->contents == NULL)
13162         return FALSE;
13163     }
13164
13165   /* Build the stubs as directed by the stub hash table.  */
13166   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
13167
13168   for (group = htab->group; group != NULL; group = group->next)
13169     if (group->needs_save_res)
13170       {
13171         stub_sec = group->stub_sec;
13172         memcpy (stub_sec->contents + stub_sec->size, htab->sfpr->contents,
13173                 htab->sfpr->size);
13174         if (htab->params->emit_stub_syms)
13175           {
13176             unsigned int i;
13177
13178             for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
13179               if (!sfpr_define (info, &save_res_funcs[i], stub_sec))
13180                 return FALSE;
13181           }
13182         stub_sec->size += htab->sfpr->size;
13183       }
13184
13185   if (htab->relbrlt != NULL)
13186     htab->relbrlt->reloc_count = 0;
13187
13188   if (htab->params->plt_stub_align != 0)
13189     for (stub_sec = htab->params->stub_bfd->sections;
13190          stub_sec != NULL;
13191          stub_sec = stub_sec->next)
13192       if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
13193         stub_sec->size = ((stub_sec->size
13194                            + (1 << htab->params->plt_stub_align) - 1)
13195                           & -(1 << htab->params->plt_stub_align));
13196
13197   for (stub_sec = htab->params->stub_bfd->sections;
13198        stub_sec != NULL;
13199        stub_sec = stub_sec->next)
13200     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
13201       {
13202         stub_sec_count += 1;
13203         if (stub_sec->rawsize != stub_sec->size
13204             && (htab->stub_iteration <= STUB_SHRINK_ITER
13205                 || stub_sec->rawsize < stub_sec->size))
13206           break;
13207       }
13208
13209   /* Note that the glink_eh_frame check here is not only testing that
13210      the generated size matched the calculated size but also that
13211      bfd_elf_discard_info didn't make any changes to the section.  */
13212   if (stub_sec != NULL
13213       || (htab->glink_eh_frame != NULL
13214           && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
13215     {
13216       htab->stub_error = TRUE;
13217       info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
13218     }
13219
13220   if (htab->stub_error)
13221     return FALSE;
13222
13223   if (stats != NULL)
13224     {
13225       *stats = bfd_malloc (500);
13226       if (*stats == NULL)
13227         return FALSE;
13228
13229       sprintf (*stats, _("linker stubs in %u group%s\n"
13230                          "  branch       %lu\n"
13231                          "  toc adjust   %lu\n"
13232                          "  long branch  %lu\n"
13233                          "  long toc adj %lu\n"
13234                          "  plt call     %lu\n"
13235                          "  plt call toc %lu\n"
13236                          "  global entry %lu"),
13237                stub_sec_count,
13238                stub_sec_count == 1 ? "" : "s",
13239                htab->stub_count[ppc_stub_long_branch - 1],
13240                htab->stub_count[ppc_stub_long_branch_r2off - 1],
13241                htab->stub_count[ppc_stub_plt_branch - 1],
13242                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
13243                htab->stub_count[ppc_stub_plt_call - 1],
13244                htab->stub_count[ppc_stub_plt_call_r2save - 1],
13245                htab->stub_count[ppc_stub_global_entry - 1]);
13246     }
13247   return TRUE;
13248 }
13249
13250 /* This function undoes the changes made by add_symbol_adjust.  */
13251
13252 static bfd_boolean
13253 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
13254 {
13255   struct ppc_link_hash_entry *eh;
13256
13257   if (h->root.type == bfd_link_hash_indirect)
13258     return TRUE;
13259
13260   eh = (struct ppc_link_hash_entry *) h;
13261   if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
13262     return TRUE;
13263
13264   eh->elf.root.type = bfd_link_hash_undefined;
13265   return TRUE;
13266 }
13267
13268 void
13269 ppc64_elf_restore_symbols (struct bfd_link_info *info)
13270 {
13271   struct ppc_link_hash_table *htab = ppc_hash_table (info);
13272
13273   if (htab != NULL)
13274     elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
13275 }
13276
13277 /* What to do when ld finds relocations against symbols defined in
13278    discarded sections.  */
13279
13280 static unsigned int
13281 ppc64_elf_action_discarded (asection *sec)
13282 {
13283   if (strcmp (".opd", sec->name) == 0)
13284     return 0;
13285
13286   if (strcmp (".toc", sec->name) == 0)
13287     return 0;
13288
13289   if (strcmp (".toc1", sec->name) == 0)
13290     return 0;
13291
13292   return _bfd_elf_default_action_discarded (sec);
13293 }
13294
13295 /* The RELOCATE_SECTION function is called by the ELF backend linker
13296    to handle the relocations for a section.
13297
13298    The relocs are always passed as Rela structures; if the section
13299    actually uses Rel structures, the r_addend field will always be
13300    zero.
13301
13302    This function is responsible for adjust the section contents as
13303    necessary, and (if using Rela relocs and generating a
13304    relocatable output file) adjusting the reloc addend as
13305    necessary.
13306
13307    This function does not have to worry about setting the reloc
13308    address or the reloc symbol index.
13309
13310    LOCAL_SYMS is a pointer to the swapped in local symbols.
13311
13312    LOCAL_SECTIONS is an array giving the section in the input file
13313    corresponding to the st_shndx field of each local symbol.
13314
13315    The global hash table entry for the global symbols can be found
13316    via elf_sym_hashes (input_bfd).
13317
13318    When generating relocatable output, this function must handle
13319    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
13320    going to be the section symbol corresponding to the output
13321    section, which means that the addend must be adjusted
13322    accordingly.  */
13323
13324 static bfd_boolean
13325 ppc64_elf_relocate_section (bfd *output_bfd,
13326                             struct bfd_link_info *info,
13327                             bfd *input_bfd,
13328                             asection *input_section,
13329                             bfd_byte *contents,
13330                             Elf_Internal_Rela *relocs,
13331                             Elf_Internal_Sym *local_syms,
13332                             asection **local_sections)
13333 {
13334   struct ppc_link_hash_table *htab;
13335   Elf_Internal_Shdr *symtab_hdr;
13336   struct elf_link_hash_entry **sym_hashes;
13337   Elf_Internal_Rela *rel;
13338   Elf_Internal_Rela *wrel;
13339   Elf_Internal_Rela *relend;
13340   Elf_Internal_Rela outrel;
13341   bfd_byte *loc;
13342   struct got_entry **local_got_ents;
13343   bfd_vma TOCstart;
13344   bfd_boolean ret = TRUE;
13345   bfd_boolean is_opd;
13346   /* Assume 'at' branch hints.  */
13347   bfd_boolean is_isa_v2 = TRUE;
13348   bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
13349
13350   /* Initialize howto table if needed.  */
13351   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
13352     ppc_howto_init ();
13353
13354   htab = ppc_hash_table (info);
13355   if (htab == NULL)
13356     return FALSE;
13357
13358   /* Don't relocate stub sections.  */
13359   if (input_section->owner == htab->params->stub_bfd)
13360     return TRUE;
13361
13362   BFD_ASSERT (is_ppc64_elf (input_bfd));
13363
13364   local_got_ents = elf_local_got_ents (input_bfd);
13365   TOCstart = elf_gp (output_bfd);
13366   symtab_hdr = &elf_symtab_hdr (input_bfd);
13367   sym_hashes = elf_sym_hashes (input_bfd);
13368   is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
13369
13370   rel = wrel = relocs;
13371   relend = relocs + input_section->reloc_count;
13372   for (; rel < relend; wrel++, rel++)
13373     {
13374       enum elf_ppc64_reloc_type r_type;
13375       bfd_vma addend;
13376       bfd_reloc_status_type r;
13377       Elf_Internal_Sym *sym;
13378       asection *sec;
13379       struct elf_link_hash_entry *h_elf;
13380       struct ppc_link_hash_entry *h;
13381       struct ppc_link_hash_entry *fdh;
13382       const char *sym_name;
13383       unsigned long r_symndx, toc_symndx;
13384       bfd_vma toc_addend;
13385       unsigned char tls_mask, tls_gd, tls_type;
13386       unsigned char sym_type;
13387       bfd_vma relocation;
13388       bfd_boolean unresolved_reloc;
13389       bfd_boolean warned;
13390       enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
13391       unsigned int insn;
13392       unsigned int mask;
13393       struct ppc_stub_hash_entry *stub_entry;
13394       bfd_vma max_br_offset;
13395       bfd_vma from;
13396       Elf_Internal_Rela orig_rel;
13397       reloc_howto_type *howto;
13398       struct reloc_howto_struct alt_howto;
13399
13400     again:
13401       orig_rel = *rel;
13402
13403       r_type = ELF64_R_TYPE (rel->r_info);
13404       r_symndx = ELF64_R_SYM (rel->r_info);
13405
13406       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
13407          symbol of the previous ADDR64 reloc.  The symbol gives us the
13408          proper TOC base to use.  */
13409       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
13410           && wrel != relocs
13411           && ELF64_R_TYPE (wrel[-1].r_info) == R_PPC64_ADDR64
13412           && is_opd)
13413         r_symndx = ELF64_R_SYM (wrel[-1].r_info);
13414
13415       sym = NULL;
13416       sec = NULL;
13417       h_elf = NULL;
13418       sym_name = NULL;
13419       unresolved_reloc = FALSE;
13420       warned = FALSE;
13421
13422       if (r_symndx < symtab_hdr->sh_info)
13423         {
13424           /* It's a local symbol.  */
13425           struct _opd_sec_data *opd;
13426
13427           sym = local_syms + r_symndx;
13428           sec = local_sections[r_symndx];
13429           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
13430           sym_type = ELF64_ST_TYPE (sym->st_info);
13431           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
13432           opd = get_opd_info (sec);
13433           if (opd != NULL && opd->adjust != NULL)
13434             {
13435               long adjust = opd->adjust[OPD_NDX (sym->st_value
13436                                                  + rel->r_addend)];
13437               if (adjust == -1)
13438                 relocation = 0;
13439               else
13440                 {
13441                   /* If this is a relocation against the opd section sym
13442                      and we have edited .opd, adjust the reloc addend so
13443                      that ld -r and ld --emit-relocs output is correct.
13444                      If it is a reloc against some other .opd symbol,
13445                      then the symbol value will be adjusted later.  */
13446                   if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
13447                     rel->r_addend += adjust;
13448                   else
13449                     relocation += adjust;
13450                 }
13451             }
13452         }
13453       else
13454         {
13455           bfd_boolean ignored;
13456
13457           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
13458                                    r_symndx, symtab_hdr, sym_hashes,
13459                                    h_elf, sec, relocation,
13460                                    unresolved_reloc, warned, ignored);
13461           sym_name = h_elf->root.root.string;
13462           sym_type = h_elf->type;
13463           if (sec != NULL
13464               && sec->owner == output_bfd
13465               && strcmp (sec->name, ".opd") == 0)
13466             {
13467               /* This is a symbol defined in a linker script.  All
13468                  such are defined in output sections, even those
13469                  defined by simple assignment from a symbol defined in
13470                  an input section.  Transfer the symbol to an
13471                  appropriate input .opd section, so that a branch to
13472                  this symbol will be mapped to the location specified
13473                  by the opd entry.  */
13474               struct bfd_link_order *lo;
13475               for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
13476                 if (lo->type == bfd_indirect_link_order)
13477                   {
13478                     asection *isec = lo->u.indirect.section;
13479                     if (h_elf->root.u.def.value >= isec->output_offset
13480                         && h_elf->root.u.def.value < (isec->output_offset
13481                                                       + isec->size))
13482                       {
13483                         h_elf->root.u.def.value -= isec->output_offset;
13484                         h_elf->root.u.def.section = isec;
13485                         sec = isec;
13486                         break;
13487                       }
13488                   }
13489             }
13490         }
13491       h = (struct ppc_link_hash_entry *) h_elf;
13492
13493       if (sec != NULL && discarded_section (sec))
13494         {
13495           _bfd_clear_contents (ppc64_elf_howto_table[r_type],
13496                                input_bfd, input_section,
13497                                contents + rel->r_offset);
13498           wrel->r_offset = rel->r_offset;
13499           wrel->r_info = 0;
13500           wrel->r_addend = 0;
13501
13502           /* For ld -r, remove relocations in debug sections against
13503              sections defined in discarded sections.  Not done for
13504              non-debug to preserve relocs in .eh_frame which the
13505              eh_frame editing code expects to be present.  */
13506           if (bfd_link_relocatable (info)
13507               && (input_section->flags & SEC_DEBUGGING))
13508             wrel--;
13509
13510           continue;
13511         }
13512
13513       if (bfd_link_relocatable (info))
13514         goto copy_reloc;
13515
13516       if (h != NULL && &h->elf == htab->elf.hgot)
13517         {
13518           relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
13519           sec = bfd_abs_section_ptr;
13520           unresolved_reloc = FALSE;
13521         }
13522
13523       /* TLS optimizations.  Replace instruction sequences and relocs
13524          based on information we collected in tls_optimize.  We edit
13525          RELOCS so that --emit-relocs will output something sensible
13526          for the final instruction stream.  */
13527       tls_mask = 0;
13528       tls_gd = 0;
13529       toc_symndx = 0;
13530       if (h != NULL)
13531         tls_mask = h->tls_mask;
13532       else if (local_got_ents != NULL)
13533         {
13534           struct plt_entry **local_plt = (struct plt_entry **)
13535             (local_got_ents + symtab_hdr->sh_info);
13536           unsigned char *lgot_masks = (unsigned char *)
13537             (local_plt + symtab_hdr->sh_info);
13538           tls_mask = lgot_masks[r_symndx];
13539         }
13540       if (tls_mask == 0
13541           && (r_type == R_PPC64_TLS
13542               || r_type == R_PPC64_TLSGD
13543               || r_type == R_PPC64_TLSLD))
13544         {
13545           /* Check for toc tls entries.  */
13546           unsigned char *toc_tls;
13547
13548           if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13549                              &local_syms, rel, input_bfd))
13550             return FALSE;
13551
13552           if (toc_tls)
13553             tls_mask = *toc_tls;
13554         }
13555
13556       /* Check that tls relocs are used with tls syms, and non-tls
13557          relocs are used with non-tls syms.  */
13558       if (r_symndx != STN_UNDEF
13559           && r_type != R_PPC64_NONE
13560           && (h == NULL
13561               || h->elf.root.type == bfd_link_hash_defined
13562               || h->elf.root.type == bfd_link_hash_defweak)
13563           && (IS_PPC64_TLS_RELOC (r_type)
13564               != (sym_type == STT_TLS
13565                   || (sym_type == STT_SECTION
13566                       && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13567         {
13568           if (tls_mask != 0
13569               && (r_type == R_PPC64_TLS
13570                   || r_type == R_PPC64_TLSGD
13571                   || r_type == R_PPC64_TLSLD))
13572             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
13573             ;
13574           else
13575             info->callbacks->einfo
13576               (!IS_PPC64_TLS_RELOC (r_type)
13577                /* xgettext:c-format */
13578                ? _("%P: %H: %s used with TLS symbol `%T'\n")
13579                /* xgettext:c-format */
13580                : _("%P: %H: %s used with non-TLS symbol `%T'\n"),
13581                input_bfd, input_section, rel->r_offset,
13582                ppc64_elf_howto_table[r_type]->name,
13583                sym_name);
13584         }
13585
13586       /* Ensure reloc mapping code below stays sane.  */
13587       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13588           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13589           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
13590           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13591           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13592           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13593           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
13594           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13595           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13596           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13597         abort ();
13598
13599       switch (r_type)
13600         {
13601         default:
13602           break;
13603
13604         case R_PPC64_LO_DS_OPT:
13605           insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13606           if ((insn & (0x3f << 26)) != 58u << 26)
13607             abort ();
13608           insn += (14u << 26) - (58u << 26);
13609           bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13610           r_type = R_PPC64_TOC16_LO;
13611           rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13612           break;
13613
13614         case R_PPC64_TOC16:
13615         case R_PPC64_TOC16_LO:
13616         case R_PPC64_TOC16_DS:
13617         case R_PPC64_TOC16_LO_DS:
13618           {
13619             /* Check for toc tls entries.  */
13620             unsigned char *toc_tls;
13621             int retval;
13622
13623             retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13624                                    &local_syms, rel, input_bfd);
13625             if (retval == 0)
13626               return FALSE;
13627
13628             if (toc_tls)
13629               {
13630                 tls_mask = *toc_tls;
13631                 if (r_type == R_PPC64_TOC16_DS
13632                     || r_type == R_PPC64_TOC16_LO_DS)
13633                   {
13634                     if (tls_mask != 0
13635                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13636                       goto toctprel;
13637                   }
13638                 else
13639                   {
13640                     /* If we found a GD reloc pair, then we might be
13641                        doing a GD->IE transition.  */
13642                     if (retval == 2)
13643                       {
13644                         tls_gd = TLS_TPRELGD;
13645                         if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13646                           goto tls_ldgd_opt;
13647                       }
13648                     else if (retval == 3)
13649                       {
13650                         if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13651                           goto tls_ldgd_opt;
13652                       }
13653                   }
13654               }
13655           }
13656           break;
13657
13658         case R_PPC64_GOT_TPREL16_HI:
13659         case R_PPC64_GOT_TPREL16_HA:
13660           if (tls_mask != 0
13661               && (tls_mask & TLS_TPREL) == 0)
13662             {
13663               rel->r_offset -= d_offset;
13664               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13665               r_type = R_PPC64_NONE;
13666               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13667             }
13668           break;
13669
13670         case R_PPC64_GOT_TPREL16_DS:
13671         case R_PPC64_GOT_TPREL16_LO_DS:
13672           if (tls_mask != 0
13673               && (tls_mask & TLS_TPREL) == 0)
13674             {
13675             toctprel:
13676               insn = bfd_get_32 (output_bfd,
13677                                  contents + rel->r_offset - d_offset);
13678               insn &= 31 << 21;
13679               insn |= 0x3c0d0000;       /* addis 0,13,0 */
13680               bfd_put_32 (output_bfd, insn,
13681                           contents + rel->r_offset - d_offset);
13682               r_type = R_PPC64_TPREL16_HA;
13683               if (toc_symndx != 0)
13684                 {
13685                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13686                   rel->r_addend = toc_addend;
13687                   /* We changed the symbol.  Start over in order to
13688                      get h, sym, sec etc. right.  */
13689                   goto again;
13690                 }
13691               else
13692                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13693             }
13694           break;
13695
13696         case R_PPC64_TLS:
13697           if (tls_mask != 0
13698               && (tls_mask & TLS_TPREL) == 0)
13699             {
13700               insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
13701               insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13702               if (insn == 0)
13703                 abort ();
13704               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13705               /* Was PPC64_TLS which sits on insn boundary, now
13706                  PPC64_TPREL16_LO which is at low-order half-word.  */
13707               rel->r_offset += d_offset;
13708               r_type = R_PPC64_TPREL16_LO;
13709               if (toc_symndx != 0)
13710                 {
13711                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13712                   rel->r_addend = toc_addend;
13713                   /* We changed the symbol.  Start over in order to
13714                      get h, sym, sec etc. right.  */
13715                   goto again;
13716                 }
13717               else
13718                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13719             }
13720           break;
13721
13722         case R_PPC64_GOT_TLSGD16_HI:
13723         case R_PPC64_GOT_TLSGD16_HA:
13724           tls_gd = TLS_TPRELGD;
13725           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13726             goto tls_gdld_hi;
13727           break;
13728
13729         case R_PPC64_GOT_TLSLD16_HI:
13730         case R_PPC64_GOT_TLSLD16_HA:
13731           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13732             {
13733             tls_gdld_hi:
13734               if ((tls_mask & tls_gd) != 0)
13735                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13736                           + R_PPC64_GOT_TPREL16_DS);
13737               else
13738                 {
13739                   rel->r_offset -= d_offset;
13740                   bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13741                   r_type = R_PPC64_NONE;
13742                 }
13743               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13744             }
13745           break;
13746
13747         case R_PPC64_GOT_TLSGD16:
13748         case R_PPC64_GOT_TLSGD16_LO:
13749           tls_gd = TLS_TPRELGD;
13750           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13751             goto tls_ldgd_opt;
13752           break;
13753
13754         case R_PPC64_GOT_TLSLD16:
13755         case R_PPC64_GOT_TLSLD16_LO:
13756           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13757             {
13758               unsigned int insn1, insn2, insn3;
13759               bfd_vma offset;
13760
13761             tls_ldgd_opt:
13762               offset = (bfd_vma) -1;
13763               /* If not using the newer R_PPC64_TLSGD/LD to mark
13764                  __tls_get_addr calls, we must trust that the call
13765                  stays with its arg setup insns, ie. that the next
13766                  reloc is the __tls_get_addr call associated with
13767                  the current reloc.  Edit both insns.  */
13768               if (input_section->has_tls_get_addr_call
13769                   && rel + 1 < relend
13770                   && branch_reloc_hash_match (input_bfd, rel + 1,
13771                                               htab->tls_get_addr,
13772                                               htab->tls_get_addr_fd))
13773                 offset = rel[1].r_offset;
13774               /* We read the low GOT_TLS (or TOC16) insn because we
13775                  need to keep the destination reg.  It may be
13776                  something other than the usual r3, and moved to r3
13777                  before the call by intervening code.  */
13778               insn1 = bfd_get_32 (output_bfd,
13779                                   contents + rel->r_offset - d_offset);
13780               if ((tls_mask & tls_gd) != 0)
13781                 {
13782                   /* IE */
13783                   insn1 &= (0x1f << 21) | (0x1f << 16);
13784                   insn1 |= 58 << 26;    /* ld */
13785                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13786                   if (offset != (bfd_vma) -1)
13787                     rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13788                   if ((tls_mask & TLS_EXPLICIT) == 0)
13789                     r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13790                               + R_PPC64_GOT_TPREL16_DS);
13791                   else
13792                     r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13793                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13794                 }
13795               else
13796                 {
13797                   /* LE */
13798                   insn1 &= 0x1f << 21;
13799                   insn1 |= 0x3c0d0000;  /* addis r,13,0 */
13800                   insn2 = 0x38630000;   /* addi 3,3,0 */
13801                   if (tls_gd == 0)
13802                     {
13803                       /* Was an LD reloc.  */
13804                       if (toc_symndx)
13805                         sec = local_sections[toc_symndx];
13806                       for (r_symndx = 0;
13807                            r_symndx < symtab_hdr->sh_info;
13808                            r_symndx++)
13809                         if (local_sections[r_symndx] == sec)
13810                           break;
13811                       if (r_symndx >= symtab_hdr->sh_info)
13812                         r_symndx = STN_UNDEF;
13813                       rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13814                       if (r_symndx != STN_UNDEF)
13815                         rel->r_addend -= (local_syms[r_symndx].st_value
13816                                           + sec->output_offset
13817                                           + sec->output_section->vma);
13818                     }
13819                   else if (toc_symndx != 0)
13820                     {
13821                       r_symndx = toc_symndx;
13822                       rel->r_addend = toc_addend;
13823                     }
13824                   r_type = R_PPC64_TPREL16_HA;
13825                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13826                   if (offset != (bfd_vma) -1)
13827                     {
13828                       rel[1].r_info = ELF64_R_INFO (r_symndx,
13829                                                     R_PPC64_TPREL16_LO);
13830                       rel[1].r_offset = offset + d_offset;
13831                       rel[1].r_addend = rel->r_addend;
13832                     }
13833                 }
13834               bfd_put_32 (output_bfd, insn1,
13835                           contents + rel->r_offset - d_offset);
13836               if (offset != (bfd_vma) -1)
13837                 {
13838                   insn3 = bfd_get_32 (output_bfd,
13839                                       contents + offset + 4);
13840                   if (insn3 == NOP
13841                       || insn3 == CROR_151515 || insn3 == CROR_313131)
13842                     {
13843                       rel[1].r_offset += 4;
13844                       bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13845                       insn2 = NOP;
13846                     }
13847                   bfd_put_32 (output_bfd, insn2, contents + offset);
13848                 }
13849               if ((tls_mask & tls_gd) == 0
13850                   && (tls_gd == 0 || toc_symndx != 0))
13851                 {
13852                   /* We changed the symbol.  Start over in order
13853                      to get h, sym, sec etc. right.  */
13854                   goto again;
13855                 }
13856             }
13857           break;
13858
13859         case R_PPC64_TLSGD:
13860           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13861             {
13862               unsigned int insn2, insn3;
13863               bfd_vma offset = rel->r_offset;
13864
13865               if ((tls_mask & TLS_TPRELGD) != 0)
13866                 {
13867                   /* IE */
13868                   r_type = R_PPC64_NONE;
13869                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13870                 }
13871               else
13872                 {
13873                   /* LE */
13874                   if (toc_symndx != 0)
13875                     {
13876                       r_symndx = toc_symndx;
13877                       rel->r_addend = toc_addend;
13878                     }
13879                   r_type = R_PPC64_TPREL16_LO;
13880                   rel->r_offset = offset + d_offset;
13881                   insn2 = 0x38630000;   /* addi 3,3,0 */
13882                 }
13883               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13884               /* Zap the reloc on the _tls_get_addr call too.  */
13885               BFD_ASSERT (offset == rel[1].r_offset);
13886               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13887               insn3 = bfd_get_32 (output_bfd,
13888                                   contents + offset + 4);
13889               if (insn3 == NOP
13890                   || insn3 == CROR_151515 || insn3 == CROR_313131)
13891                 {
13892                   rel->r_offset += 4;
13893                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13894                   insn2 = NOP;
13895                 }
13896               bfd_put_32 (output_bfd, insn2, contents + offset);
13897               if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
13898                 goto again;
13899             }
13900           break;
13901
13902         case R_PPC64_TLSLD:
13903           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13904             {
13905               unsigned int insn2, insn3;
13906               bfd_vma offset = rel->r_offset;
13907
13908               if (toc_symndx)
13909                 sec = local_sections[toc_symndx];
13910               for (r_symndx = 0;
13911                    r_symndx < symtab_hdr->sh_info;
13912                    r_symndx++)
13913                 if (local_sections[r_symndx] == sec)
13914                   break;
13915               if (r_symndx >= symtab_hdr->sh_info)
13916                 r_symndx = STN_UNDEF;
13917               rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13918               if (r_symndx != STN_UNDEF)
13919                 rel->r_addend -= (local_syms[r_symndx].st_value
13920                                   + sec->output_offset
13921                                   + sec->output_section->vma);
13922
13923               r_type = R_PPC64_TPREL16_LO;
13924               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13925               rel->r_offset = offset + d_offset;
13926               /* Zap the reloc on the _tls_get_addr call too.  */
13927               BFD_ASSERT (offset == rel[1].r_offset);
13928               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13929               insn2 = 0x38630000;       /* addi 3,3,0 */
13930               insn3 = bfd_get_32 (output_bfd,
13931                                   contents + offset + 4);
13932               if (insn3 == NOP
13933                   || insn3 == CROR_151515 || insn3 == CROR_313131)
13934                 {
13935                   rel->r_offset += 4;
13936                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13937                   insn2 = NOP;
13938                 }
13939               bfd_put_32 (output_bfd, insn2, contents + offset);
13940               goto again;
13941             }
13942           break;
13943
13944         case R_PPC64_DTPMOD64:
13945           if (rel + 1 < relend
13946               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
13947               && rel[1].r_offset == rel->r_offset + 8)
13948             {
13949               if ((tls_mask & TLS_GD) == 0)
13950                 {
13951                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
13952                   if ((tls_mask & TLS_TPRELGD) != 0)
13953                     r_type = R_PPC64_TPREL64;
13954                   else
13955                     {
13956                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13957                       r_type = R_PPC64_NONE;
13958                     }
13959                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13960                 }
13961             }
13962           else
13963             {
13964               if ((tls_mask & TLS_LD) == 0)
13965                 {
13966                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13967                   r_type = R_PPC64_NONE;
13968                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13969                 }
13970             }
13971           break;
13972
13973         case R_PPC64_TPREL64:
13974           if ((tls_mask & TLS_TPREL) == 0)
13975             {
13976               r_type = R_PPC64_NONE;
13977               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13978             }
13979           break;
13980
13981         case R_PPC64_ENTRY:
13982           relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
13983           if (!bfd_link_pic (info)
13984               && !info->traditional_format
13985               && relocation + 0x80008000 <= 0xffffffff)
13986             {
13987               unsigned int insn1, insn2;
13988
13989               insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
13990               insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
13991               if ((insn1 & ~0xfffc) == LD_R2_0R12
13992                   && insn2 == ADD_R2_R2_R12)
13993                 {
13994                   bfd_put_32 (output_bfd,
13995                               LIS_R2 + PPC_HA (relocation),
13996                               contents + rel->r_offset);
13997                   bfd_put_32 (output_bfd,
13998                               ADDI_R2_R2 + PPC_LO (relocation),
13999                               contents + rel->r_offset + 4);
14000                 }
14001             }
14002           else
14003             {
14004               relocation -= (rel->r_offset
14005                              + input_section->output_offset
14006                              + input_section->output_section->vma);
14007               if (relocation + 0x80008000 <= 0xffffffff)
14008                 {
14009                   unsigned int insn1, insn2;
14010
14011                   insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
14012                   insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
14013                   if ((insn1 & ~0xfffc) == LD_R2_0R12
14014                       && insn2 == ADD_R2_R2_R12)
14015                     {
14016                       bfd_put_32 (output_bfd,
14017                                   ADDIS_R2_R12 + PPC_HA (relocation),
14018                                   contents + rel->r_offset);
14019                       bfd_put_32 (output_bfd,
14020                                   ADDI_R2_R2 + PPC_LO (relocation),
14021                                   contents + rel->r_offset + 4);
14022                     }
14023                 }
14024             }
14025           break;
14026
14027         case R_PPC64_REL16_HA:
14028           /* If we are generating a non-PIC executable, edit
14029              .  0:      addis 2,12,.TOC.-0b@ha
14030              .          addi 2,2,.TOC.-0b@l
14031              used by ELFv2 global entry points to set up r2, to
14032              .          lis 2,.TOC.@ha
14033              .          addi 2,2,.TOC.@l
14034              if .TOC. is in range.  */
14035           if (!bfd_link_pic (info)
14036               && !info->traditional_format
14037               && !htab->opd_abi
14038               && rel->r_addend == d_offset
14039               && h != NULL && &h->elf == htab->elf.hgot
14040               && rel + 1 < relend
14041               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
14042               && rel[1].r_offset == rel->r_offset + 4
14043               && rel[1].r_addend == rel->r_addend + 4
14044               && relocation + 0x80008000 <= 0xffffffff)
14045             {
14046               unsigned int insn1, insn2;
14047               bfd_vma offset = rel->r_offset - d_offset;
14048               insn1 = bfd_get_32 (output_bfd, contents + offset);
14049               insn2 = bfd_get_32 (output_bfd, contents + offset + 4);
14050               if ((insn1 & 0xffff0000) == ADDIS_R2_R12
14051                   && (insn2 & 0xffff0000) == ADDI_R2_R2)
14052                 {
14053                   r_type = R_PPC64_ADDR16_HA;
14054                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14055                   rel->r_addend -= d_offset;
14056                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
14057                   rel[1].r_addend -= d_offset + 4;
14058                   bfd_put_32 (output_bfd, LIS_R2, contents + offset);
14059                 }
14060             }
14061           break;
14062         }
14063
14064       /* Handle other relocations that tweak non-addend part of insn.  */
14065       insn = 0;
14066       max_br_offset = 1 << 25;
14067       addend = rel->r_addend;
14068       reloc_dest = DEST_NORMAL;
14069       switch (r_type)
14070         {
14071         default:
14072           break;
14073
14074         case R_PPC64_TOCSAVE:
14075           if (relocation + addend == (rel->r_offset
14076                                       + input_section->output_offset
14077                                       + input_section->output_section->vma)
14078               && tocsave_find (htab, NO_INSERT,
14079                                &local_syms, rel, input_bfd))
14080             {
14081               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
14082               if (insn == NOP
14083                   || insn == CROR_151515 || insn == CROR_313131)
14084                 bfd_put_32 (input_bfd,
14085                             STD_R2_0R1 + STK_TOC (htab),
14086                             contents + rel->r_offset);
14087             }
14088           break;
14089
14090           /* Branch taken prediction relocations.  */
14091         case R_PPC64_ADDR14_BRTAKEN:
14092         case R_PPC64_REL14_BRTAKEN:
14093           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
14094           /* Fall through.  */
14095
14096           /* Branch not taken prediction relocations.  */
14097         case R_PPC64_ADDR14_BRNTAKEN:
14098         case R_PPC64_REL14_BRNTAKEN:
14099           insn |= bfd_get_32 (output_bfd,
14100                               contents + rel->r_offset) & ~(0x01 << 21);
14101           /* Fall through.  */
14102
14103         case R_PPC64_REL14:
14104           max_br_offset = 1 << 15;
14105           /* Fall through.  */
14106
14107         case R_PPC64_REL24:
14108           /* Calls to functions with a different TOC, such as calls to
14109              shared objects, need to alter the TOC pointer.  This is
14110              done using a linkage stub.  A REL24 branching to these
14111              linkage stubs needs to be followed by a nop, as the nop
14112              will be replaced with an instruction to restore the TOC
14113              base pointer.  */
14114           fdh = h;
14115           if (h != NULL
14116               && h->oh != NULL
14117               && h->oh->is_func_descriptor)
14118             fdh = ppc_follow_link (h->oh);
14119           stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
14120                                            htab);
14121           if (stub_entry != NULL
14122               && (stub_entry->stub_type == ppc_stub_plt_call
14123                   || stub_entry->stub_type == ppc_stub_plt_call_r2save
14124                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
14125                   || stub_entry->stub_type == ppc_stub_long_branch_r2off))
14126             {
14127               bfd_boolean can_plt_call = FALSE;
14128
14129               /* All of these stubs will modify r2, so there must be a
14130                  branch and link followed by a nop.  The nop is
14131                  replaced by an insn to restore r2.  */
14132               if (rel->r_offset + 8 <= input_section->size)
14133                 {
14134                   unsigned long br;
14135
14136                   br = bfd_get_32 (input_bfd,
14137                                    contents + rel->r_offset);
14138                   if ((br & 1) != 0)
14139                     {
14140                       unsigned long nop;
14141
14142                       nop = bfd_get_32 (input_bfd,
14143                                         contents + rel->r_offset + 4);
14144                       if (nop == NOP
14145                           || nop == CROR_151515 || nop == CROR_313131)
14146                         {
14147                           if (h != NULL
14148                               && (h == htab->tls_get_addr_fd
14149                                   || h == htab->tls_get_addr)
14150                               && htab->params->tls_get_addr_opt)
14151                             {
14152                               /* Special stub used, leave nop alone.  */
14153                             }
14154                           else
14155                             bfd_put_32 (input_bfd,
14156                                         LD_R2_0R1 + STK_TOC (htab),
14157                                         contents + rel->r_offset + 4);
14158                           can_plt_call = TRUE;
14159                         }
14160                     }
14161                 }
14162
14163               if (!can_plt_call && h != NULL)
14164                 {
14165                   const char *name = h->elf.root.root.string;
14166
14167                   if (*name == '.')
14168                     ++name;
14169
14170                   if (strncmp (name, "__libc_start_main", 17) == 0
14171                       && (name[17] == 0 || name[17] == '@'))
14172                     {
14173                       /* Allow crt1 branch to go via a toc adjusting
14174                          stub.  Other calls that never return could do
14175                          the same, if we could detect such.  */
14176                       can_plt_call = TRUE;
14177                     }
14178                 }
14179
14180               if (!can_plt_call)
14181                 {
14182                   /* g++ as of 20130507 emits self-calls without a
14183                      following nop.  This is arguably wrong since we
14184                      have conflicting information.  On the one hand a
14185                      global symbol and on the other a local call
14186                      sequence, but don't error for this special case.
14187                      It isn't possible to cheaply verify we have
14188                      exactly such a call.  Allow all calls to the same
14189                      section.  */
14190                   asection *code_sec = sec;
14191
14192                   if (get_opd_info (sec) != NULL)
14193                     {
14194                       bfd_vma off = (relocation + addend
14195                                      - sec->output_section->vma
14196                                      - sec->output_offset);
14197
14198                       opd_entry_value (sec, off, &code_sec, NULL, FALSE);
14199                     }
14200                   if (code_sec == input_section)
14201                     can_plt_call = TRUE;
14202                 }
14203
14204               if (!can_plt_call)
14205                 {
14206                   if (stub_entry->stub_type == ppc_stub_plt_call
14207                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14208                     info->callbacks->einfo
14209                       /* xgettext:c-format */
14210                       (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
14211                          "recompile with -fPIC\n"),
14212                        input_bfd, input_section, rel->r_offset, sym_name);
14213                   else
14214                     info->callbacks->einfo
14215                       /* xgettext:c-format */
14216                       (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
14217                          "(-mcmodel=small toc adjust stub)\n"),
14218                        input_bfd, input_section, rel->r_offset, sym_name);
14219
14220                   bfd_set_error (bfd_error_bad_value);
14221                   ret = FALSE;
14222                 }
14223
14224               if (can_plt_call
14225                   && (stub_entry->stub_type == ppc_stub_plt_call
14226                       || stub_entry->stub_type == ppc_stub_plt_call_r2save))
14227                 unresolved_reloc = FALSE;
14228             }
14229
14230           if ((stub_entry == NULL
14231                || stub_entry->stub_type == ppc_stub_long_branch
14232                || stub_entry->stub_type == ppc_stub_plt_branch)
14233               && get_opd_info (sec) != NULL)
14234             {
14235               /* The branch destination is the value of the opd entry. */
14236               bfd_vma off = (relocation + addend
14237                              - sec->output_section->vma
14238                              - sec->output_offset);
14239               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
14240               if (dest != (bfd_vma) -1)
14241                 {
14242                   relocation = dest;
14243                   addend = 0;
14244                   reloc_dest = DEST_OPD;
14245                 }
14246             }
14247
14248           /* If the branch is out of reach we ought to have a long
14249              branch stub.  */
14250           from = (rel->r_offset
14251                   + input_section->output_offset
14252                   + input_section->output_section->vma);
14253
14254           relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
14255                                                   ? fdh->elf.other
14256                                                   : sym->st_other);
14257
14258           if (stub_entry != NULL
14259               && (stub_entry->stub_type == ppc_stub_long_branch
14260                   || stub_entry->stub_type == ppc_stub_plt_branch)
14261               && (r_type == R_PPC64_ADDR14_BRTAKEN
14262                   || r_type == R_PPC64_ADDR14_BRNTAKEN
14263                   || (relocation + addend - from + max_br_offset
14264                       < 2 * max_br_offset)))
14265             /* Don't use the stub if this branch is in range.  */
14266             stub_entry = NULL;
14267
14268           if (stub_entry != NULL)
14269             {
14270               /* Munge up the value and addend so that we call the stub
14271                  rather than the procedure directly.  */
14272               asection *stub_sec = stub_entry->group->stub_sec;
14273
14274               if (stub_entry->stub_type == ppc_stub_save_res)
14275                 relocation += (stub_sec->output_offset
14276                                + stub_sec->output_section->vma
14277                                + stub_sec->size - htab->sfpr->size
14278                                - htab->sfpr->output_offset
14279                                - htab->sfpr->output_section->vma);
14280               else
14281                 relocation = (stub_entry->stub_offset
14282                               + stub_sec->output_offset
14283                               + stub_sec->output_section->vma);
14284               addend = 0;
14285               reloc_dest = DEST_STUB;
14286
14287               if ((stub_entry->stub_type == ppc_stub_plt_call
14288                    || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14289                   && (ALWAYS_EMIT_R2SAVE
14290                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14291                   && rel + 1 < relend
14292                   && rel[1].r_offset == rel->r_offset + 4
14293                   && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
14294                 relocation += 4;
14295             }
14296
14297           if (insn != 0)
14298             {
14299               if (is_isa_v2)
14300                 {
14301                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
14302                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
14303                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
14304                   if ((insn & (0x14 << 21)) == (0x04 << 21))
14305                     insn |= 0x02 << 21;
14306                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
14307                     insn |= 0x08 << 21;
14308                   else
14309                     break;
14310                 }
14311               else
14312                 {
14313                   /* Invert 'y' bit if not the default.  */
14314                   if ((bfd_signed_vma) (relocation + addend - from) < 0)
14315                     insn ^= 0x01 << 21;
14316                 }
14317
14318               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
14319             }
14320
14321           /* NOP out calls to undefined weak functions.
14322              We can thus call a weak function without first
14323              checking whether the function is defined.  */
14324           else if (h != NULL
14325                    && h->elf.root.type == bfd_link_hash_undefweak
14326                    && h->elf.dynindx == -1
14327                    && r_type == R_PPC64_REL24
14328                    && relocation == 0
14329                    && addend == 0)
14330             {
14331               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
14332               goto copy_reloc;
14333             }
14334           break;
14335         }
14336
14337       /* Set `addend'.  */
14338       tls_type = 0;
14339       switch (r_type)
14340         {
14341         default:
14342           info->callbacks->einfo
14343             /* xgettext:c-format */
14344             (_("%P: %B: unknown relocation type %d for `%T'\n"),
14345              input_bfd, (int) r_type, sym_name);
14346
14347           bfd_set_error (bfd_error_bad_value);
14348           ret = FALSE;
14349           goto copy_reloc;
14350
14351         case R_PPC64_NONE:
14352         case R_PPC64_TLS:
14353         case R_PPC64_TLSGD:
14354         case R_PPC64_TLSLD:
14355         case R_PPC64_TOCSAVE:
14356         case R_PPC64_GNU_VTINHERIT:
14357         case R_PPC64_GNU_VTENTRY:
14358         case R_PPC64_ENTRY:
14359           goto copy_reloc;
14360
14361           /* GOT16 relocations.  Like an ADDR16 using the symbol's
14362              address in the GOT as relocation value instead of the
14363              symbol's value itself.  Also, create a GOT entry for the
14364              symbol and put the symbol value there.  */
14365         case R_PPC64_GOT_TLSGD16:
14366         case R_PPC64_GOT_TLSGD16_LO:
14367         case R_PPC64_GOT_TLSGD16_HI:
14368         case R_PPC64_GOT_TLSGD16_HA:
14369           tls_type = TLS_TLS | TLS_GD;
14370           goto dogot;
14371
14372         case R_PPC64_GOT_TLSLD16:
14373         case R_PPC64_GOT_TLSLD16_LO:
14374         case R_PPC64_GOT_TLSLD16_HI:
14375         case R_PPC64_GOT_TLSLD16_HA:
14376           tls_type = TLS_TLS | TLS_LD;
14377           goto dogot;
14378
14379         case R_PPC64_GOT_TPREL16_DS:
14380         case R_PPC64_GOT_TPREL16_LO_DS:
14381         case R_PPC64_GOT_TPREL16_HI:
14382         case R_PPC64_GOT_TPREL16_HA:
14383           tls_type = TLS_TLS | TLS_TPREL;
14384           goto dogot;
14385
14386         case R_PPC64_GOT_DTPREL16_DS:
14387         case R_PPC64_GOT_DTPREL16_LO_DS:
14388         case R_PPC64_GOT_DTPREL16_HI:
14389         case R_PPC64_GOT_DTPREL16_HA:
14390           tls_type = TLS_TLS | TLS_DTPREL;
14391           goto dogot;
14392
14393         case R_PPC64_GOT16:
14394         case R_PPC64_GOT16_LO:
14395         case R_PPC64_GOT16_HI:
14396         case R_PPC64_GOT16_HA:
14397         case R_PPC64_GOT16_DS:
14398         case R_PPC64_GOT16_LO_DS:
14399         dogot:
14400           {
14401             /* Relocation is to the entry for this symbol in the global
14402                offset table.  */
14403             asection *got;
14404             bfd_vma *offp;
14405             bfd_vma off;
14406             unsigned long indx = 0;
14407             struct got_entry *ent;
14408
14409             if (tls_type == (TLS_TLS | TLS_LD)
14410                 && (h == NULL
14411                     || !h->elf.def_dynamic))
14412               ent = ppc64_tlsld_got (input_bfd);
14413             else
14414               {
14415
14416                 if (h != NULL)
14417                   {
14418                     bfd_boolean dyn = htab->elf.dynamic_sections_created;
14419                     if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info),
14420                                                           &h->elf)
14421                         || (bfd_link_pic (info)
14422                             && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
14423                       /* This is actually a static link, or it is a
14424                          -Bsymbolic link and the symbol is defined
14425                          locally, or the symbol was forced to be local
14426                          because of a version file.  */
14427                       ;
14428                     else
14429                       {
14430                         BFD_ASSERT (h->elf.dynindx != -1);
14431                         indx = h->elf.dynindx;
14432                         unresolved_reloc = FALSE;
14433                       }
14434                     ent = h->elf.got.glist;
14435                   }
14436                 else
14437                   {
14438                     if (local_got_ents == NULL)
14439                       abort ();
14440                     ent = local_got_ents[r_symndx];
14441                   }
14442
14443                 for (; ent != NULL; ent = ent->next)
14444                   if (ent->addend == orig_rel.r_addend
14445                       && ent->owner == input_bfd
14446                       && ent->tls_type == tls_type)
14447                     break;
14448               }
14449
14450             if (ent == NULL)
14451               abort ();
14452             if (ent->is_indirect)
14453               ent = ent->got.ent;
14454             offp = &ent->got.offset;
14455             got = ppc64_elf_tdata (ent->owner)->got;
14456             if (got == NULL)
14457               abort ();
14458
14459             /* The offset must always be a multiple of 8.  We use the
14460                least significant bit to record whether we have already
14461                processed this entry.  */
14462             off = *offp;
14463             if ((off & 1) != 0)
14464               off &= ~1;
14465             else
14466               {
14467                 /* Generate relocs for the dynamic linker, except in
14468                    the case of TLSLD where we'll use one entry per
14469                    module.  */
14470                 asection *relgot;
14471                 bfd_boolean ifunc;
14472
14473                 *offp = off | 1;
14474                 relgot = NULL;
14475                 ifunc = (h != NULL
14476                          ? h->elf.type == STT_GNU_IFUNC
14477                          : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
14478                 if (ifunc)
14479                   relgot = htab->elf.irelplt;
14480                 else if ((bfd_link_pic (info) || indx != 0)
14481                          && (h == NULL
14482                              || (tls_type == (TLS_TLS | TLS_LD)
14483                                  && !h->elf.def_dynamic)
14484                              || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14485                              || h->elf.root.type != bfd_link_hash_undefweak))
14486                   relgot = ppc64_elf_tdata (ent->owner)->relgot;
14487                 if (relgot != NULL)
14488                   {
14489                     outrel.r_offset = (got->output_section->vma
14490                                        + got->output_offset
14491                                        + off);
14492                     outrel.r_addend = addend;
14493                     if (tls_type & (TLS_LD | TLS_GD))
14494                       {
14495                         outrel.r_addend = 0;
14496                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
14497                         if (tls_type == (TLS_TLS | TLS_GD))
14498                           {
14499                             loc = relgot->contents;
14500                             loc += (relgot->reloc_count++
14501                                     * sizeof (Elf64_External_Rela));
14502                             bfd_elf64_swap_reloca_out (output_bfd,
14503                                                        &outrel, loc);
14504                             outrel.r_offset += 8;
14505                             outrel.r_addend = addend;
14506                             outrel.r_info
14507                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14508                           }
14509                       }
14510                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
14511                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14512                     else if (tls_type == (TLS_TLS | TLS_TPREL))
14513                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
14514                     else if (indx != 0)
14515                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
14516                     else
14517                       {
14518                         if (ifunc)
14519                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14520                         else
14521                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14522
14523                         /* Write the .got section contents for the sake
14524                            of prelink.  */
14525                         loc = got->contents + off;
14526                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
14527                                     loc);
14528                       }
14529
14530                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
14531                       {
14532                         outrel.r_addend += relocation;
14533                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
14534                           {
14535                             if (htab->elf.tls_sec == NULL)
14536                               outrel.r_addend = 0;
14537                             else
14538                               outrel.r_addend -= htab->elf.tls_sec->vma;
14539                           }
14540                       }
14541                     loc = relgot->contents;
14542                     loc += (relgot->reloc_count++
14543                             * sizeof (Elf64_External_Rela));
14544                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14545                   }
14546
14547                 /* Init the .got section contents here if we're not
14548                    emitting a reloc.  */
14549                 else
14550                   {
14551                     relocation += addend;
14552                     if (tls_type == (TLS_TLS | TLS_LD))
14553                       relocation = 1;
14554                     else if (tls_type != 0)
14555                       {
14556                         if (htab->elf.tls_sec == NULL)
14557                           relocation = 0;
14558                         else
14559                           {
14560                             relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
14561                             if (tls_type == (TLS_TLS | TLS_TPREL))
14562                               relocation += DTP_OFFSET - TP_OFFSET;
14563                           }
14564
14565                         if (tls_type == (TLS_TLS | TLS_GD))
14566                           {
14567                             bfd_put_64 (output_bfd, relocation,
14568                                         got->contents + off + 8);
14569                             relocation = 1;
14570                           }
14571                       }
14572
14573                     bfd_put_64 (output_bfd, relocation,
14574                                 got->contents + off);
14575                   }
14576               }
14577
14578             if (off >= (bfd_vma) -2)
14579               abort ();
14580
14581             relocation = got->output_section->vma + got->output_offset + off;
14582             addend = -(TOCstart + htab->sec_info[input_section->id].toc_off);
14583           }
14584           break;
14585
14586         case R_PPC64_PLT16_HA:
14587         case R_PPC64_PLT16_HI:
14588         case R_PPC64_PLT16_LO:
14589         case R_PPC64_PLT32:
14590         case R_PPC64_PLT64:
14591           /* Relocation is to the entry for this symbol in the
14592              procedure linkage table.  */
14593           {
14594             struct plt_entry **plt_list = NULL;
14595             if (h != NULL)
14596               plt_list = &h->elf.plt.plist;
14597             else if (local_got_ents != NULL)
14598               {
14599                 struct plt_entry **local_plt = (struct plt_entry **)
14600                   (local_got_ents + symtab_hdr->sh_info);
14601                 unsigned char *local_got_tls_masks = (unsigned char *)
14602                   (local_plt + symtab_hdr->sh_info);
14603                 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
14604                   plt_list = local_plt + r_symndx;
14605               }
14606             if (plt_list)
14607               {
14608                 struct plt_entry *ent;
14609
14610                 for (ent = *plt_list; ent != NULL; ent = ent->next)
14611                   if (ent->plt.offset != (bfd_vma) -1
14612                       && ent->addend == orig_rel.r_addend)
14613                     {
14614                       asection *plt;
14615
14616                       plt = htab->elf.splt;
14617                       if (!htab->elf.dynamic_sections_created
14618                           || h == NULL
14619                           || h->elf.dynindx == -1)
14620                         plt = htab->elf.iplt;
14621                       relocation = (plt->output_section->vma
14622                                     + plt->output_offset
14623                                     + ent->plt.offset);
14624                       addend = 0;
14625                       unresolved_reloc = FALSE;
14626                       break;
14627                     }
14628               }
14629           }
14630           break;
14631
14632         case R_PPC64_TOC:
14633           /* Relocation value is TOC base.  */
14634           relocation = TOCstart;
14635           if (r_symndx == STN_UNDEF)
14636             relocation += htab->sec_info[input_section->id].toc_off;
14637           else if (unresolved_reloc)
14638             ;
14639           else if (sec != NULL && sec->id < htab->sec_info_arr_size)
14640             relocation += htab->sec_info[sec->id].toc_off;
14641           else
14642             unresolved_reloc = TRUE;
14643           goto dodyn;
14644
14645           /* TOC16 relocs.  We want the offset relative to the TOC base,
14646              which is the address of the start of the TOC plus 0x8000.
14647              The TOC consists of sections .got, .toc, .tocbss, and .plt,
14648              in this order.  */
14649         case R_PPC64_TOC16:
14650         case R_PPC64_TOC16_LO:
14651         case R_PPC64_TOC16_HI:
14652         case R_PPC64_TOC16_DS:
14653         case R_PPC64_TOC16_LO_DS:
14654         case R_PPC64_TOC16_HA:
14655           addend -= TOCstart + htab->sec_info[input_section->id].toc_off;
14656           break;
14657
14658           /* Relocate against the beginning of the section.  */
14659         case R_PPC64_SECTOFF:
14660         case R_PPC64_SECTOFF_LO:
14661         case R_PPC64_SECTOFF_HI:
14662         case R_PPC64_SECTOFF_DS:
14663         case R_PPC64_SECTOFF_LO_DS:
14664         case R_PPC64_SECTOFF_HA:
14665           if (sec != NULL)
14666             addend -= sec->output_section->vma;
14667           break;
14668
14669         case R_PPC64_REL16:
14670         case R_PPC64_REL16_LO:
14671         case R_PPC64_REL16_HI:
14672         case R_PPC64_REL16_HA:
14673         case R_PPC64_REL16DX_HA:
14674           break;
14675
14676         case R_PPC64_REL14:
14677         case R_PPC64_REL14_BRNTAKEN:
14678         case R_PPC64_REL14_BRTAKEN:
14679         case R_PPC64_REL24:
14680           break;
14681
14682         case R_PPC64_TPREL16:
14683         case R_PPC64_TPREL16_LO:
14684         case R_PPC64_TPREL16_HI:
14685         case R_PPC64_TPREL16_HA:
14686         case R_PPC64_TPREL16_DS:
14687         case R_PPC64_TPREL16_LO_DS:
14688         case R_PPC64_TPREL16_HIGH:
14689         case R_PPC64_TPREL16_HIGHA:
14690         case R_PPC64_TPREL16_HIGHER:
14691         case R_PPC64_TPREL16_HIGHERA:
14692         case R_PPC64_TPREL16_HIGHEST:
14693         case R_PPC64_TPREL16_HIGHESTA:
14694           if (h != NULL
14695               && h->elf.root.type == bfd_link_hash_undefweak
14696               && h->elf.dynindx == -1)
14697             {
14698               /* Make this relocation against an undefined weak symbol
14699                  resolve to zero.  This is really just a tweak, since
14700                  code using weak externs ought to check that they are
14701                  defined before using them.  */
14702               bfd_byte *p = contents + rel->r_offset - d_offset;
14703
14704               insn = bfd_get_32 (output_bfd, p);
14705               insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14706               if (insn != 0)
14707                 bfd_put_32 (output_bfd, insn, p);
14708               break;
14709             }
14710           if (htab->elf.tls_sec != NULL)
14711             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14712           if (bfd_link_pic (info))
14713             /* The TPREL16 relocs shouldn't really be used in shared
14714                libs as they will result in DT_TEXTREL being set, but
14715                support them anyway.  */
14716             goto dodyn;
14717           break;
14718
14719         case R_PPC64_DTPREL16:
14720         case R_PPC64_DTPREL16_LO:
14721         case R_PPC64_DTPREL16_HI:
14722         case R_PPC64_DTPREL16_HA:
14723         case R_PPC64_DTPREL16_DS:
14724         case R_PPC64_DTPREL16_LO_DS:
14725         case R_PPC64_DTPREL16_HIGH:
14726         case R_PPC64_DTPREL16_HIGHA:
14727         case R_PPC64_DTPREL16_HIGHER:
14728         case R_PPC64_DTPREL16_HIGHERA:
14729         case R_PPC64_DTPREL16_HIGHEST:
14730         case R_PPC64_DTPREL16_HIGHESTA:
14731           if (htab->elf.tls_sec != NULL)
14732             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14733           break;
14734
14735         case R_PPC64_ADDR64_LOCAL:
14736           addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
14737                                               ? h->elf.other
14738                                               : sym->st_other);
14739           break;
14740
14741         case R_PPC64_DTPMOD64:
14742           relocation = 1;
14743           addend = 0;
14744           goto dodyn;
14745
14746         case R_PPC64_TPREL64:
14747           if (htab->elf.tls_sec != NULL)
14748             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14749           goto dodyn;
14750
14751         case R_PPC64_DTPREL64:
14752           if (htab->elf.tls_sec != NULL)
14753             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14754           /* Fall through.  */
14755
14756           /* Relocations that may need to be propagated if this is a
14757              dynamic object.  */
14758         case R_PPC64_REL30:
14759         case R_PPC64_REL32:
14760         case R_PPC64_REL64:
14761         case R_PPC64_ADDR14:
14762         case R_PPC64_ADDR14_BRNTAKEN:
14763         case R_PPC64_ADDR14_BRTAKEN:
14764         case R_PPC64_ADDR16:
14765         case R_PPC64_ADDR16_DS:
14766         case R_PPC64_ADDR16_HA:
14767         case R_PPC64_ADDR16_HI:
14768         case R_PPC64_ADDR16_HIGH:
14769         case R_PPC64_ADDR16_HIGHA:
14770         case R_PPC64_ADDR16_HIGHER:
14771         case R_PPC64_ADDR16_HIGHERA:
14772         case R_PPC64_ADDR16_HIGHEST:
14773         case R_PPC64_ADDR16_HIGHESTA:
14774         case R_PPC64_ADDR16_LO:
14775         case R_PPC64_ADDR16_LO_DS:
14776         case R_PPC64_ADDR24:
14777         case R_PPC64_ADDR32:
14778         case R_PPC64_ADDR64:
14779         case R_PPC64_UADDR16:
14780         case R_PPC64_UADDR32:
14781         case R_PPC64_UADDR64:
14782         dodyn:
14783           if ((input_section->flags & SEC_ALLOC) == 0)
14784             break;
14785
14786           if (NO_OPD_RELOCS && is_opd)
14787             break;
14788
14789           if (bfd_link_pic (info)
14790               ? ((h != NULL && pc_dynrelocs (h))
14791                  || must_be_dyn_reloc (info, r_type))
14792               : (h != NULL
14793                  ? h->dyn_relocs != NULL
14794                  : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14795             {
14796               bfd_boolean skip, relocate;
14797               asection *sreloc;
14798               bfd_vma out_off;
14799
14800               /* When generating a dynamic object, these relocations
14801                  are copied into the output file to be resolved at run
14802                  time.  */
14803
14804               skip = FALSE;
14805               relocate = FALSE;
14806
14807               out_off = _bfd_elf_section_offset (output_bfd, info,
14808                                                  input_section, rel->r_offset);
14809               if (out_off == (bfd_vma) -1)
14810                 skip = TRUE;
14811               else if (out_off == (bfd_vma) -2)
14812                 skip = TRUE, relocate = TRUE;
14813               out_off += (input_section->output_section->vma
14814                           + input_section->output_offset);
14815               outrel.r_offset = out_off;
14816               outrel.r_addend = rel->r_addend;
14817
14818               /* Optimize unaligned reloc use.  */
14819               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14820                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14821                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14822               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14823                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
14824                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
14825               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
14826                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
14827                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
14828
14829               if (skip)
14830                 memset (&outrel, 0, sizeof outrel);
14831               else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14832                        && !is_opd
14833                        && r_type != R_PPC64_TOC)
14834                 {
14835                   BFD_ASSERT (h->elf.dynindx != -1);
14836                   outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
14837                 }
14838               else
14839                 {
14840                   /* This symbol is local, or marked to become local,
14841                      or this is an opd section reloc which must point
14842                      at a local function.  */
14843                   outrel.r_addend += relocation;
14844                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
14845                     {
14846                       if (is_opd && h != NULL)
14847                         {
14848                           /* Lie about opd entries.  This case occurs
14849                              when building shared libraries and we
14850                              reference a function in another shared
14851                              lib.  The same thing happens for a weak
14852                              definition in an application that's
14853                              overridden by a strong definition in a
14854                              shared lib.  (I believe this is a generic
14855                              bug in binutils handling of weak syms.)
14856                              In these cases we won't use the opd
14857                              entry in this lib.  */
14858                           unresolved_reloc = FALSE;
14859                         }
14860                       if (!is_opd
14861                           && r_type == R_PPC64_ADDR64
14862                           && (h != NULL
14863                               ? h->elf.type == STT_GNU_IFUNC
14864                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14865                         outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14866                       else
14867                         {
14868                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14869
14870                           /* We need to relocate .opd contents for ld.so.
14871                              Prelink also wants simple and consistent rules
14872                              for relocs.  This make all RELATIVE relocs have
14873                              *r_offset equal to r_addend.  */
14874                           relocate = TRUE;
14875                         }
14876                     }
14877                   else
14878                     {
14879                       long indx = 0;
14880
14881                       if (h != NULL
14882                           ? h->elf.type == STT_GNU_IFUNC
14883                           : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14884                         {
14885                           info->callbacks->einfo
14886                             /* xgettext:c-format */
14887                             (_("%P: %H: %s for indirect "
14888                                "function `%T' unsupported\n"),
14889                              input_bfd, input_section, rel->r_offset,
14890                              ppc64_elf_howto_table[r_type]->name,
14891                              sym_name);
14892                           ret = FALSE;
14893                         }
14894                       else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
14895                         ;
14896                       else if (sec == NULL || sec->owner == NULL)
14897                         {
14898                           bfd_set_error (bfd_error_bad_value);
14899                           return FALSE;
14900                         }
14901                       else
14902                         {
14903                           asection *osec;
14904
14905                           osec = sec->output_section;
14906                           indx = elf_section_data (osec)->dynindx;
14907
14908                           if (indx == 0)
14909                             {
14910                               if ((osec->flags & SEC_READONLY) == 0
14911                                   && htab->elf.data_index_section != NULL)
14912                                 osec = htab->elf.data_index_section;
14913                               else
14914                                 osec = htab->elf.text_index_section;
14915                               indx = elf_section_data (osec)->dynindx;
14916                             }
14917                           BFD_ASSERT (indx != 0);
14918
14919                           /* We are turning this relocation into one
14920                              against a section symbol, so subtract out
14921                              the output section's address but not the
14922                              offset of the input section in the output
14923                              section.  */
14924                           outrel.r_addend -= osec->vma;
14925                         }
14926
14927                       outrel.r_info = ELF64_R_INFO (indx, r_type);
14928                     }
14929                 }
14930
14931               sreloc = elf_section_data (input_section)->sreloc;
14932               if (h != NULL
14933                   ? h->elf.type == STT_GNU_IFUNC
14934                   : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14935                 sreloc = htab->elf.irelplt;
14936               if (sreloc == NULL)
14937                 abort ();
14938
14939               if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
14940                   >= sreloc->size)
14941                 abort ();
14942               loc = sreloc->contents;
14943               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
14944               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14945
14946               /* If this reloc is against an external symbol, it will
14947                  be computed at runtime, so there's no need to do
14948                  anything now.  However, for the sake of prelink ensure
14949                  that the section contents are a known value.  */
14950               if (! relocate)
14951                 {
14952                   unresolved_reloc = FALSE;
14953                   /* The value chosen here is quite arbitrary as ld.so
14954                      ignores section contents except for the special
14955                      case of .opd where the contents might be accessed
14956                      before relocation.  Choose zero, as that won't
14957                      cause reloc overflow.  */
14958                   relocation = 0;
14959                   addend = 0;
14960                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
14961                      to improve backward compatibility with older
14962                      versions of ld.  */
14963                   if (r_type == R_PPC64_ADDR64)
14964                     addend = outrel.r_addend;
14965                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
14966                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
14967                     addend = (input_section->output_section->vma
14968                               + input_section->output_offset
14969                               + rel->r_offset);
14970                 }
14971             }
14972           break;
14973
14974         case R_PPC64_COPY:
14975         case R_PPC64_GLOB_DAT:
14976         case R_PPC64_JMP_SLOT:
14977         case R_PPC64_JMP_IREL:
14978         case R_PPC64_RELATIVE:
14979           /* We shouldn't ever see these dynamic relocs in relocatable
14980              files.  */
14981           /* Fall through.  */
14982
14983         case R_PPC64_PLTGOT16:
14984         case R_PPC64_PLTGOT16_DS:
14985         case R_PPC64_PLTGOT16_HA:
14986         case R_PPC64_PLTGOT16_HI:
14987         case R_PPC64_PLTGOT16_LO:
14988         case R_PPC64_PLTGOT16_LO_DS:
14989         case R_PPC64_PLTREL32:
14990         case R_PPC64_PLTREL64:
14991           /* These ones haven't been implemented yet.  */
14992
14993           info->callbacks->einfo
14994             /* xgettext:c-format */
14995             (_("%P: %B: %s is not supported for `%T'\n"),
14996              input_bfd,
14997              ppc64_elf_howto_table[r_type]->name, sym_name);
14998
14999           bfd_set_error (bfd_error_invalid_operation);
15000           ret = FALSE;
15001           goto copy_reloc;
15002         }
15003
15004       /* Multi-instruction sequences that access the TOC can be
15005          optimized, eg. addis ra,r2,0; addi rb,ra,x;
15006          to             nop;           addi rb,r2,x;  */
15007       switch (r_type)
15008         {
15009         default:
15010           break;
15011
15012         case R_PPC64_GOT_TLSLD16_HI:
15013         case R_PPC64_GOT_TLSGD16_HI:
15014         case R_PPC64_GOT_TPREL16_HI:
15015         case R_PPC64_GOT_DTPREL16_HI:
15016         case R_PPC64_GOT16_HI:
15017         case R_PPC64_TOC16_HI:
15018           /* These relocs would only be useful if building up an
15019              offset to later add to r2, perhaps in an indexed
15020              addressing mode instruction.  Don't try to optimize.
15021              Unfortunately, the possibility of someone building up an
15022              offset like this or even with the HA relocs, means that
15023              we need to check the high insn when optimizing the low
15024              insn.  */
15025           break;
15026
15027         case R_PPC64_GOT_TLSLD16_HA:
15028         case R_PPC64_GOT_TLSGD16_HA:
15029         case R_PPC64_GOT_TPREL16_HA:
15030         case R_PPC64_GOT_DTPREL16_HA:
15031         case R_PPC64_GOT16_HA:
15032         case R_PPC64_TOC16_HA:
15033           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
15034               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
15035             {
15036               bfd_byte *p = contents + (rel->r_offset & ~3);
15037               bfd_put_32 (input_bfd, NOP, p);
15038             }
15039           break;
15040
15041         case R_PPC64_GOT_TLSLD16_LO:
15042         case R_PPC64_GOT_TLSGD16_LO:
15043         case R_PPC64_GOT_TPREL16_LO_DS:
15044         case R_PPC64_GOT_DTPREL16_LO_DS:
15045         case R_PPC64_GOT16_LO:
15046         case R_PPC64_GOT16_LO_DS:
15047         case R_PPC64_TOC16_LO:
15048         case R_PPC64_TOC16_LO_DS:
15049           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
15050               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
15051             {
15052               bfd_byte *p = contents + (rel->r_offset & ~3);
15053               insn = bfd_get_32 (input_bfd, p);
15054               if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
15055                 {
15056                   /* Transform addic to addi when we change reg.  */
15057                   insn &= ~((0x3f << 26) | (0x1f << 16));
15058                   insn |= (14u << 26) | (2 << 16);
15059                 }
15060               else
15061                 {
15062                   insn &= ~(0x1f << 16);
15063                   insn |= 2 << 16;
15064                 }
15065               bfd_put_32 (input_bfd, insn, p);
15066             }
15067           break;
15068         }
15069
15070       /* Do any further special processing.  */
15071       howto = ppc64_elf_howto_table[(int) r_type];
15072       switch (r_type)
15073         {
15074         default:
15075           break;
15076
15077         case R_PPC64_REL16_HA:
15078         case R_PPC64_REL16DX_HA:
15079         case R_PPC64_ADDR16_HA:
15080         case R_PPC64_ADDR16_HIGHA:
15081         case R_PPC64_ADDR16_HIGHERA:
15082         case R_PPC64_ADDR16_HIGHESTA:
15083         case R_PPC64_TOC16_HA:
15084         case R_PPC64_SECTOFF_HA:
15085         case R_PPC64_TPREL16_HA:
15086         case R_PPC64_TPREL16_HIGHA:
15087         case R_PPC64_TPREL16_HIGHERA:
15088         case R_PPC64_TPREL16_HIGHESTA:
15089         case R_PPC64_DTPREL16_HA:
15090         case R_PPC64_DTPREL16_HIGHA:
15091         case R_PPC64_DTPREL16_HIGHERA:
15092         case R_PPC64_DTPREL16_HIGHESTA:
15093           /* It's just possible that this symbol is a weak symbol
15094              that's not actually defined anywhere. In that case,
15095              'sec' would be NULL, and we should leave the symbol
15096              alone (it will be set to zero elsewhere in the link).  */
15097           if (sec == NULL)
15098             break;
15099           /* Fall through.  */
15100
15101         case R_PPC64_GOT16_HA:
15102         case R_PPC64_PLTGOT16_HA:
15103         case R_PPC64_PLT16_HA:
15104         case R_PPC64_GOT_TLSGD16_HA:
15105         case R_PPC64_GOT_TLSLD16_HA:
15106         case R_PPC64_GOT_TPREL16_HA:
15107         case R_PPC64_GOT_DTPREL16_HA:
15108           /* Add 0x10000 if sign bit in 0:15 is set.
15109              Bits 0:15 are not used.  */
15110           addend += 0x8000;
15111           break;
15112
15113         case R_PPC64_ADDR16_DS:
15114         case R_PPC64_ADDR16_LO_DS:
15115         case R_PPC64_GOT16_DS:
15116         case R_PPC64_GOT16_LO_DS:
15117         case R_PPC64_PLT16_LO_DS:
15118         case R_PPC64_SECTOFF_DS:
15119         case R_PPC64_SECTOFF_LO_DS:
15120         case R_PPC64_TOC16_DS:
15121         case R_PPC64_TOC16_LO_DS:
15122         case R_PPC64_PLTGOT16_DS:
15123         case R_PPC64_PLTGOT16_LO_DS:
15124         case R_PPC64_GOT_TPREL16_DS:
15125         case R_PPC64_GOT_TPREL16_LO_DS:
15126         case R_PPC64_GOT_DTPREL16_DS:
15127         case R_PPC64_GOT_DTPREL16_LO_DS:
15128         case R_PPC64_TPREL16_DS:
15129         case R_PPC64_TPREL16_LO_DS:
15130         case R_PPC64_DTPREL16_DS:
15131         case R_PPC64_DTPREL16_LO_DS:
15132           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15133           mask = 3;
15134           /* If this reloc is against an lq, lxv, or stxv insn, then
15135              the value must be a multiple of 16.  This is somewhat of
15136              a hack, but the "correct" way to do this by defining _DQ
15137              forms of all the _DS relocs bloats all reloc switches in
15138              this file.  It doesn't make much sense to use these
15139              relocs in data, so testing the insn should be safe.  */
15140           if ((insn & (0x3f << 26)) == (56u << 26)
15141               || ((insn & (0x3f << 26)) == (61u << 26) && (insn & 3) == 1))
15142             mask = 15;
15143           relocation += addend;
15144           addend = insn & (mask ^ 3);
15145           if ((relocation & mask) != 0)
15146             {
15147               relocation ^= relocation & mask;
15148               info->callbacks->einfo
15149                 /* xgettext:c-format */
15150                 (_("%P: %H: error: %s not a multiple of %u\n"),
15151                  input_bfd, input_section, rel->r_offset,
15152                  howto->name,
15153                  mask + 1);
15154               bfd_set_error (bfd_error_bad_value);
15155               ret = FALSE;
15156               goto copy_reloc;
15157             }
15158           break;
15159         }
15160
15161       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
15162          because such sections are not SEC_ALLOC and thus ld.so will
15163          not process them.  */
15164       if (unresolved_reloc
15165           && !((input_section->flags & SEC_DEBUGGING) != 0
15166                && h->elf.def_dynamic)
15167           && _bfd_elf_section_offset (output_bfd, info, input_section,
15168                                       rel->r_offset) != (bfd_vma) -1)
15169         {
15170           info->callbacks->einfo
15171             /* xgettext:c-format */
15172             (_("%P: %H: unresolvable %s against `%T'\n"),
15173              input_bfd, input_section, rel->r_offset,
15174              howto->name,
15175              h->elf.root.root.string);
15176           ret = FALSE;
15177         }
15178
15179       /* 16-bit fields in insns mostly have signed values, but a
15180          few insns have 16-bit unsigned values.  Really, we should
15181          have different reloc types.  */
15182       if (howto->complain_on_overflow != complain_overflow_dont
15183           && howto->dst_mask == 0xffff
15184           && (input_section->flags & SEC_CODE) != 0)
15185         {
15186           enum complain_overflow complain = complain_overflow_signed;
15187
15188           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15189           if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
15190             complain = complain_overflow_bitfield;
15191           else if (howto->rightshift == 0
15192                    ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
15193                       || (insn & (0x3f << 26)) == 24u << 26 /* ori */
15194                       || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
15195                    : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
15196                       || (insn & (0x3f << 26)) == 25u << 26 /* oris */
15197                       || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
15198             complain = complain_overflow_unsigned;
15199           if (howto->complain_on_overflow != complain)
15200             {
15201               alt_howto = *howto;
15202               alt_howto.complain_on_overflow = complain;
15203               howto = &alt_howto;
15204             }
15205         }
15206
15207       if (r_type == R_PPC64_REL16DX_HA)
15208         {
15209           /* Split field reloc isn't handled by _bfd_final_link_relocate.  */
15210           if (rel->r_offset + 4 > input_section->size)
15211             r = bfd_reloc_outofrange;
15212           else
15213             {
15214               relocation += addend;
15215               relocation -= (rel->r_offset
15216                              + input_section->output_offset
15217                              + input_section->output_section->vma);
15218               relocation = (bfd_signed_vma) relocation >> 16;
15219               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
15220               insn &= ~0x1fffc1;
15221               insn |= (relocation & 0xffc1) | ((relocation & 0x3e) << 15);
15222               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
15223               r = bfd_reloc_ok;
15224               if (relocation + 0x8000 > 0xffff)
15225                 r = bfd_reloc_overflow;
15226             }
15227         }
15228       else
15229         r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
15230                                       rel->r_offset, relocation, addend);
15231
15232       if (r != bfd_reloc_ok)
15233         {
15234           char *more_info = NULL;
15235           const char *reloc_name = howto->name;
15236
15237           if (reloc_dest != DEST_NORMAL)
15238             {
15239               more_info = bfd_malloc (strlen (reloc_name) + 8);
15240               if (more_info != NULL)
15241                 {
15242                   strcpy (more_info, reloc_name);
15243                   strcat (more_info, (reloc_dest == DEST_OPD
15244                                       ? " (OPD)" : " (stub)"));
15245                   reloc_name = more_info;
15246                 }
15247             }
15248
15249           if (r == bfd_reloc_overflow)
15250             {
15251               /* On code like "if (foo) foo();" don't report overflow
15252                  on a branch to zero when foo is undefined.  */
15253               if (!warned
15254                   && (reloc_dest == DEST_STUB
15255                       || !(h != NULL
15256                            && (h->elf.root.type == bfd_link_hash_undefweak
15257                                || h->elf.root.type == bfd_link_hash_undefined)
15258                            && is_branch_reloc (r_type))))
15259                 info->callbacks->reloc_overflow (info, &h->elf.root,
15260                                                  sym_name, reloc_name,
15261                                                  orig_rel.r_addend,
15262                                                  input_bfd, input_section,
15263                                                  rel->r_offset);
15264             }
15265           else
15266             {
15267               info->callbacks->einfo
15268                 /* xgettext:c-format */
15269                 (_("%P: %H: %s against `%T': error %d\n"),
15270                  input_bfd, input_section, rel->r_offset,
15271                  reloc_name, sym_name, (int) r);
15272               ret = FALSE;
15273             }
15274           if (more_info != NULL)
15275             free (more_info);
15276         }
15277     copy_reloc:
15278       if (wrel != rel)
15279         *wrel = *rel;
15280     }
15281
15282   if (wrel != rel)
15283     {
15284       Elf_Internal_Shdr *rel_hdr;
15285       size_t deleted = rel - wrel;
15286
15287       rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
15288       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15289       if (rel_hdr->sh_size == 0)
15290         {
15291           /* It is too late to remove an empty reloc section.  Leave
15292              one NONE reloc.
15293              ??? What is wrong with an empty section???  */
15294           rel_hdr->sh_size = rel_hdr->sh_entsize;
15295           deleted -= 1;
15296         }
15297       rel_hdr = _bfd_elf_single_rel_hdr (input_section);
15298       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15299       input_section->reloc_count -= deleted;
15300     }
15301
15302   /* If we're emitting relocations, then shortly after this function
15303      returns, reloc offsets and addends for this section will be
15304      adjusted.  Worse, reloc symbol indices will be for the output
15305      file rather than the input.  Save a copy of the relocs for
15306      opd_entry_value.  */
15307   if (is_opd && (info->emitrelocations || bfd_link_relocatable (info)))
15308     {
15309       bfd_size_type amt;
15310       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
15311       rel = bfd_alloc (input_bfd, amt);
15312       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
15313       ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
15314       if (rel == NULL)
15315         return FALSE;
15316       memcpy (rel, relocs, amt);
15317     }
15318   return ret;
15319 }
15320
15321 /* Adjust the value of any local symbols in opd sections.  */
15322
15323 static int
15324 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
15325                               const char *name ATTRIBUTE_UNUSED,
15326                               Elf_Internal_Sym *elfsym,
15327                               asection *input_sec,
15328                               struct elf_link_hash_entry *h)
15329 {
15330   struct _opd_sec_data *opd;
15331   long adjust;
15332   bfd_vma value;
15333
15334   if (h != NULL)
15335     return 1;
15336
15337   opd = get_opd_info (input_sec);
15338   if (opd == NULL || opd->adjust == NULL)
15339     return 1;
15340
15341   value = elfsym->st_value - input_sec->output_offset;
15342   if (!bfd_link_relocatable (info))
15343     value -= input_sec->output_section->vma;
15344
15345   adjust = opd->adjust[OPD_NDX (value)];
15346   if (adjust == -1)
15347     return 2;
15348
15349   elfsym->st_value += adjust;
15350   return 1;
15351 }
15352
15353 /* Finish up dynamic symbol handling.  We set the contents of various
15354    dynamic sections here.  */
15355
15356 static bfd_boolean
15357 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
15358                                  struct bfd_link_info *info,
15359                                  struct elf_link_hash_entry *h,
15360                                  Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
15361 {
15362   struct ppc_link_hash_table *htab;
15363   struct plt_entry *ent;
15364   Elf_Internal_Rela rela;
15365   bfd_byte *loc;
15366
15367   htab = ppc_hash_table (info);
15368   if (htab == NULL)
15369     return FALSE;
15370
15371   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
15372     if (ent->plt.offset != (bfd_vma) -1)
15373       {
15374         /* This symbol has an entry in the procedure linkage
15375            table.  Set it up.  */
15376         if (!htab->elf.dynamic_sections_created
15377             || h->dynindx == -1)
15378           {
15379             BFD_ASSERT (h->type == STT_GNU_IFUNC
15380                         && h->def_regular
15381                         && (h->root.type == bfd_link_hash_defined
15382                             || h->root.type == bfd_link_hash_defweak));
15383             rela.r_offset = (htab->elf.iplt->output_section->vma
15384                              + htab->elf.iplt->output_offset
15385                              + ent->plt.offset);
15386             if (htab->opd_abi)
15387               rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
15388             else
15389               rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15390             rela.r_addend = (h->root.u.def.value
15391                              + h->root.u.def.section->output_offset
15392                              + h->root.u.def.section->output_section->vma
15393                              + ent->addend);
15394             loc = (htab->elf.irelplt->contents
15395                    + (htab->elf.irelplt->reloc_count++
15396                       * sizeof (Elf64_External_Rela)));
15397           }
15398         else
15399           {
15400             rela.r_offset = (htab->elf.splt->output_section->vma
15401                              + htab->elf.splt->output_offset
15402                              + ent->plt.offset);
15403             rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
15404             rela.r_addend = ent->addend;
15405             loc = (htab->elf.srelplt->contents
15406                    + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
15407                       / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
15408           }
15409         bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15410
15411         if (!htab->opd_abi)
15412           {
15413             if (!h->def_regular)
15414               {
15415                 /* Mark the symbol as undefined, rather than as
15416                    defined in glink.  Leave the value if there were
15417                    any relocations where pointer equality matters
15418                    (this is a clue for the dynamic linker, to make
15419                    function pointer comparisons work between an
15420                    application and shared library), otherwise set it
15421                    to zero.  */
15422                 sym->st_shndx = SHN_UNDEF;
15423                 if (!h->pointer_equality_needed)
15424                   sym->st_value = 0;
15425                 else if (!h->ref_regular_nonweak)
15426                   {
15427                     /* This breaks function pointer comparisons, but
15428                        that is better than breaking tests for a NULL
15429                        function pointer.  */
15430                     sym->st_value = 0;
15431                   }
15432               }
15433           }
15434       }
15435
15436   if (h->needs_copy)
15437     {
15438       /* This symbol needs a copy reloc.  Set it up.  */
15439
15440       if (h->dynindx == -1
15441           || (h->root.type != bfd_link_hash_defined
15442               && h->root.type != bfd_link_hash_defweak)
15443           || htab->relbss == NULL)
15444         abort ();
15445
15446       rela.r_offset = (h->root.u.def.value
15447                        + h->root.u.def.section->output_section->vma
15448                        + h->root.u.def.section->output_offset);
15449       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
15450       rela.r_addend = 0;
15451       loc = htab->relbss->contents;
15452       loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
15453       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15454     }
15455
15456   return TRUE;
15457 }
15458
15459 /* Used to decide how to sort relocs in an optimal manner for the
15460    dynamic linker, before writing them out.  */
15461
15462 static enum elf_reloc_type_class
15463 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
15464                             const asection *rel_sec,
15465                             const Elf_Internal_Rela *rela)
15466 {
15467   enum elf_ppc64_reloc_type r_type;
15468   struct ppc_link_hash_table *htab = ppc_hash_table (info);
15469
15470   if (rel_sec == htab->elf.irelplt)
15471     return reloc_class_ifunc;
15472
15473   r_type = ELF64_R_TYPE (rela->r_info);
15474   switch (r_type)
15475     {
15476     case R_PPC64_RELATIVE:
15477       return reloc_class_relative;
15478     case R_PPC64_JMP_SLOT:
15479       return reloc_class_plt;
15480     case R_PPC64_COPY:
15481       return reloc_class_copy;
15482     default:
15483       return reloc_class_normal;
15484     }
15485 }
15486
15487 /* Finish up the dynamic sections.  */
15488
15489 static bfd_boolean
15490 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
15491                                    struct bfd_link_info *info)
15492 {
15493   struct ppc_link_hash_table *htab;
15494   bfd *dynobj;
15495   asection *sdyn;
15496
15497   htab = ppc_hash_table (info);
15498   if (htab == NULL)
15499     return FALSE;
15500
15501   dynobj = htab->elf.dynobj;
15502   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
15503
15504   if (htab->elf.dynamic_sections_created)
15505     {
15506       Elf64_External_Dyn *dyncon, *dynconend;
15507
15508       if (sdyn == NULL || htab->elf.sgot == NULL)
15509         abort ();
15510
15511       dyncon = (Elf64_External_Dyn *) sdyn->contents;
15512       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
15513       for (; dyncon < dynconend; dyncon++)
15514         {
15515           Elf_Internal_Dyn dyn;
15516           asection *s;
15517
15518           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
15519
15520           switch (dyn.d_tag)
15521             {
15522             default:
15523               continue;
15524
15525             case DT_PPC64_GLINK:
15526               s = htab->glink;
15527               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15528               /* We stupidly defined DT_PPC64_GLINK to be the start
15529                  of glink rather than the first entry point, which is
15530                  what ld.so needs, and now have a bigger stub to
15531                  support automatic multiple TOCs.  */
15532               dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
15533               break;
15534
15535             case DT_PPC64_OPD:
15536               s = bfd_get_section_by_name (output_bfd, ".opd");
15537               if (s == NULL)
15538                 continue;
15539               dyn.d_un.d_ptr = s->vma;
15540               break;
15541
15542             case DT_PPC64_OPT:
15543               if (htab->do_multi_toc && htab->multi_toc_needed)
15544                 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
15545               break;
15546
15547             case DT_PPC64_OPDSZ:
15548               s = bfd_get_section_by_name (output_bfd, ".opd");
15549               if (s == NULL)
15550                 continue;
15551               dyn.d_un.d_val = s->size;
15552               break;
15553
15554             case DT_PLTGOT:
15555               s = htab->elf.splt;
15556               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15557               break;
15558
15559             case DT_JMPREL:
15560               s = htab->elf.srelplt;
15561               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15562               break;
15563
15564             case DT_PLTRELSZ:
15565               dyn.d_un.d_val = htab->elf.srelplt->size;
15566               break;
15567
15568             case DT_RELASZ:
15569               /* Don't count procedure linkage table relocs in the
15570                  overall reloc count.  */
15571               s = htab->elf.srelplt;
15572               if (s == NULL)
15573                 continue;
15574               dyn.d_un.d_val -= s->size;
15575               break;
15576
15577             case DT_RELA:
15578               /* We may not be using the standard ELF linker script.
15579                  If .rela.plt is the first .rela section, we adjust
15580                  DT_RELA to not include it.  */
15581               s = htab->elf.srelplt;
15582               if (s == NULL)
15583                 continue;
15584               if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
15585                 continue;
15586               dyn.d_un.d_ptr += s->size;
15587               break;
15588             }
15589
15590           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
15591         }
15592     }
15593
15594   if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0)
15595     {
15596       /* Fill in the first entry in the global offset table.
15597          We use it to hold the link-time TOCbase.  */
15598       bfd_put_64 (output_bfd,
15599                   elf_gp (output_bfd) + TOC_BASE_OFF,
15600                   htab->elf.sgot->contents);
15601
15602       /* Set .got entry size.  */
15603       elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
15604     }
15605
15606   if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
15607     {
15608       /* Set .plt entry size.  */
15609       elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
15610         = PLT_ENTRY_SIZE (htab);
15611     }
15612
15613   /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
15614      brlt ourselves if emitrelocations.  */
15615   if (htab->brlt != NULL
15616       && htab->brlt->reloc_count != 0
15617       && !_bfd_elf_link_output_relocs (output_bfd,
15618                                        htab->brlt,
15619                                        elf_section_data (htab->brlt)->rela.hdr,
15620                                        elf_section_data (htab->brlt)->relocs,
15621                                        NULL))
15622     return FALSE;
15623
15624   if (htab->glink != NULL
15625       && htab->glink->reloc_count != 0
15626       && !_bfd_elf_link_output_relocs (output_bfd,
15627                                        htab->glink,
15628                                        elf_section_data (htab->glink)->rela.hdr,
15629                                        elf_section_data (htab->glink)->relocs,
15630                                        NULL))
15631     return FALSE;
15632
15633   if (htab->glink_eh_frame != NULL
15634       && htab->glink_eh_frame->size != 0)
15635     {
15636       bfd_vma val;
15637       bfd_byte *p;
15638       asection *stub_sec;
15639
15640       p = htab->glink_eh_frame->contents + sizeof (glink_eh_frame_cie);
15641       for (stub_sec = htab->params->stub_bfd->sections;
15642            stub_sec != NULL;
15643            stub_sec = stub_sec->next)
15644         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
15645           {
15646             /* FDE length.  */
15647             p += 4;
15648             /* CIE pointer.  */
15649             p += 4;
15650             /* Offset to stub section.  */
15651             val = (stub_sec->output_section->vma
15652                    + stub_sec->output_offset);
15653             val -= (htab->glink_eh_frame->output_section->vma
15654                     + htab->glink_eh_frame->output_offset
15655                     + (p - htab->glink_eh_frame->contents));
15656             if (val + 0x80000000 > 0xffffffff)
15657               {
15658                 info->callbacks->einfo
15659                   (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15660                    stub_sec->name);
15661                 return FALSE;
15662               }
15663             bfd_put_32 (dynobj, val, p);
15664             p += 4;
15665             /* stub section size.  */
15666             p += 4;
15667             /* Augmentation.  */
15668             p += 1;
15669             /* Pad.  */
15670             p += 7;
15671           }
15672       if (htab->glink != NULL && htab->glink->size != 0)
15673         {
15674           /* FDE length.  */
15675           p += 4;
15676           /* CIE pointer.  */
15677           p += 4;
15678           /* Offset to .glink.  */
15679           val = (htab->glink->output_section->vma
15680                  + htab->glink->output_offset
15681                  + 8);
15682           val -= (htab->glink_eh_frame->output_section->vma
15683                   + htab->glink_eh_frame->output_offset
15684                   + (p - htab->glink_eh_frame->contents));
15685           if (val + 0x80000000 > 0xffffffff)
15686             {
15687               info->callbacks->einfo
15688                 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15689                  htab->glink->name);
15690               return FALSE;
15691             }
15692           bfd_put_32 (dynobj, val, p);
15693           p += 4;
15694           /* .glink size.  */
15695           p += 4;
15696           /* Augmentation.  */
15697           p += 1;
15698           /* Ops.  */
15699           p += 7;
15700         }
15701
15702       if (htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
15703           && !_bfd_elf_write_section_eh_frame (output_bfd, info,
15704                                                htab->glink_eh_frame,
15705                                                htab->glink_eh_frame->contents))
15706         return FALSE;
15707     }
15708
15709   /* We need to handle writing out multiple GOT sections ourselves,
15710      since we didn't add them to DYNOBJ.  We know dynobj is the first
15711      bfd.  */
15712   while ((dynobj = dynobj->link.next) != NULL)
15713     {
15714       asection *s;
15715
15716       if (!is_ppc64_elf (dynobj))
15717         continue;
15718
15719       s = ppc64_elf_tdata (dynobj)->got;
15720       if (s != NULL
15721           && s->size != 0
15722           && s->output_section != bfd_abs_section_ptr
15723           && !bfd_set_section_contents (output_bfd, s->output_section,
15724                                         s->contents, s->output_offset,
15725                                         s->size))
15726         return FALSE;
15727       s = ppc64_elf_tdata (dynobj)->relgot;
15728       if (s != NULL
15729           && s->size != 0
15730           && s->output_section != bfd_abs_section_ptr
15731           && !bfd_set_section_contents (output_bfd, s->output_section,
15732                                         s->contents, s->output_offset,
15733                                         s->size))
15734         return FALSE;
15735     }
15736
15737   return TRUE;
15738 }
15739
15740 #include "elf64-target.h"
15741
15742 /* FreeBSD support */
15743
15744 #undef  TARGET_LITTLE_SYM
15745 #undef  TARGET_LITTLE_NAME
15746
15747 #undef  TARGET_BIG_SYM
15748 #define TARGET_BIG_SYM  powerpc_elf64_fbsd_vec
15749 #undef  TARGET_BIG_NAME
15750 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15751
15752 #undef  ELF_OSABI
15753 #define ELF_OSABI       ELFOSABI_FREEBSD
15754
15755 #undef  elf64_bed
15756 #define elf64_bed       elf64_powerpc_fbsd_bed
15757
15758 #include "elf64-target.h"
15759