bfd/elf64-ppc.c

   1 /* PowerPC64-specific support for 64-bit ELF.
   2    Copyright (C) 1999-2016 Free Software Foundation, Inc.
   3    Written by Linus Nordberg, Swox AB <info@swox.com>,
   4    based on elf32-ppc.c by Ian Lance Taylor.
   5    Largely rewritten by Alan Modra.
   6
   7    This file is part of BFD, the Binary File Descriptor library.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License along
  20    with this program; if not, write to the Free Software Foundation, Inc.,
  21    51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
  22
  23
  24 /* The 64-bit PowerPC ELF ABI may be found at
  25    http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and
  26    http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html  */
  27
  28 #include "sysdep.h"
  29 #include <stdarg.h>
  30 #include "bfd.h"
  31 #include "bfdlink.h"
  32 #include "libbfd.h"
  33 #include "elf-bfd.h"
  34 #include "elf/ppc64.h"
  35 #include "elf64-ppc.h"
  36 #include "dwarf2.h"
  37
  38 static bfd_reloc_status_type ppc64_elf_ha_reloc
  39   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  40 static bfd_reloc_status_type ppc64_elf_branch_reloc
  41   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  42 static bfd_reloc_status_type ppc64_elf_brtaken_reloc
  43   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  44 static bfd_reloc_status_type ppc64_elf_sectoff_reloc
  45   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  46 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
  47   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  48 static bfd_reloc_status_type ppc64_elf_toc_reloc
  49   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  50 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
  51   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  52 static bfd_reloc_status_type ppc64_elf_toc64_reloc
  53   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  54 static bfd_reloc_status_type ppc64_elf_unhandled_reloc
  55   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  56 static bfd_vma opd_entry_value
  57   (asection *, bfd_vma, asection **, bfd_vma *, bfd_boolean);
  58
  59 #define TARGET_LITTLE_SYM       powerpc_elf64_le_vec
  60 #define TARGET_LITTLE_NAME      "elf64-powerpcle"
  61 #define TARGET_BIG_SYM          powerpc_elf64_vec
  62 #define TARGET_BIG_NAME         "elf64-powerpc"
  63 #define ELF_ARCH                bfd_arch_powerpc
  64 #define ELF_TARGET_ID           PPC64_ELF_DATA
  65 #define ELF_MACHINE_CODE        EM_PPC64
  66 #define ELF_MAXPAGESIZE         0x10000
  67 #define ELF_COMMONPAGESIZE      0x10000
  68 #define elf_info_to_howto       ppc64_elf_info_to_howto
  69
  70 #define elf_backend_want_got_sym 0
  71 #define elf_backend_want_plt_sym 0
  72 #define elf_backend_plt_alignment 3
  73 #define elf_backend_plt_not_loaded 1
  74 #define elf_backend_got_header_size 8
  75 #define elf_backend_can_gc_sections 1
  76 #define elf_backend_can_refcount 1
  77 #define elf_backend_rela_normal 1
  78 #define elf_backend_default_execstack 0
  79
  80 #define bfd_elf64_mkobject                    ppc64_elf_mkobject
  81 #define bfd_elf64_bfd_reloc_type_lookup       ppc64_elf_reloc_type_lookup
  82 #define bfd_elf64_bfd_reloc_name_lookup       ppc64_elf_reloc_name_lookup
  83 #define bfd_elf64_bfd_merge_private_bfd_data  ppc64_elf_merge_private_bfd_data
  84 #define bfd_elf64_bfd_print_private_bfd_data  ppc64_elf_print_private_bfd_data
  85 #define bfd_elf64_new_section_hook            ppc64_elf_new_section_hook
  86 #define bfd_elf64_bfd_link_hash_table_create  ppc64_elf_link_hash_table_create
  87 #define bfd_elf64_get_synthetic_symtab        ppc64_elf_get_synthetic_symtab
  88 #define bfd_elf64_bfd_link_just_syms          ppc64_elf_link_just_syms
  89
  90 #define elf_backend_object_p                  ppc64_elf_object_p
  91 #define elf_backend_grok_prstatus             ppc64_elf_grok_prstatus
  92 #define elf_backend_grok_psinfo               ppc64_elf_grok_psinfo
  93 #define elf_backend_write_core_note           ppc64_elf_write_core_note
  94 #define elf_backend_create_dynamic_sections   ppc64_elf_create_dynamic_sections
  95 #define elf_backend_copy_indirect_symbol      ppc64_elf_copy_indirect_symbol
  96 #define elf_backend_add_symbol_hook           ppc64_elf_add_symbol_hook
  97 #define elf_backend_check_directives          ppc64_elf_before_check_relocs
  98 #define elf_backend_notice_as_needed          ppc64_elf_notice_as_needed
  99 #define elf_backend_archive_symbol_lookup     ppc64_elf_archive_symbol_lookup
 100 #define elf_backend_check_relocs              ppc64_elf_check_relocs
 101 #define elf_backend_gc_keep                   ppc64_elf_gc_keep
 102 #define elf_backend_gc_mark_dynamic_ref       ppc64_elf_gc_mark_dynamic_ref
 103 #define elf_backend_gc_mark_hook              ppc64_elf_gc_mark_hook
 104 #define elf_backend_gc_sweep_hook             ppc64_elf_gc_sweep_hook
 105 #define elf_backend_adjust_dynamic_symbol     ppc64_elf_adjust_dynamic_symbol
 106 #define elf_backend_hide_symbol               ppc64_elf_hide_symbol
 107 #define elf_backend_maybe_function_sym        ppc64_elf_maybe_function_sym
 108 #define elf_backend_always_size_sections      ppc64_elf_func_desc_adjust
 109 #define elf_backend_size_dynamic_sections     ppc64_elf_size_dynamic_sections
 110 #define elf_backend_hash_symbol               ppc64_elf_hash_symbol
 111 #define elf_backend_init_index_section        _bfd_elf_init_2_index_sections
 112 #define elf_backend_action_discarded          ppc64_elf_action_discarded
 113 #define elf_backend_relocate_section          ppc64_elf_relocate_section
 114 #define elf_backend_finish_dynamic_symbol     ppc64_elf_finish_dynamic_symbol
 115 #define elf_backend_reloc_type_class          ppc64_elf_reloc_type_class
 116 #define elf_backend_finish_dynamic_sections   ppc64_elf_finish_dynamic_sections
 117 #define elf_backend_link_output_symbol_hook   ppc64_elf_output_symbol_hook
 118 #define elf_backend_special_sections          ppc64_elf_special_sections
 119 #define elf_backend_merge_symbol_attribute    ppc64_elf_merge_symbol_attribute
 120
 121 /* The name of the dynamic interpreter.  This is put in the .interp
 122    section.  */
 123 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
 124
 125 /* The size in bytes of an entry in the procedure linkage table.  */
 126 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
 127
 128 /* The initial size of the plt reserved for the dynamic linker.  */
 129 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
 130
 131 /* Offsets to some stack save slots.  */
 132 #define STK_LR 16
 133 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
 134 /* This one is dodgy.  ELFv2 does not have a linker word, so use the
 135    CR save slot.  Used only by optimised __tls_get_addr call stub,
 136    relying on __tls_get_addr_opt not saving CR..  */
 137 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
 138
 139 /* TOC base pointers offset from start of TOC.  */
 140 #define TOC_BASE_OFF    0x8000
 141 /* TOC base alignment.  */
 142 #define TOC_BASE_ALIGN  256
 143
 144 /* Offset of tp and dtp pointers from start of TLS block.  */
 145 #define TP_OFFSET       0x7000
 146 #define DTP_OFFSET      0x8000
 147
 148 /* .plt call stub instructions.  The normal stub is like this, but
 149    sometimes the .plt entry crosses a 64k boundary and we need to
 150    insert an addi to adjust r11.  */
 151 #define STD_R2_0R1      0xf8410000      /* std   %r2,0+40(%r1)       */
 152 #define ADDIS_R11_R2    0x3d620000      /* addis %r11,%r2,xxx@ha     */
 153 #define LD_R12_0R11     0xe98b0000      /* ld    %r12,xxx+0@l(%r11)  */
 154 #define MTCTR_R12       0x7d8903a6      /* mtctr %r12                */
 155 #define LD_R2_0R11      0xe84b0000      /* ld    %r2,xxx+8@l(%r11)   */
 156 #define LD_R11_0R11     0xe96b0000      /* ld    %r11,xxx+16@l(%r11) */
 157 #define BCTR            0x4e800420      /* bctr                      */
 158
 159 #define ADDI_R11_R11    0x396b0000      /* addi %r11,%r11,off@l  */
 160 #define ADDIS_R2_R2     0x3c420000      /* addis %r2,%r2,off@ha  */
 161 #define ADDI_R2_R2      0x38420000      /* addi  %r2,%r2,off@l   */
 162
 163 #define XOR_R2_R12_R12  0x7d826278      /* xor   %r2,%r12,%r12   */
 164 #define ADD_R11_R11_R2  0x7d6b1214      /* add   %r11,%r11,%r2   */
 165 #define XOR_R11_R12_R12 0x7d8b6278      /* xor   %r11,%r12,%r12  */
 166 #define ADD_R2_R2_R11   0x7c425a14      /* add   %r2,%r2,%r11    */
 167 #define CMPLDI_R2_0     0x28220000      /* cmpldi %r2,0          */
 168 #define BNECTR          0x4ca20420      /* bnectr+               */
 169 #define BNECTR_P4       0x4ce20420      /* bnectr+               */
 170
 171 #define LD_R12_0R2      0xe9820000      /* ld    %r12,xxx+0(%r2) */
 172 #define LD_R11_0R2      0xe9620000      /* ld    %r11,xxx+0(%r2) */
 173 #define LD_R2_0R2       0xe8420000      /* ld    %r2,xxx+0(%r2)  */
 174
 175 #define LD_R2_0R1       0xe8410000      /* ld    %r2,0(%r1)      */
 176 #define LD_R2_0R12      0xe84c0000      /* ld    %r2,0(%r12)     */
 177 #define ADD_R2_R2_R12   0x7c426214      /* add   %r2,%r2,%r12    */
 178
 179 #define LIS_R2          0x3c400000      /* lis %r2,xxx@ha         */
 180 #define ADDIS_R2_R12    0x3c4c0000      /* addis %r2,%r12,xxx@ha  */
 181 #define ADDIS_R12_R2    0x3d820000      /* addis %r12,%r2,xxx@ha  */
 182 #define ADDIS_R12_R12   0x3d8c0000      /* addis %r12,%r12,xxx@ha */
 183 #define LD_R12_0R12     0xe98c0000      /* ld    %r12,xxx@l(%r12) */
 184
 185 /* glink call stub instructions.  We enter with the index in R0.  */
 186 #define GLINK_CALL_STUB_SIZE (16*4)
 187                                         /* 0:                           */
 188                                         /*  .quad plt0-1f               */
 189                                         /* __glink:                     */
 190 #define MFLR_R12        0x7d8802a6      /*  mflr %12                    */
 191 #define BCL_20_31       0x429f0005      /*  bcl 20,31,1f                */
 192                                         /* 1:                           */
 193 #define MFLR_R11        0x7d6802a6      /*  mflr %11                    */
 194                                         /*  ld %2,(0b-1b)(%11)          */
 195 #define MTLR_R12        0x7d8803a6      /*  mtlr %12                    */
 196 #define ADD_R11_R2_R11  0x7d625a14      /*  add %11,%2,%11              */
 197                                         /*  ld %12,0(%11)               */
 198                                         /*  ld %2,8(%11)                */
 199                                         /*  mtctr %12                   */
 200                                         /*  ld %11,16(%11)              */
 201                                         /*  bctr                        */
 202 #define MFLR_R0         0x7c0802a6      /*  mflr %r0                    */
 203 #define MTLR_R0         0x7c0803a6      /*  mtlr %r0                    */
 204 #define SUB_R12_R12_R11 0x7d8b6050      /*  subf %r12,%r11,%r12         */
 205 #define ADDI_R0_R12     0x380c0000      /*  addi %r0,%r12,0             */
 206 #define SRDI_R0_R0_2    0x7800f082      /*  rldicl %r0,%r0,62,2         */
 207
 208 /* Pad with this.  */
 209 #define NOP             0x60000000
 210
 211 /* Some other nops.  */
 212 #define CROR_151515     0x4def7b82
 213 #define CROR_313131     0x4ffffb82
 214
 215 /* .glink entries for the first 32k functions are two instructions.  */
 216 #define LI_R0_0         0x38000000      /* li    %r0,0          */
 217 #define B_DOT           0x48000000      /* b     .              */
 218
 219 /* After that, we need two instructions to load the index, followed by
 220    a branch.  */
 221 #define LIS_R0_0        0x3c000000      /* lis   %r0,0          */
 222 #define ORI_R0_R0_0     0x60000000      /* ori   %r0,%r0,0      */
 223
 224 /* Instructions used by the save and restore reg functions.  */
 225 #define STD_R0_0R1      0xf8010000      /* std   %r0,0(%r1)     */
 226 #define STD_R0_0R12     0xf80c0000      /* std   %r0,0(%r12)    */
 227 #define LD_R0_0R1       0xe8010000      /* ld    %r0,0(%r1)     */
 228 #define LD_R0_0R12      0xe80c0000      /* ld    %r0,0(%r12)    */
 229 #define STFD_FR0_0R1    0xd8010000      /* stfd  %fr0,0(%r1)    */
 230 #define LFD_FR0_0R1     0xc8010000      /* lfd   %fr0,0(%r1)    */
 231 #define LI_R12_0        0x39800000      /* li    %r12,0         */
 232 #define STVX_VR0_R12_R0 0x7c0c01ce      /* stvx  %v0,%r12,%r0   */
 233 #define LVX_VR0_R12_R0  0x7c0c00ce      /* lvx   %v0,%r12,%r0   */
 234 #define MTLR_R0         0x7c0803a6      /* mtlr  %r0            */
 235 #define BLR             0x4e800020      /* blr                  */
 236
 237 /* Since .opd is an array of descriptors and each entry will end up
 238    with identical R_PPC64_RELATIVE relocs, there is really no need to
 239    propagate .opd relocs;  The dynamic linker should be taught to
 240    relocate .opd without reloc entries.  */
 241 #ifndef NO_OPD_RELOCS
 242 #define NO_OPD_RELOCS 0
 243 #endif
 244
 245 #ifndef ARRAY_SIZE
 246 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
 247 #endif
 248
 249 static inline int
 250 abiversion (bfd *abfd)
 251 {
 252   return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
 253 }
 254
 255 static inline void
 256 set_abiversion (bfd *abfd, int ver)
 257 {
 258   elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
 259   elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
 260 }
 261 \f
 262 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
 263
 264 /* Relocation HOWTO's.  */
 265 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
 266
 267 static reloc_howto_type ppc64_elf_howto_raw[] = {
 268   /* This reloc does nothing.  */
 269   HOWTO (R_PPC64_NONE,          /* type */
 270          0,                     /* rightshift */
 271          3,                     /* size (0 = byte, 1 = short, 2 = long) */
 272          0,                     /* bitsize */
 273          FALSE,                 /* pc_relative */
 274          0,                     /* bitpos */
 275          complain_overflow_dont, /* complain_on_overflow */
 276          bfd_elf_generic_reloc, /* special_function */
 277          "R_PPC64_NONE",        /* name */
 278          FALSE,                 /* partial_inplace */
 279          0,                     /* src_mask */
 280          0,                     /* dst_mask */
 281          FALSE),                /* pcrel_offset */
 282
 283   /* A standard 32 bit relocation.  */
 284   HOWTO (R_PPC64_ADDR32,        /* type */
 285          0,                     /* rightshift */
 286          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 287          32,                    /* bitsize */
 288          FALSE,                 /* pc_relative */
 289          0,                     /* bitpos */
 290          complain_overflow_bitfield, /* complain_on_overflow */
 291          bfd_elf_generic_reloc, /* special_function */
 292          "R_PPC64_ADDR32",      /* name */
 293          FALSE,                 /* partial_inplace */
 294          0,                     /* src_mask */
 295          0xffffffff,            /* dst_mask */
 296          FALSE),                /* pcrel_offset */
 297
 298   /* An absolute 26 bit branch; the lower two bits must be zero.
 299      FIXME: we don't check that, we just clear them.  */
 300   HOWTO (R_PPC64_ADDR24,        /* type */
 301          0,                     /* rightshift */
 302          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 303          26,                    /* bitsize */
 304          FALSE,                 /* pc_relative */
 305          0,                     /* bitpos */
 306          complain_overflow_bitfield, /* complain_on_overflow */
 307          bfd_elf_generic_reloc, /* special_function */
 308          "R_PPC64_ADDR24",      /* name */
 309          FALSE,                 /* partial_inplace */
 310          0,                     /* src_mask */
 311          0x03fffffc,            /* dst_mask */
 312          FALSE),                /* pcrel_offset */
 313
 314   /* A standard 16 bit relocation.  */
 315   HOWTO (R_PPC64_ADDR16,        /* type */
 316          0,                     /* rightshift */
 317          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 318          16,                    /* bitsize */
 319          FALSE,                 /* pc_relative */
 320          0,                     /* bitpos */
 321          complain_overflow_bitfield, /* complain_on_overflow */
 322          bfd_elf_generic_reloc, /* special_function */
 323          "R_PPC64_ADDR16",      /* name */
 324          FALSE,                 /* partial_inplace */
 325          0,                     /* src_mask */
 326          0xffff,                /* dst_mask */
 327          FALSE),                /* pcrel_offset */
 328
 329   /* A 16 bit relocation without overflow.  */
 330   HOWTO (R_PPC64_ADDR16_LO,     /* type */
 331          0,                     /* rightshift */
 332          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 333          16,                    /* bitsize */
 334          FALSE,                 /* pc_relative */
 335          0,                     /* bitpos */
 336          complain_overflow_dont,/* complain_on_overflow */
 337          bfd_elf_generic_reloc, /* special_function */
 338          "R_PPC64_ADDR16_LO",   /* name */
 339          FALSE,                 /* partial_inplace */
 340          0,                     /* src_mask */
 341          0xffff,                /* dst_mask */
 342          FALSE),                /* pcrel_offset */
 343
 344   /* Bits 16-31 of an address.  */
 345   HOWTO (R_PPC64_ADDR16_HI,     /* type */
 346          16,                    /* rightshift */
 347          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 348          16,                    /* bitsize */
 349          FALSE,                 /* pc_relative */
 350          0,                     /* bitpos */
 351          complain_overflow_signed, /* complain_on_overflow */
 352          bfd_elf_generic_reloc, /* special_function */
 353          "R_PPC64_ADDR16_HI",   /* name */
 354          FALSE,                 /* partial_inplace */
 355          0,                     /* src_mask */
 356          0xffff,                /* dst_mask */
 357          FALSE),                /* pcrel_offset */
 358
 359   /* Bits 16-31 of an address, plus 1 if the contents of the low 16
 360      bits, treated as a signed number, is negative.  */
 361   HOWTO (R_PPC64_ADDR16_HA,     /* type */
 362          16,                    /* rightshift */
 363          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 364          16,                    /* bitsize */
 365          FALSE,                 /* pc_relative */
 366          0,                     /* bitpos */
 367          complain_overflow_signed, /* complain_on_overflow */
 368          ppc64_elf_ha_reloc,    /* special_function */
 369          "R_PPC64_ADDR16_HA",   /* name */
 370          FALSE,                 /* partial_inplace */
 371          0,                     /* src_mask */
 372          0xffff,                /* dst_mask */
 373          FALSE),                /* pcrel_offset */
 374
 375   /* An absolute 16 bit branch; the lower two bits must be zero.
 376      FIXME: we don't check that, we just clear them.  */
 377   HOWTO (R_PPC64_ADDR14,        /* type */
 378          0,                     /* rightshift */
 379          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 380          16,                    /* bitsize */
 381          FALSE,                 /* pc_relative */
 382          0,                     /* bitpos */
 383          complain_overflow_signed, /* complain_on_overflow */
 384          ppc64_elf_branch_reloc, /* special_function */
 385          "R_PPC64_ADDR14",      /* name */
 386          FALSE,                 /* partial_inplace */
 387          0,                     /* src_mask */
 388          0x0000fffc,            /* dst_mask */
 389          FALSE),                /* pcrel_offset */
 390
 391   /* An absolute 16 bit branch, for which bit 10 should be set to
 392      indicate that the branch is expected to be taken.  The lower two
 393      bits must be zero.  */
 394   HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
 395          0,                     /* rightshift */
 396          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 397          16,                    /* bitsize */
 398          FALSE,                 /* pc_relative */
 399          0,                     /* bitpos */
 400          complain_overflow_signed, /* complain_on_overflow */
 401          ppc64_elf_brtaken_reloc, /* special_function */
 402          "R_PPC64_ADDR14_BRTAKEN",/* name */
 403          FALSE,                 /* partial_inplace */
 404          0,                     /* src_mask */
 405          0x0000fffc,            /* dst_mask */
 406          FALSE),                /* pcrel_offset */
 407
 408   /* An absolute 16 bit branch, for which bit 10 should be set to
 409      indicate that the branch is not expected to be taken.  The lower
 410      two bits must be zero.  */
 411   HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
 412          0,                     /* rightshift */
 413          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 414          16,                    /* bitsize */
 415          FALSE,                 /* pc_relative */
 416          0,                     /* bitpos */
 417          complain_overflow_signed, /* complain_on_overflow */
 418          ppc64_elf_brtaken_reloc, /* special_function */
 419          "R_PPC64_ADDR14_BRNTAKEN",/* name */
 420          FALSE,                 /* partial_inplace */
 421          0,                     /* src_mask */
 422          0x0000fffc,            /* dst_mask */
 423          FALSE),                /* pcrel_offset */
 424
 425   /* A relative 26 bit branch; the lower two bits must be zero.  */
 426   HOWTO (R_PPC64_REL24,         /* type */
 427          0,                     /* rightshift */
 428          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 429          26,                    /* bitsize */
 430          TRUE,                  /* pc_relative */
 431          0,                     /* bitpos */
 432          complain_overflow_signed, /* complain_on_overflow */
 433          ppc64_elf_branch_reloc, /* special_function */
 434          "R_PPC64_REL24",       /* name */
 435          FALSE,                 /* partial_inplace */
 436          0,                     /* src_mask */
 437          0x03fffffc,            /* dst_mask */
 438          TRUE),                 /* pcrel_offset */
 439
 440   /* A relative 16 bit branch; the lower two bits must be zero.  */
 441   HOWTO (R_PPC64_REL14,         /* type */
 442          0,                     /* rightshift */
 443          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 444          16,                    /* bitsize */
 445          TRUE,                  /* pc_relative */
 446          0,                     /* bitpos */
 447          complain_overflow_signed, /* complain_on_overflow */
 448          ppc64_elf_branch_reloc, /* special_function */
 449          "R_PPC64_REL14",       /* name */
 450          FALSE,                 /* partial_inplace */
 451          0,                     /* src_mask */
 452          0x0000fffc,            /* dst_mask */
 453          TRUE),                 /* pcrel_offset */
 454
 455   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 456      the branch is expected to be taken.  The lower two bits must be
 457      zero.  */
 458   HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
 459          0,                     /* rightshift */
 460          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 461          16,                    /* bitsize */
 462          TRUE,                  /* pc_relative */
 463          0,                     /* bitpos */
 464          complain_overflow_signed, /* complain_on_overflow */
 465          ppc64_elf_brtaken_reloc, /* special_function */
 466          "R_PPC64_REL14_BRTAKEN", /* name */
 467          FALSE,                 /* partial_inplace */
 468          0,                     /* src_mask */
 469          0x0000fffc,            /* dst_mask */
 470          TRUE),                 /* pcrel_offset */
 471
 472   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 473      the branch is not expected to be taken.  The lower two bits must
 474      be zero.  */
 475   HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
 476          0,                     /* rightshift */
 477          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 478          16,                    /* bitsize */
 479          TRUE,                  /* pc_relative */
 480          0,                     /* bitpos */
 481          complain_overflow_signed, /* complain_on_overflow */
 482          ppc64_elf_brtaken_reloc, /* special_function */
 483          "R_PPC64_REL14_BRNTAKEN",/* name */
 484          FALSE,                 /* partial_inplace */
 485          0,                     /* src_mask */
 486          0x0000fffc,            /* dst_mask */
 487          TRUE),                 /* pcrel_offset */
 488
 489   /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
 490      symbol.  */
 491   HOWTO (R_PPC64_GOT16,         /* type */
 492          0,                     /* rightshift */
 493          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 494          16,                    /* bitsize */
 495          FALSE,                 /* pc_relative */
 496          0,                     /* bitpos */
 497          complain_overflow_signed, /* complain_on_overflow */
 498          ppc64_elf_unhandled_reloc, /* special_function */
 499          "R_PPC64_GOT16",       /* name */
 500          FALSE,                 /* partial_inplace */
 501          0,                     /* src_mask */
 502          0xffff,                /* dst_mask */
 503          FALSE),                /* pcrel_offset */
 504
 505   /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
 506      the symbol.  */
 507   HOWTO (R_PPC64_GOT16_LO,      /* type */
 508          0,                     /* rightshift */
 509          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 510          16,                    /* bitsize */
 511          FALSE,                 /* pc_relative */
 512          0,                     /* bitpos */
 513          complain_overflow_dont, /* complain_on_overflow */
 514          ppc64_elf_unhandled_reloc, /* special_function */
 515          "R_PPC64_GOT16_LO",    /* name */
 516          FALSE,                 /* partial_inplace */
 517          0,                     /* src_mask */
 518          0xffff,                /* dst_mask */
 519          FALSE),                /* pcrel_offset */
 520
 521   /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
 522      the symbol.  */
 523   HOWTO (R_PPC64_GOT16_HI,      /* type */
 524          16,                    /* rightshift */
 525          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 526          16,                    /* bitsize */
 527          FALSE,                 /* pc_relative */
 528          0,                     /* bitpos */
 529          complain_overflow_signed,/* complain_on_overflow */
 530          ppc64_elf_unhandled_reloc, /* special_function */
 531          "R_PPC64_GOT16_HI",    /* name */
 532          FALSE,                 /* partial_inplace */
 533          0,                     /* src_mask */
 534          0xffff,                /* dst_mask */
 535          FALSE),                /* pcrel_offset */
 536
 537   /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
 538      the symbol.  */
 539   HOWTO (R_PPC64_GOT16_HA,      /* type */
 540          16,                    /* rightshift */
 541          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 542          16,                    /* bitsize */
 543          FALSE,                 /* pc_relative */
 544          0,                     /* bitpos */
 545          complain_overflow_signed,/* complain_on_overflow */
 546          ppc64_elf_unhandled_reloc, /* special_function */
 547          "R_PPC64_GOT16_HA",    /* name */
 548          FALSE,                 /* partial_inplace */
 549          0,                     /* src_mask */
 550          0xffff,                /* dst_mask */
 551          FALSE),                /* pcrel_offset */
 552
 553   /* This is used only by the dynamic linker.  The symbol should exist
 554      both in the object being run and in some shared library.  The
 555      dynamic linker copies the data addressed by the symbol from the
 556      shared library into the object, because the object being
 557      run has to have the data at some particular address.  */
 558   HOWTO (R_PPC64_COPY,          /* type */
 559          0,                     /* rightshift */
 560          0,                     /* this one is variable size */
 561          0,                     /* bitsize */
 562          FALSE,                 /* pc_relative */
 563          0,                     /* bitpos */
 564          complain_overflow_dont, /* complain_on_overflow */
 565          ppc64_elf_unhandled_reloc, /* special_function */
 566          "R_PPC64_COPY",        /* name */
 567          FALSE,                 /* partial_inplace */
 568          0,                     /* src_mask */
 569          0,                     /* dst_mask */
 570          FALSE),                /* pcrel_offset */
 571
 572   /* Like R_PPC64_ADDR64, but used when setting global offset table
 573      entries.  */
 574   HOWTO (R_PPC64_GLOB_DAT,      /* type */
 575          0,                     /* rightshift */
 576          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 577          64,                    /* bitsize */
 578          FALSE,                 /* pc_relative */
 579          0,                     /* bitpos */
 580          complain_overflow_dont, /* complain_on_overflow */
 581          ppc64_elf_unhandled_reloc,  /* special_function */
 582          "R_PPC64_GLOB_DAT",    /* name */
 583          FALSE,                 /* partial_inplace */
 584          0,                     /* src_mask */
 585          ONES (64),             /* dst_mask */
 586          FALSE),                /* pcrel_offset */
 587
 588   /* Created by the link editor.  Marks a procedure linkage table
 589      entry for a symbol.  */
 590   HOWTO (R_PPC64_JMP_SLOT,      /* type */
 591          0,                     /* rightshift */
 592          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 593          0,                     /* bitsize */
 594          FALSE,                 /* pc_relative */
 595          0,                     /* bitpos */
 596          complain_overflow_dont, /* complain_on_overflow */
 597          ppc64_elf_unhandled_reloc, /* special_function */
 598          "R_PPC64_JMP_SLOT",    /* name */
 599          FALSE,                 /* partial_inplace */
 600          0,                     /* src_mask */
 601          0,                     /* dst_mask */
 602          FALSE),                /* pcrel_offset */
 603
 604   /* Used only by the dynamic linker.  When the object is run, this
 605      doubleword64 is set to the load address of the object, plus the
 606      addend.  */
 607   HOWTO (R_PPC64_RELATIVE,      /* type */
 608          0,                     /* rightshift */
 609          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 610          64,                    /* bitsize */
 611          FALSE,                 /* pc_relative */
 612          0,                     /* bitpos */
 613          complain_overflow_dont, /* complain_on_overflow */
 614          bfd_elf_generic_reloc, /* special_function */
 615          "R_PPC64_RELATIVE",    /* name */
 616          FALSE,                 /* partial_inplace */
 617          0,                     /* src_mask */
 618          ONES (64),             /* dst_mask */
 619          FALSE),                /* pcrel_offset */
 620
 621   /* Like R_PPC64_ADDR32, but may be unaligned.  */
 622   HOWTO (R_PPC64_UADDR32,       /* type */
 623          0,                     /* rightshift */
 624          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 625          32,                    /* bitsize */
 626          FALSE,                 /* pc_relative */
 627          0,                     /* bitpos */
 628          complain_overflow_bitfield, /* complain_on_overflow */
 629          bfd_elf_generic_reloc, /* special_function */
 630          "R_PPC64_UADDR32",     /* name */
 631          FALSE,                 /* partial_inplace */
 632          0,                     /* src_mask */
 633          0xffffffff,            /* dst_mask */
 634          FALSE),                /* pcrel_offset */
 635
 636   /* Like R_PPC64_ADDR16, but may be unaligned.  */
 637   HOWTO (R_PPC64_UADDR16,       /* type */
 638          0,                     /* rightshift */
 639          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 640          16,                    /* bitsize */
 641          FALSE,                 /* pc_relative */
 642          0,                     /* bitpos */
 643          complain_overflow_bitfield, /* complain_on_overflow */
 644          bfd_elf_generic_reloc, /* special_function */
 645          "R_PPC64_UADDR16",     /* name */
 646          FALSE,                 /* partial_inplace */
 647          0,                     /* src_mask */
 648          0xffff,                /* dst_mask */
 649          FALSE),                /* pcrel_offset */
 650
 651   /* 32-bit PC relative.  */
 652   HOWTO (R_PPC64_REL32,         /* type */
 653          0,                     /* rightshift */
 654          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 655          32,                    /* bitsize */
 656          TRUE,                  /* pc_relative */
 657          0,                     /* bitpos */
 658          complain_overflow_signed, /* complain_on_overflow */
 659          bfd_elf_generic_reloc, /* special_function */
 660          "R_PPC64_REL32",       /* name */
 661          FALSE,                 /* partial_inplace */
 662          0,                     /* src_mask */
 663          0xffffffff,            /* dst_mask */
 664          TRUE),                 /* pcrel_offset */
 665
 666   /* 32-bit relocation to the symbol's procedure linkage table.  */
 667   HOWTO (R_PPC64_PLT32,         /* type */
 668          0,                     /* rightshift */
 669          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 670          32,                    /* bitsize */
 671          FALSE,                 /* pc_relative */
 672          0,                     /* bitpos */
 673          complain_overflow_bitfield, /* complain_on_overflow */
 674          ppc64_elf_unhandled_reloc, /* special_function */
 675          "R_PPC64_PLT32",       /* name */
 676          FALSE,                 /* partial_inplace */
 677          0,                     /* src_mask */
 678          0xffffffff,            /* dst_mask */
 679          FALSE),                /* pcrel_offset */
 680
 681   /* 32-bit PC relative relocation to the symbol's procedure linkage table.
 682      FIXME: R_PPC64_PLTREL32 not supported.  */
 683   HOWTO (R_PPC64_PLTREL32,      /* type */
 684          0,                     /* rightshift */
 685          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 686          32,                    /* bitsize */
 687          TRUE,                  /* pc_relative */
 688          0,                     /* bitpos */
 689          complain_overflow_signed, /* complain_on_overflow */
 690          ppc64_elf_unhandled_reloc, /* special_function */
 691          "R_PPC64_PLTREL32",    /* name */
 692          FALSE,                 /* partial_inplace */
 693          0,                     /* src_mask */
 694          0xffffffff,            /* dst_mask */
 695          TRUE),                 /* pcrel_offset */
 696
 697   /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
 698      the symbol.  */
 699   HOWTO (R_PPC64_PLT16_LO,      /* type */
 700          0,                     /* rightshift */
 701          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 702          16,                    /* bitsize */
 703          FALSE,                 /* pc_relative */
 704          0,                     /* bitpos */
 705          complain_overflow_dont, /* complain_on_overflow */
 706          ppc64_elf_unhandled_reloc, /* special_function */
 707          "R_PPC64_PLT16_LO",    /* name */
 708          FALSE,                 /* partial_inplace */
 709          0,                     /* src_mask */
 710          0xffff,                /* dst_mask */
 711          FALSE),                /* pcrel_offset */
 712
 713   /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
 714      the symbol.  */
 715   HOWTO (R_PPC64_PLT16_HI,      /* type */
 716          16,                    /* rightshift */
 717          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 718          16,                    /* bitsize */
 719          FALSE,                 /* pc_relative */
 720          0,                     /* bitpos */
 721          complain_overflow_signed, /* complain_on_overflow */
 722          ppc64_elf_unhandled_reloc, /* special_function */
 723          "R_PPC64_PLT16_HI",    /* name */
 724          FALSE,                 /* partial_inplace */
 725          0,                     /* src_mask */
 726          0xffff,                /* dst_mask */
 727          FALSE),                /* pcrel_offset */
 728
 729   /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
 730      the symbol.  */
 731   HOWTO (R_PPC64_PLT16_HA,      /* type */
 732          16,                    /* rightshift */
 733          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 734          16,                    /* bitsize */
 735          FALSE,                 /* pc_relative */
 736          0,                     /* bitpos */
 737          complain_overflow_signed, /* complain_on_overflow */
 738          ppc64_elf_unhandled_reloc, /* special_function */
 739          "R_PPC64_PLT16_HA",    /* name */
 740          FALSE,                 /* partial_inplace */
 741          0,                     /* src_mask */
 742          0xffff,                /* dst_mask */
 743          FALSE),                /* pcrel_offset */
 744
 745   /* 16-bit section relative relocation.  */
 746   HOWTO (R_PPC64_SECTOFF,       /* type */
 747          0,                     /* rightshift */
 748          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 749          16,                    /* bitsize */
 750          FALSE,                 /* pc_relative */
 751          0,                     /* bitpos */
 752          complain_overflow_signed, /* complain_on_overflow */
 753          ppc64_elf_sectoff_reloc, /* special_function */
 754          "R_PPC64_SECTOFF",     /* name */
 755          FALSE,                 /* partial_inplace */
 756          0,                     /* src_mask */
 757          0xffff,                /* dst_mask */
 758          FALSE),                /* pcrel_offset */
 759
 760   /* Like R_PPC64_SECTOFF, but no overflow warning.  */
 761   HOWTO (R_PPC64_SECTOFF_LO,    /* type */
 762          0,                     /* rightshift */
 763          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 764          16,                    /* bitsize */
 765          FALSE,                 /* pc_relative */
 766          0,                     /* bitpos */
 767          complain_overflow_dont, /* complain_on_overflow */
 768          ppc64_elf_sectoff_reloc, /* special_function */
 769          "R_PPC64_SECTOFF_LO",  /* name */
 770          FALSE,                 /* partial_inplace */
 771          0,                     /* src_mask */
 772          0xffff,                /* dst_mask */
 773          FALSE),                /* pcrel_offset */
 774
 775   /* 16-bit upper half section relative relocation.  */
 776   HOWTO (R_PPC64_SECTOFF_HI,    /* type */
 777          16,                    /* rightshift */
 778          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 779          16,                    /* bitsize */
 780          FALSE,                 /* pc_relative */
 781          0,                     /* bitpos */
 782          complain_overflow_signed, /* complain_on_overflow */
 783          ppc64_elf_sectoff_reloc, /* special_function */
 784          "R_PPC64_SECTOFF_HI",  /* name */
 785          FALSE,                 /* partial_inplace */
 786          0,                     /* src_mask */
 787          0xffff,                /* dst_mask */
 788          FALSE),                /* pcrel_offset */
 789
 790   /* 16-bit upper half adjusted section relative relocation.  */
 791   HOWTO (R_PPC64_SECTOFF_HA,    /* type */
 792          16,                    /* rightshift */
 793          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 794          16,                    /* bitsize */
 795          FALSE,                 /* pc_relative */
 796          0,                     /* bitpos */
 797          complain_overflow_signed, /* complain_on_overflow */
 798          ppc64_elf_sectoff_ha_reloc, /* special_function */
 799          "R_PPC64_SECTOFF_HA",  /* name */
 800          FALSE,                 /* partial_inplace */
 801          0,                     /* src_mask */
 802          0xffff,                /* dst_mask */
 803          FALSE),                /* pcrel_offset */
 804
 805   /* Like R_PPC64_REL24 without touching the two least significant bits.  */
 806   HOWTO (R_PPC64_REL30,         /* type */
 807          2,                     /* rightshift */
 808          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 809          30,                    /* bitsize */
 810          TRUE,                  /* pc_relative */
 811          0,                     /* bitpos */
 812          complain_overflow_dont, /* complain_on_overflow */
 813          bfd_elf_generic_reloc, /* special_function */
 814          "R_PPC64_REL30",       /* name */
 815          FALSE,                 /* partial_inplace */
 816          0,                     /* src_mask */
 817          0xfffffffc,            /* dst_mask */
 818          TRUE),                 /* pcrel_offset */
 819
 820   /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI.  */
 821
 822   /* A standard 64-bit relocation.  */
 823   HOWTO (R_PPC64_ADDR64,        /* type */
 824          0,                     /* rightshift */
 825          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 826          64,                    /* bitsize */
 827          FALSE,                 /* pc_relative */
 828          0,                     /* bitpos */
 829          complain_overflow_dont, /* complain_on_overflow */
 830          bfd_elf_generic_reloc, /* special_function */
 831          "R_PPC64_ADDR64",      /* name */
 832          FALSE,                 /* partial_inplace */
 833          0,                     /* src_mask */
 834          ONES (64),             /* dst_mask */
 835          FALSE),                /* pcrel_offset */
 836
 837   /* The bits 32-47 of an address.  */
 838   HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
 839          32,                    /* rightshift */
 840          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 841          16,                    /* bitsize */
 842          FALSE,                 /* pc_relative */
 843          0,                     /* bitpos */
 844          complain_overflow_dont, /* complain_on_overflow */
 845          bfd_elf_generic_reloc, /* special_function */
 846          "R_PPC64_ADDR16_HIGHER", /* name */
 847          FALSE,                 /* partial_inplace */
 848          0,                     /* src_mask */
 849          0xffff,                /* dst_mask */
 850          FALSE),                /* pcrel_offset */
 851
 852   /* The bits 32-47 of an address, plus 1 if the contents of the low
 853      16 bits, treated as a signed number, is negative.  */
 854   HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
 855          32,                    /* rightshift */
 856          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 857          16,                    /* bitsize */
 858          FALSE,                 /* pc_relative */
 859          0,                     /* bitpos */
 860          complain_overflow_dont, /* complain_on_overflow */
 861          ppc64_elf_ha_reloc,    /* special_function */
 862          "R_PPC64_ADDR16_HIGHERA", /* name */
 863          FALSE,                 /* partial_inplace */
 864          0,                     /* src_mask */
 865          0xffff,                /* dst_mask */
 866          FALSE),                /* pcrel_offset */
 867
 868   /* The bits 48-63 of an address.  */
 869   HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
 870          48,                    /* rightshift */
 871          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 872          16,                    /* bitsize */
 873          FALSE,                 /* pc_relative */
 874          0,                     /* bitpos */
 875          complain_overflow_dont, /* complain_on_overflow */
 876          bfd_elf_generic_reloc, /* special_function */
 877          "R_PPC64_ADDR16_HIGHEST", /* name */
 878          FALSE,                 /* partial_inplace */
 879          0,                     /* src_mask */
 880          0xffff,                /* dst_mask */
 881          FALSE),                /* pcrel_offset */
 882
 883   /* The bits 48-63 of an address, plus 1 if the contents of the low
 884      16 bits, treated as a signed number, is negative.  */
 885   HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
 886          48,                    /* rightshift */
 887          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 888          16,                    /* bitsize */
 889          FALSE,                 /* pc_relative */
 890          0,                     /* bitpos */
 891          complain_overflow_dont, /* complain_on_overflow */
 892          ppc64_elf_ha_reloc,    /* special_function */
 893          "R_PPC64_ADDR16_HIGHESTA", /* name */
 894          FALSE,                 /* partial_inplace */
 895          0,                     /* src_mask */
 896          0xffff,                /* dst_mask */
 897          FALSE),                /* pcrel_offset */
 898
 899   /* Like ADDR64, but may be unaligned.  */
 900   HOWTO (R_PPC64_UADDR64,       /* type */
 901          0,                     /* rightshift */
 902          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 903          64,                    /* bitsize */
 904          FALSE,                 /* pc_relative */
 905          0,                     /* bitpos */
 906          complain_overflow_dont, /* complain_on_overflow */
 907          bfd_elf_generic_reloc, /* special_function */
 908          "R_PPC64_UADDR64",     /* name */
 909          FALSE,                 /* partial_inplace */
 910          0,                     /* src_mask */
 911          ONES (64),             /* dst_mask */
 912          FALSE),                /* pcrel_offset */
 913
 914   /* 64-bit relative relocation.  */
 915   HOWTO (R_PPC64_REL64,         /* type */
 916          0,                     /* rightshift */
 917          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 918          64,                    /* bitsize */
 919          TRUE,                  /* pc_relative */
 920          0,                     /* bitpos */
 921          complain_overflow_dont, /* complain_on_overflow */
 922          bfd_elf_generic_reloc, /* special_function */
 923          "R_PPC64_REL64",       /* name */
 924          FALSE,                 /* partial_inplace */
 925          0,                     /* src_mask */
 926          ONES (64),             /* dst_mask */
 927          TRUE),                 /* pcrel_offset */
 928
 929   /* 64-bit relocation to the symbol's procedure linkage table.  */
 930   HOWTO (R_PPC64_PLT64,         /* type */
 931          0,                     /* rightshift */
 932          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 933          64,                    /* bitsize */
 934          FALSE,                 /* pc_relative */
 935          0,                     /* bitpos */
 936          complain_overflow_dont, /* complain_on_overflow */
 937          ppc64_elf_unhandled_reloc, /* special_function */
 938          "R_PPC64_PLT64",       /* name */
 939          FALSE,                 /* partial_inplace */
 940          0,                     /* src_mask */
 941          ONES (64),             /* dst_mask */
 942          FALSE),                /* pcrel_offset */
 943
 944   /* 64-bit PC relative relocation to the symbol's procedure linkage
 945      table.  */
 946   /* FIXME: R_PPC64_PLTREL64 not supported.  */
 947   HOWTO (R_PPC64_PLTREL64,      /* type */
 948          0,                     /* rightshift */
 949          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 950          64,                    /* bitsize */
 951          TRUE,                  /* pc_relative */
 952          0,                     /* bitpos */
 953          complain_overflow_dont, /* complain_on_overflow */
 954          ppc64_elf_unhandled_reloc, /* special_function */
 955          "R_PPC64_PLTREL64",    /* name */
 956          FALSE,                 /* partial_inplace */
 957          0,                     /* src_mask */
 958          ONES (64),             /* dst_mask */
 959          TRUE),                 /* pcrel_offset */
 960
 961   /* 16 bit TOC-relative relocation.  */
 962
 963   /* R_PPC64_TOC16        47       half16*      S + A - .TOC.  */
 964   HOWTO (R_PPC64_TOC16,         /* type */
 965          0,                     /* rightshift */
 966          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 967          16,                    /* bitsize */
 968          FALSE,                 /* pc_relative */
 969          0,                     /* bitpos */
 970          complain_overflow_signed, /* complain_on_overflow */
 971          ppc64_elf_toc_reloc,   /* special_function */
 972          "R_PPC64_TOC16",       /* name */
 973          FALSE,                 /* partial_inplace */
 974          0,                     /* src_mask */
 975          0xffff,                /* dst_mask */
 976          FALSE),                /* pcrel_offset */
 977
 978   /* 16 bit TOC-relative relocation without overflow.  */
 979
 980   /* R_PPC64_TOC16_LO     48       half16        #lo (S + A - .TOC.)  */
 981   HOWTO (R_PPC64_TOC16_LO,      /* type */
 982          0,                     /* rightshift */
 983          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 984          16,                    /* bitsize */
 985          FALSE,                 /* pc_relative */
 986          0,                     /* bitpos */
 987          complain_overflow_dont, /* complain_on_overflow */
 988          ppc64_elf_toc_reloc,   /* special_function */
 989          "R_PPC64_TOC16_LO",    /* name */
 990          FALSE,                 /* partial_inplace */
 991          0,                     /* src_mask */
 992          0xffff,                /* dst_mask */
 993          FALSE),                /* pcrel_offset */
 994
 995   /* 16 bit TOC-relative relocation, high 16 bits.  */
 996
 997   /* R_PPC64_TOC16_HI     49       half16        #hi (S + A - .TOC.)  */
 998   HOWTO (R_PPC64_TOC16_HI,      /* type */
 999          16,                    /* rightshift */
1000          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1001          16,                    /* bitsize */
1002          FALSE,                 /* pc_relative */
1003          0,                     /* bitpos */
1004          complain_overflow_signed, /* complain_on_overflow */
1005          ppc64_elf_toc_reloc,   /* special_function */
1006          "R_PPC64_TOC16_HI",    /* name */
1007          FALSE,                 /* partial_inplace */
1008          0,                     /* src_mask */
1009          0xffff,                /* dst_mask */
1010          FALSE),                /* pcrel_offset */
1011
1012   /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
1013      contents of the low 16 bits, treated as a signed number, is
1014      negative.  */
1015
1016   /* R_PPC64_TOC16_HA     50       half16        #ha (S + A - .TOC.)  */
1017   HOWTO (R_PPC64_TOC16_HA,      /* type */
1018          16,                    /* rightshift */
1019          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1020          16,                    /* bitsize */
1021          FALSE,                 /* pc_relative */
1022          0,                     /* bitpos */
1023          complain_overflow_signed, /* complain_on_overflow */
1024          ppc64_elf_toc_ha_reloc, /* special_function */
1025          "R_PPC64_TOC16_HA",    /* name */
1026          FALSE,                 /* partial_inplace */
1027          0,                     /* src_mask */
1028          0xffff,                /* dst_mask */
1029          FALSE),                /* pcrel_offset */
1030
1031   /* 64-bit relocation; insert value of TOC base (.TOC.).  */
1032
1033   /* R_PPC64_TOC                  51       doubleword64  .TOC.  */
1034   HOWTO (R_PPC64_TOC,           /* type */
1035          0,                     /* rightshift */
1036          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1037          64,                    /* bitsize */
1038          FALSE,                 /* pc_relative */
1039          0,                     /* bitpos */
1040          complain_overflow_dont, /* complain_on_overflow */
1041          ppc64_elf_toc64_reloc, /* special_function */
1042          "R_PPC64_TOC",         /* name */
1043          FALSE,                 /* partial_inplace */
1044          0,                     /* src_mask */
1045          ONES (64),             /* dst_mask */
1046          FALSE),                /* pcrel_offset */
1047
1048   /* Like R_PPC64_GOT16, but also informs the link editor that the
1049      value to relocate may (!) refer to a PLT entry which the link
1050      editor (a) may replace with the symbol value.  If the link editor
1051      is unable to fully resolve the symbol, it may (b) create a PLT
1052      entry and store the address to the new PLT entry in the GOT.
1053      This permits lazy resolution of function symbols at run time.
1054      The link editor may also skip all of this and just (c) emit a
1055      R_PPC64_GLOB_DAT to tie the symbol to the GOT entry.  */
1056   /* FIXME: R_PPC64_PLTGOT16 not implemented.  */
1057     HOWTO (R_PPC64_PLTGOT16,    /* type */
1058          0,                     /* rightshift */
1059          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1060          16,                    /* bitsize */
1061          FALSE,                 /* pc_relative */
1062          0,                     /* bitpos */
1063          complain_overflow_signed, /* complain_on_overflow */
1064          ppc64_elf_unhandled_reloc, /* special_function */
1065          "R_PPC64_PLTGOT16",    /* name */
1066          FALSE,                 /* partial_inplace */
1067          0,                     /* src_mask */
1068          0xffff,                /* dst_mask */
1069          FALSE),                /* pcrel_offset */
1070
1071   /* Like R_PPC64_PLTGOT16, but without overflow.  */
1072   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1073   HOWTO (R_PPC64_PLTGOT16_LO,   /* type */
1074          0,                     /* rightshift */
1075          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1076          16,                    /* bitsize */
1077          FALSE,                 /* pc_relative */
1078          0,                     /* bitpos */
1079          complain_overflow_dont, /* complain_on_overflow */
1080          ppc64_elf_unhandled_reloc, /* special_function */
1081          "R_PPC64_PLTGOT16_LO", /* name */
1082          FALSE,                 /* partial_inplace */
1083          0,                     /* src_mask */
1084          0xffff,                /* dst_mask */
1085          FALSE),                /* pcrel_offset */
1086
1087   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address.  */
1088   /* FIXME: R_PPC64_PLTGOT16_HI not implemented.  */
1089   HOWTO (R_PPC64_PLTGOT16_HI,   /* type */
1090          16,                    /* rightshift */
1091          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1092          16,                    /* bitsize */
1093          FALSE,                 /* pc_relative */
1094          0,                     /* bitpos */
1095          complain_overflow_signed, /* complain_on_overflow */
1096          ppc64_elf_unhandled_reloc, /* special_function */
1097          "R_PPC64_PLTGOT16_HI", /* name */
1098          FALSE,                 /* partial_inplace */
1099          0,                     /* src_mask */
1100          0xffff,                /* dst_mask */
1101          FALSE),                /* pcrel_offset */
1102
1103   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1104      1 if the contents of the low 16 bits, treated as a signed number,
1105      is negative.  */
1106   /* FIXME: R_PPC64_PLTGOT16_HA not implemented.  */
1107   HOWTO (R_PPC64_PLTGOT16_HA,   /* type */
1108          16,                    /* rightshift */
1109          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1110          16,                    /* bitsize */
1111          FALSE,                 /* pc_relative */
1112          0,                     /* bitpos */
1113          complain_overflow_signed, /* complain_on_overflow */
1114          ppc64_elf_unhandled_reloc, /* special_function */
1115          "R_PPC64_PLTGOT16_HA", /* name */
1116          FALSE,                 /* partial_inplace */
1117          0,                     /* src_mask */
1118          0xffff,                /* dst_mask */
1119          FALSE),                /* pcrel_offset */
1120
1121   /* Like R_PPC64_ADDR16, but for instructions with a DS field.  */
1122   HOWTO (R_PPC64_ADDR16_DS,     /* type */
1123          0,                     /* rightshift */
1124          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1125          16,                    /* bitsize */
1126          FALSE,                 /* pc_relative */
1127          0,                     /* bitpos */
1128          complain_overflow_signed, /* complain_on_overflow */
1129          bfd_elf_generic_reloc, /* special_function */
1130          "R_PPC64_ADDR16_DS",   /* name */
1131          FALSE,                 /* partial_inplace */
1132          0,                     /* src_mask */
1133          0xfffc,                /* dst_mask */
1134          FALSE),                /* pcrel_offset */
1135
1136   /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field.  */
1137   HOWTO (R_PPC64_ADDR16_LO_DS,  /* type */
1138          0,                     /* rightshift */
1139          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1140          16,                    /* bitsize */
1141          FALSE,                 /* pc_relative */
1142          0,                     /* bitpos */
1143          complain_overflow_dont,/* complain_on_overflow */
1144          bfd_elf_generic_reloc, /* special_function */
1145          "R_PPC64_ADDR16_LO_DS",/* name */
1146          FALSE,                 /* partial_inplace */
1147          0,                     /* src_mask */
1148          0xfffc,                /* dst_mask */
1149          FALSE),                /* pcrel_offset */
1150
1151   /* Like R_PPC64_GOT16, but for instructions with a DS field.  */
1152   HOWTO (R_PPC64_GOT16_DS,      /* type */
1153          0,                     /* rightshift */
1154          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1155          16,                    /* bitsize */
1156          FALSE,                 /* pc_relative */
1157          0,                     /* bitpos */
1158          complain_overflow_signed, /* complain_on_overflow */
1159          ppc64_elf_unhandled_reloc, /* special_function */
1160          "R_PPC64_GOT16_DS",    /* name */
1161          FALSE,                 /* partial_inplace */
1162          0,                     /* src_mask */
1163          0xfffc,                /* dst_mask */
1164          FALSE),                /* pcrel_offset */
1165
1166   /* Like R_PPC64_GOT16_LO, but for instructions with a DS field.  */
1167   HOWTO (R_PPC64_GOT16_LO_DS,   /* type */
1168          0,                     /* rightshift */
1169          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1170          16,                    /* bitsize */
1171          FALSE,                 /* pc_relative */
1172          0,                     /* bitpos */
1173          complain_overflow_dont, /* complain_on_overflow */
1174          ppc64_elf_unhandled_reloc, /* special_function */
1175          "R_PPC64_GOT16_LO_DS", /* name */
1176          FALSE,                 /* partial_inplace */
1177          0,                     /* src_mask */
1178          0xfffc,                /* dst_mask */
1179          FALSE),                /* pcrel_offset */
1180
1181   /* Like R_PPC64_PLT16_LO, but for instructions with a DS field.  */
1182   HOWTO (R_PPC64_PLT16_LO_DS,   /* type */
1183          0,                     /* rightshift */
1184          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1185          16,                    /* bitsize */
1186          FALSE,                 /* pc_relative */
1187          0,                     /* bitpos */
1188          complain_overflow_dont, /* complain_on_overflow */
1189          ppc64_elf_unhandled_reloc, /* special_function */
1190          "R_PPC64_PLT16_LO_DS", /* name */
1191          FALSE,                 /* partial_inplace */
1192          0,                     /* src_mask */
1193          0xfffc,                /* dst_mask */
1194          FALSE),                /* pcrel_offset */
1195
1196   /* Like R_PPC64_SECTOFF, but for instructions with a DS field.  */
1197   HOWTO (R_PPC64_SECTOFF_DS,    /* type */
1198          0,                     /* rightshift */
1199          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1200          16,                    /* bitsize */
1201          FALSE,                 /* pc_relative */
1202          0,                     /* bitpos */
1203          complain_overflow_signed, /* complain_on_overflow */
1204          ppc64_elf_sectoff_reloc, /* special_function */
1205          "R_PPC64_SECTOFF_DS",  /* name */
1206          FALSE,                 /* partial_inplace */
1207          0,                     /* src_mask */
1208          0xfffc,                /* dst_mask */
1209          FALSE),                /* pcrel_offset */
1210
1211   /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field.  */
1212   HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1213          0,                     /* rightshift */
1214          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1215          16,                    /* bitsize */
1216          FALSE,                 /* pc_relative */
1217          0,                     /* bitpos */
1218          complain_overflow_dont, /* complain_on_overflow */
1219          ppc64_elf_sectoff_reloc, /* special_function */
1220          "R_PPC64_SECTOFF_LO_DS",/* name */
1221          FALSE,                 /* partial_inplace */
1222          0,                     /* src_mask */
1223          0xfffc,                /* dst_mask */
1224          FALSE),                /* pcrel_offset */
1225
1226   /* Like R_PPC64_TOC16, but for instructions with a DS field.  */
1227   HOWTO (R_PPC64_TOC16_DS,      /* type */
1228          0,                     /* rightshift */
1229          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1230          16,                    /* bitsize */
1231          FALSE,                 /* pc_relative */
1232          0,                     /* bitpos */
1233          complain_overflow_signed, /* complain_on_overflow */
1234          ppc64_elf_toc_reloc,   /* special_function */
1235          "R_PPC64_TOC16_DS",    /* name */
1236          FALSE,                 /* partial_inplace */
1237          0,                     /* src_mask */
1238          0xfffc,                /* dst_mask */
1239          FALSE),                /* pcrel_offset */
1240
1241   /* Like R_PPC64_TOC16_LO, but for instructions with a DS field.  */
1242   HOWTO (R_PPC64_TOC16_LO_DS,   /* type */
1243          0,                     /* rightshift */
1244          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1245          16,                    /* bitsize */
1246          FALSE,                 /* pc_relative */
1247          0,                     /* bitpos */
1248          complain_overflow_dont, /* complain_on_overflow */
1249          ppc64_elf_toc_reloc,   /* special_function */
1250          "R_PPC64_TOC16_LO_DS", /* name */
1251          FALSE,                 /* partial_inplace */
1252          0,                     /* src_mask */
1253          0xfffc,                /* dst_mask */
1254          FALSE),                /* pcrel_offset */
1255
1256   /* Like R_PPC64_PLTGOT16, but for instructions with a DS field.  */
1257   /* FIXME: R_PPC64_PLTGOT16_DS not implemented.  */
1258   HOWTO (R_PPC64_PLTGOT16_DS,   /* type */
1259          0,                     /* rightshift */
1260          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1261          16,                    /* bitsize */
1262          FALSE,                 /* pc_relative */
1263          0,                     /* bitpos */
1264          complain_overflow_signed, /* complain_on_overflow */
1265          ppc64_elf_unhandled_reloc, /* special_function */
1266          "R_PPC64_PLTGOT16_DS", /* name */
1267          FALSE,                 /* partial_inplace */
1268          0,                     /* src_mask */
1269          0xfffc,                /* dst_mask */
1270          FALSE),                /* pcrel_offset */
1271
1272   /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field.  */
1273   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1274   HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1275          0,                     /* rightshift */
1276          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1277          16,                    /* bitsize */
1278          FALSE,                 /* pc_relative */
1279          0,                     /* bitpos */
1280          complain_overflow_dont, /* complain_on_overflow */
1281          ppc64_elf_unhandled_reloc, /* special_function */
1282          "R_PPC64_PLTGOT16_LO_DS",/* name */
1283          FALSE,                 /* partial_inplace */
1284          0,                     /* src_mask */
1285          0xfffc,                /* dst_mask */
1286          FALSE),                /* pcrel_offset */
1287
1288   /* Marker relocs for TLS.  */
1289   HOWTO (R_PPC64_TLS,
1290          0,                     /* rightshift */
1291          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1292          32,                    /* bitsize */
1293          FALSE,                 /* pc_relative */
1294          0,                     /* bitpos */
1295          complain_overflow_dont, /* complain_on_overflow */
1296          bfd_elf_generic_reloc, /* special_function */
1297          "R_PPC64_TLS",         /* name */
1298          FALSE,                 /* partial_inplace */
1299          0,                     /* src_mask */
1300          0,                     /* dst_mask */
1301          FALSE),                /* pcrel_offset */
1302
1303   HOWTO (R_PPC64_TLSGD,
1304          0,                     /* rightshift */
1305          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1306          32,                    /* bitsize */
1307          FALSE,                 /* pc_relative */
1308          0,                     /* bitpos */
1309          complain_overflow_dont, /* complain_on_overflow */
1310          bfd_elf_generic_reloc, /* special_function */
1311          "R_PPC64_TLSGD",       /* name */
1312          FALSE,                 /* partial_inplace */
1313          0,                     /* src_mask */
1314          0,                     /* dst_mask */
1315          FALSE),                /* pcrel_offset */
1316
1317   HOWTO (R_PPC64_TLSLD,
1318          0,                     /* rightshift */
1319          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1320          32,                    /* bitsize */
1321          FALSE,                 /* pc_relative */
1322          0,                     /* bitpos */
1323          complain_overflow_dont, /* complain_on_overflow */
1324          bfd_elf_generic_reloc, /* special_function */
1325          "R_PPC64_TLSLD",       /* name */
1326          FALSE,                 /* partial_inplace */
1327          0,                     /* src_mask */
1328          0,                     /* dst_mask */
1329          FALSE),                /* pcrel_offset */
1330
1331   HOWTO (R_PPC64_TOCSAVE,
1332          0,                     /* rightshift */
1333          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1334          32,                    /* bitsize */
1335          FALSE,                 /* pc_relative */
1336          0,                     /* bitpos */
1337          complain_overflow_dont, /* complain_on_overflow */
1338          bfd_elf_generic_reloc, /* special_function */
1339          "R_PPC64_TOCSAVE",     /* name */
1340          FALSE,                 /* partial_inplace */
1341          0,                     /* src_mask */
1342          0,                     /* dst_mask */
1343          FALSE),                /* pcrel_offset */
1344
1345   /* Computes the load module index of the load module that contains the
1346      definition of its TLS sym.  */
1347   HOWTO (R_PPC64_DTPMOD64,
1348          0,                     /* rightshift */
1349          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1350          64,                    /* bitsize */
1351          FALSE,                 /* pc_relative */
1352          0,                     /* bitpos */
1353          complain_overflow_dont, /* complain_on_overflow */
1354          ppc64_elf_unhandled_reloc, /* special_function */
1355          "R_PPC64_DTPMOD64",    /* name */
1356          FALSE,                 /* partial_inplace */
1357          0,                     /* src_mask */
1358          ONES (64),             /* dst_mask */
1359          FALSE),                /* pcrel_offset */
1360
1361   /* Computes a dtv-relative displacement, the difference between the value
1362      of sym+add and the base address of the thread-local storage block that
1363      contains the definition of sym, minus 0x8000.  */
1364   HOWTO (R_PPC64_DTPREL64,
1365          0,                     /* rightshift */
1366          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1367          64,                    /* bitsize */
1368          FALSE,                 /* pc_relative */
1369          0,                     /* bitpos */
1370          complain_overflow_dont, /* complain_on_overflow */
1371          ppc64_elf_unhandled_reloc, /* special_function */
1372          "R_PPC64_DTPREL64",    /* name */
1373          FALSE,                 /* partial_inplace */
1374          0,                     /* src_mask */
1375          ONES (64),             /* dst_mask */
1376          FALSE),                /* pcrel_offset */
1377
1378   /* A 16 bit dtprel reloc.  */
1379   HOWTO (R_PPC64_DTPREL16,
1380          0,                     /* rightshift */
1381          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1382          16,                    /* bitsize */
1383          FALSE,                 /* pc_relative */
1384          0,                     /* bitpos */
1385          complain_overflow_signed, /* complain_on_overflow */
1386          ppc64_elf_unhandled_reloc, /* special_function */
1387          "R_PPC64_DTPREL16",    /* name */
1388          FALSE,                 /* partial_inplace */
1389          0,                     /* src_mask */
1390          0xffff,                /* dst_mask */
1391          FALSE),                /* pcrel_offset */
1392
1393   /* Like DTPREL16, but no overflow.  */
1394   HOWTO (R_PPC64_DTPREL16_LO,
1395          0,                     /* rightshift */
1396          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1397          16,                    /* bitsize */
1398          FALSE,                 /* pc_relative */
1399          0,                     /* bitpos */
1400          complain_overflow_dont, /* complain_on_overflow */
1401          ppc64_elf_unhandled_reloc, /* special_function */
1402          "R_PPC64_DTPREL16_LO", /* name */
1403          FALSE,                 /* partial_inplace */
1404          0,                     /* src_mask */
1405          0xffff,                /* dst_mask */
1406          FALSE),                /* pcrel_offset */
1407
1408   /* Like DTPREL16_LO, but next higher group of 16 bits.  */
1409   HOWTO (R_PPC64_DTPREL16_HI,
1410          16,                    /* rightshift */
1411          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1412          16,                    /* bitsize */
1413          FALSE,                 /* pc_relative */
1414          0,                     /* bitpos */
1415          complain_overflow_signed, /* complain_on_overflow */
1416          ppc64_elf_unhandled_reloc, /* special_function */
1417          "R_PPC64_DTPREL16_HI", /* name */
1418          FALSE,                 /* partial_inplace */
1419          0,                     /* src_mask */
1420          0xffff,                /* dst_mask */
1421          FALSE),                /* pcrel_offset */
1422
1423   /* Like DTPREL16_HI, but adjust for low 16 bits.  */
1424   HOWTO (R_PPC64_DTPREL16_HA,
1425          16,                    /* rightshift */
1426          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1427          16,                    /* bitsize */
1428          FALSE,                 /* pc_relative */
1429          0,                     /* bitpos */
1430          complain_overflow_signed, /* complain_on_overflow */
1431          ppc64_elf_unhandled_reloc, /* special_function */
1432          "R_PPC64_DTPREL16_HA", /* name */
1433          FALSE,                 /* partial_inplace */
1434          0,                     /* src_mask */
1435          0xffff,                /* dst_mask */
1436          FALSE),                /* pcrel_offset */
1437
1438   /* Like DTPREL16_HI, but next higher group of 16 bits.  */
1439   HOWTO (R_PPC64_DTPREL16_HIGHER,
1440          32,                    /* rightshift */
1441          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1442          16,                    /* bitsize */
1443          FALSE,                 /* pc_relative */
1444          0,                     /* bitpos */
1445          complain_overflow_dont, /* complain_on_overflow */
1446          ppc64_elf_unhandled_reloc, /* special_function */
1447          "R_PPC64_DTPREL16_HIGHER", /* name */
1448          FALSE,                 /* partial_inplace */
1449          0,                     /* src_mask */
1450          0xffff,                /* dst_mask */
1451          FALSE),                /* pcrel_offset */
1452
1453   /* Like DTPREL16_HIGHER, but adjust for low 16 bits.  */
1454   HOWTO (R_PPC64_DTPREL16_HIGHERA,
1455          32,                    /* rightshift */
1456          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1457          16,                    /* bitsize */
1458          FALSE,                 /* pc_relative */
1459          0,                     /* bitpos */
1460          complain_overflow_dont, /* complain_on_overflow */
1461          ppc64_elf_unhandled_reloc, /* special_function */
1462          "R_PPC64_DTPREL16_HIGHERA", /* name */
1463          FALSE,                 /* partial_inplace */
1464          0,                     /* src_mask */
1465          0xffff,                /* dst_mask */
1466          FALSE),                /* pcrel_offset */
1467
1468   /* Like DTPREL16_HIGHER, but next higher group of 16 bits.  */
1469   HOWTO (R_PPC64_DTPREL16_HIGHEST,
1470          48,                    /* rightshift */
1471          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1472          16,                    /* bitsize */
1473          FALSE,                 /* pc_relative */
1474          0,                     /* bitpos */
1475          complain_overflow_dont, /* complain_on_overflow */
1476          ppc64_elf_unhandled_reloc, /* special_function */
1477          "R_PPC64_DTPREL16_HIGHEST", /* name */
1478          FALSE,                 /* partial_inplace */
1479          0,                     /* src_mask */
1480          0xffff,                /* dst_mask */
1481          FALSE),                /* pcrel_offset */
1482
1483   /* Like DTPREL16_HIGHEST, but adjust for low 16 bits.  */
1484   HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1485          48,                    /* rightshift */
1486          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1487          16,                    /* bitsize */
1488          FALSE,                 /* pc_relative */
1489          0,                     /* bitpos */
1490          complain_overflow_dont, /* complain_on_overflow */
1491          ppc64_elf_unhandled_reloc, /* special_function */
1492          "R_PPC64_DTPREL16_HIGHESTA", /* name */
1493          FALSE,                 /* partial_inplace */
1494          0,                     /* src_mask */
1495          0xffff,                /* dst_mask */
1496          FALSE),                /* pcrel_offset */
1497
1498   /* Like DTPREL16, but for insns with a DS field.  */
1499   HOWTO (R_PPC64_DTPREL16_DS,
1500          0,                     /* rightshift */
1501          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1502          16,                    /* bitsize */
1503          FALSE,                 /* pc_relative */
1504          0,                     /* bitpos */
1505          complain_overflow_signed, /* complain_on_overflow */
1506          ppc64_elf_unhandled_reloc, /* special_function */
1507          "R_PPC64_DTPREL16_DS", /* name */
1508          FALSE,                 /* partial_inplace */
1509          0,                     /* src_mask */
1510          0xfffc,                /* dst_mask */
1511          FALSE),                /* pcrel_offset */
1512
1513   /* Like DTPREL16_DS, but no overflow.  */
1514   HOWTO (R_PPC64_DTPREL16_LO_DS,
1515          0,                     /* rightshift */
1516          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1517          16,                    /* bitsize */
1518          FALSE,                 /* pc_relative */
1519          0,                     /* bitpos */
1520          complain_overflow_dont, /* complain_on_overflow */
1521          ppc64_elf_unhandled_reloc, /* special_function */
1522          "R_PPC64_DTPREL16_LO_DS", /* name */
1523          FALSE,                 /* partial_inplace */
1524          0,                     /* src_mask */
1525          0xfffc,                /* dst_mask */
1526          FALSE),                /* pcrel_offset */
1527
1528   /* Computes a tp-relative displacement, the difference between the value of
1529      sym+add and the value of the thread pointer (r13).  */
1530   HOWTO (R_PPC64_TPREL64,
1531          0,                     /* rightshift */
1532          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1533          64,                    /* bitsize */
1534          FALSE,                 /* pc_relative */
1535          0,                     /* bitpos */
1536          complain_overflow_dont, /* complain_on_overflow */
1537          ppc64_elf_unhandled_reloc, /* special_function */
1538          "R_PPC64_TPREL64",     /* name */
1539          FALSE,                 /* partial_inplace */
1540          0,                     /* src_mask */
1541          ONES (64),             /* dst_mask */
1542          FALSE),                /* pcrel_offset */
1543
1544   /* A 16 bit tprel reloc.  */
1545   HOWTO (R_PPC64_TPREL16,
1546          0,                     /* rightshift */
1547          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1548          16,                    /* bitsize */
1549          FALSE,                 /* pc_relative */
1550          0,                     /* bitpos */
1551          complain_overflow_signed, /* complain_on_overflow */
1552          ppc64_elf_unhandled_reloc, /* special_function */
1553          "R_PPC64_TPREL16",     /* name */
1554          FALSE,                 /* partial_inplace */
1555          0,                     /* src_mask */
1556          0xffff,                /* dst_mask */
1557          FALSE),                /* pcrel_offset */
1558
1559   /* Like TPREL16, but no overflow.  */
1560   HOWTO (R_PPC64_TPREL16_LO,
1561          0,                     /* rightshift */
1562          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1563          16,                    /* bitsize */
1564          FALSE,                 /* pc_relative */
1565          0,                     /* bitpos */
1566          complain_overflow_dont, /* complain_on_overflow */
1567          ppc64_elf_unhandled_reloc, /* special_function */
1568          "R_PPC64_TPREL16_LO",  /* name */
1569          FALSE,                 /* partial_inplace */
1570          0,                     /* src_mask */
1571          0xffff,                /* dst_mask */
1572          FALSE),                /* pcrel_offset */
1573
1574   /* Like TPREL16_LO, but next higher group of 16 bits.  */
1575   HOWTO (R_PPC64_TPREL16_HI,
1576          16,                    /* rightshift */
1577          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1578          16,                    /* bitsize */
1579          FALSE,                 /* pc_relative */
1580          0,                     /* bitpos */
1581          complain_overflow_signed, /* complain_on_overflow */
1582          ppc64_elf_unhandled_reloc, /* special_function */
1583          "R_PPC64_TPREL16_HI",  /* name */
1584          FALSE,                 /* partial_inplace */
1585          0,                     /* src_mask */
1586          0xffff,                /* dst_mask */
1587          FALSE),                /* pcrel_offset */
1588
1589   /* Like TPREL16_HI, but adjust for low 16 bits.  */
1590   HOWTO (R_PPC64_TPREL16_HA,
1591          16,                    /* rightshift */
1592          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1593          16,                    /* bitsize */
1594          FALSE,                 /* pc_relative */
1595          0,                     /* bitpos */
1596          complain_overflow_signed, /* complain_on_overflow */
1597          ppc64_elf_unhandled_reloc, /* special_function */
1598          "R_PPC64_TPREL16_HA",  /* name */
1599          FALSE,                 /* partial_inplace */
1600          0,                     /* src_mask */
1601          0xffff,                /* dst_mask */
1602          FALSE),                /* pcrel_offset */
1603
1604   /* Like TPREL16_HI, but next higher group of 16 bits.  */
1605   HOWTO (R_PPC64_TPREL16_HIGHER,
1606          32,                    /* rightshift */
1607          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1608          16,                    /* bitsize */
1609          FALSE,                 /* pc_relative */
1610          0,                     /* bitpos */
1611          complain_overflow_dont, /* complain_on_overflow */
1612          ppc64_elf_unhandled_reloc, /* special_function */
1613          "R_PPC64_TPREL16_HIGHER",      /* name */
1614          FALSE,                 /* partial_inplace */
1615          0,                     /* src_mask */
1616          0xffff,                /* dst_mask */
1617          FALSE),                /* pcrel_offset */
1618
1619   /* Like TPREL16_HIGHER, but adjust for low 16 bits.  */
1620   HOWTO (R_PPC64_TPREL16_HIGHERA,
1621          32,                    /* rightshift */
1622          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1623          16,                    /* bitsize */
1624          FALSE,                 /* pc_relative */
1625          0,                     /* bitpos */
1626          complain_overflow_dont, /* complain_on_overflow */
1627          ppc64_elf_unhandled_reloc, /* special_function */
1628          "R_PPC64_TPREL16_HIGHERA", /* name */
1629          FALSE,                 /* partial_inplace */
1630          0,                     /* src_mask */
1631          0xffff,                /* dst_mask */
1632          FALSE),                /* pcrel_offset */
1633
1634   /* Like TPREL16_HIGHER, but next higher group of 16 bits.  */
1635   HOWTO (R_PPC64_TPREL16_HIGHEST,
1636          48,                    /* rightshift */
1637          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1638          16,                    /* bitsize */
1639          FALSE,                 /* pc_relative */
1640          0,                     /* bitpos */
1641          complain_overflow_dont, /* complain_on_overflow */
1642          ppc64_elf_unhandled_reloc, /* special_function */
1643          "R_PPC64_TPREL16_HIGHEST", /* name */
1644          FALSE,                 /* partial_inplace */
1645          0,                     /* src_mask */
1646          0xffff,                /* dst_mask */
1647          FALSE),                /* pcrel_offset */
1648
1649   /* Like TPREL16_HIGHEST, but adjust for low 16 bits.  */
1650   HOWTO (R_PPC64_TPREL16_HIGHESTA,
1651          48,                    /* rightshift */
1652          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1653          16,                    /* bitsize */
1654          FALSE,                 /* pc_relative */
1655          0,                     /* bitpos */
1656          complain_overflow_dont, /* complain_on_overflow */
1657          ppc64_elf_unhandled_reloc, /* special_function */
1658          "R_PPC64_TPREL16_HIGHESTA", /* name */
1659          FALSE,                 /* partial_inplace */
1660          0,                     /* src_mask */
1661          0xffff,                /* dst_mask */
1662          FALSE),                /* pcrel_offset */
1663
1664   /* Like TPREL16, but for insns with a DS field.  */
1665   HOWTO (R_PPC64_TPREL16_DS,
1666          0,                     /* rightshift */
1667          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1668          16,                    /* bitsize */
1669          FALSE,                 /* pc_relative */
1670          0,                     /* bitpos */
1671          complain_overflow_signed, /* complain_on_overflow */
1672          ppc64_elf_unhandled_reloc, /* special_function */
1673          "R_PPC64_TPREL16_DS",  /* name */
1674          FALSE,                 /* partial_inplace */
1675          0,                     /* src_mask */
1676          0xfffc,                /* dst_mask */
1677          FALSE),                /* pcrel_offset */
1678
1679   /* Like TPREL16_DS, but no overflow.  */
1680   HOWTO (R_PPC64_TPREL16_LO_DS,
1681          0,                     /* rightshift */
1682          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1683          16,                    /* bitsize */
1684          FALSE,                 /* pc_relative */
1685          0,                     /* bitpos */
1686          complain_overflow_dont, /* complain_on_overflow */
1687          ppc64_elf_unhandled_reloc, /* special_function */
1688          "R_PPC64_TPREL16_LO_DS", /* name */
1689          FALSE,                 /* partial_inplace */
1690          0,                     /* src_mask */
1691          0xfffc,                /* dst_mask */
1692          FALSE),                /* pcrel_offset */
1693
1694   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1695      with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1696      to the first entry relative to the TOC base (r2).  */
1697   HOWTO (R_PPC64_GOT_TLSGD16,
1698          0,                     /* rightshift */
1699          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1700          16,                    /* bitsize */
1701          FALSE,                 /* pc_relative */
1702          0,                     /* bitpos */
1703          complain_overflow_signed, /* complain_on_overflow */
1704          ppc64_elf_unhandled_reloc, /* special_function */
1705          "R_PPC64_GOT_TLSGD16", /* name */
1706          FALSE,                 /* partial_inplace */
1707          0,                     /* src_mask */
1708          0xffff,                /* dst_mask */
1709          FALSE),                /* pcrel_offset */
1710
1711   /* Like GOT_TLSGD16, but no overflow.  */
1712   HOWTO (R_PPC64_GOT_TLSGD16_LO,
1713          0,                     /* rightshift */
1714          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1715          16,                    /* bitsize */
1716          FALSE,                 /* pc_relative */
1717          0,                     /* bitpos */
1718          complain_overflow_dont, /* complain_on_overflow */
1719          ppc64_elf_unhandled_reloc, /* special_function */
1720          "R_PPC64_GOT_TLSGD16_LO", /* name */
1721          FALSE,                 /* partial_inplace */
1722          0,                     /* src_mask */
1723          0xffff,                /* dst_mask */
1724          FALSE),                /* pcrel_offset */
1725
1726   /* Like GOT_TLSGD16_LO, but next higher group of 16 bits.  */
1727   HOWTO (R_PPC64_GOT_TLSGD16_HI,
1728          16,                    /* rightshift */
1729          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1730          16,                    /* bitsize */
1731          FALSE,                 /* pc_relative */
1732          0,                     /* bitpos */
1733          complain_overflow_signed, /* complain_on_overflow */
1734          ppc64_elf_unhandled_reloc, /* special_function */
1735          "R_PPC64_GOT_TLSGD16_HI", /* name */
1736          FALSE,                 /* partial_inplace */
1737          0,                     /* src_mask */
1738          0xffff,                /* dst_mask */
1739          FALSE),                /* pcrel_offset */
1740
1741   /* Like GOT_TLSGD16_HI, but adjust for low 16 bits.  */
1742   HOWTO (R_PPC64_GOT_TLSGD16_HA,
1743          16,                    /* rightshift */
1744          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1745          16,                    /* bitsize */
1746          FALSE,                 /* pc_relative */
1747          0,                     /* bitpos */
1748          complain_overflow_signed, /* complain_on_overflow */
1749          ppc64_elf_unhandled_reloc, /* special_function */
1750          "R_PPC64_GOT_TLSGD16_HA", /* name */
1751          FALSE,                 /* partial_inplace */
1752          0,                     /* src_mask */
1753          0xffff,                /* dst_mask */
1754          FALSE),                /* pcrel_offset */
1755
1756   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1757      with values (sym+add)@dtpmod and zero, and computes the offset to the
1758      first entry relative to the TOC base (r2).  */
1759   HOWTO (R_PPC64_GOT_TLSLD16,
1760          0,                     /* rightshift */
1761          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1762          16,                    /* bitsize */
1763          FALSE,                 /* pc_relative */
1764          0,                     /* bitpos */
1765          complain_overflow_signed, /* complain_on_overflow */
1766          ppc64_elf_unhandled_reloc, /* special_function */
1767          "R_PPC64_GOT_TLSLD16", /* name */
1768          FALSE,                 /* partial_inplace */
1769          0,                     /* src_mask */
1770          0xffff,                /* dst_mask */
1771          FALSE),                /* pcrel_offset */
1772
1773   /* Like GOT_TLSLD16, but no overflow.  */
1774   HOWTO (R_PPC64_GOT_TLSLD16_LO,
1775          0,                     /* rightshift */
1776          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1777          16,                    /* bitsize */
1778          FALSE,                 /* pc_relative */
1779          0,                     /* bitpos */
1780          complain_overflow_dont, /* complain_on_overflow */
1781          ppc64_elf_unhandled_reloc, /* special_function */
1782          "R_PPC64_GOT_TLSLD16_LO", /* name */
1783          FALSE,                 /* partial_inplace */
1784          0,                     /* src_mask */
1785          0xffff,                /* dst_mask */
1786          FALSE),                /* pcrel_offset */
1787
1788   /* Like GOT_TLSLD16_LO, but next higher group of 16 bits.  */
1789   HOWTO (R_PPC64_GOT_TLSLD16_HI,
1790          16,                    /* rightshift */
1791          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1792          16,                    /* bitsize */
1793          FALSE,                 /* pc_relative */
1794          0,                     /* bitpos */
1795          complain_overflow_signed, /* complain_on_overflow */
1796          ppc64_elf_unhandled_reloc, /* special_function */
1797          "R_PPC64_GOT_TLSLD16_HI", /* name */
1798          FALSE,                 /* partial_inplace */
1799          0,                     /* src_mask */
1800          0xffff,                /* dst_mask */
1801          FALSE),                /* pcrel_offset */
1802
1803   /* Like GOT_TLSLD16_HI, but adjust for low 16 bits.  */
1804   HOWTO (R_PPC64_GOT_TLSLD16_HA,
1805          16,                    /* rightshift */
1806          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1807          16,                    /* bitsize */
1808          FALSE,                 /* pc_relative */
1809          0,                     /* bitpos */
1810          complain_overflow_signed, /* complain_on_overflow */
1811          ppc64_elf_unhandled_reloc, /* special_function */
1812          "R_PPC64_GOT_TLSLD16_HA", /* name */
1813          FALSE,                 /* partial_inplace */
1814          0,                     /* src_mask */
1815          0xffff,                /* dst_mask */
1816          FALSE),                /* pcrel_offset */
1817
1818   /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1819      the offset to the entry relative to the TOC base (r2).  */
1820   HOWTO (R_PPC64_GOT_DTPREL16_DS,
1821          0,                     /* rightshift */
1822          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1823          16,                    /* bitsize */
1824          FALSE,                 /* pc_relative */
1825          0,                     /* bitpos */
1826          complain_overflow_signed, /* complain_on_overflow */
1827          ppc64_elf_unhandled_reloc, /* special_function */
1828          "R_PPC64_GOT_DTPREL16_DS", /* name */
1829          FALSE,                 /* partial_inplace */
1830          0,                     /* src_mask */
1831          0xfffc,                /* dst_mask */
1832          FALSE),                /* pcrel_offset */
1833
1834   /* Like GOT_DTPREL16_DS, but no overflow.  */
1835   HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1836          0,                     /* rightshift */
1837          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1838          16,                    /* bitsize */
1839          FALSE,                 /* pc_relative */
1840          0,                     /* bitpos */
1841          complain_overflow_dont, /* complain_on_overflow */
1842          ppc64_elf_unhandled_reloc, /* special_function */
1843          "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1844          FALSE,                 /* partial_inplace */
1845          0,                     /* src_mask */
1846          0xfffc,                /* dst_mask */
1847          FALSE),                /* pcrel_offset */
1848
1849   /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits.  */
1850   HOWTO (R_PPC64_GOT_DTPREL16_HI,
1851          16,                    /* rightshift */
1852          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1853          16,                    /* bitsize */
1854          FALSE,                 /* pc_relative */
1855          0,                     /* bitpos */
1856          complain_overflow_signed, /* complain_on_overflow */
1857          ppc64_elf_unhandled_reloc, /* special_function */
1858          "R_PPC64_GOT_DTPREL16_HI", /* name */
1859          FALSE,                 /* partial_inplace */
1860          0,                     /* src_mask */
1861          0xffff,                /* dst_mask */
1862          FALSE),                /* pcrel_offset */
1863
1864   /* Like GOT_DTPREL16_HI, but adjust for low 16 bits.  */
1865   HOWTO (R_PPC64_GOT_DTPREL16_HA,
1866          16,                    /* rightshift */
1867          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1868          16,                    /* bitsize */
1869          FALSE,                 /* pc_relative */
1870          0,                     /* bitpos */
1871          complain_overflow_signed, /* complain_on_overflow */
1872          ppc64_elf_unhandled_reloc, /* special_function */
1873          "R_PPC64_GOT_DTPREL16_HA", /* name */
1874          FALSE,                 /* partial_inplace */
1875          0,                     /* src_mask */
1876          0xffff,                /* dst_mask */
1877          FALSE),                /* pcrel_offset */
1878
1879   /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1880      offset to the entry relative to the TOC base (r2).  */
1881   HOWTO (R_PPC64_GOT_TPREL16_DS,
1882          0,                     /* rightshift */
1883          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1884          16,                    /* bitsize */
1885          FALSE,                 /* pc_relative */
1886          0,                     /* bitpos */
1887          complain_overflow_signed, /* complain_on_overflow */
1888          ppc64_elf_unhandled_reloc, /* special_function */
1889          "R_PPC64_GOT_TPREL16_DS", /* name */
1890          FALSE,                 /* partial_inplace */
1891          0,                     /* src_mask */
1892          0xfffc,                /* dst_mask */
1893          FALSE),                /* pcrel_offset */
1894
1895   /* Like GOT_TPREL16_DS, but no overflow.  */
1896   HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1897          0,                     /* rightshift */
1898          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1899          16,                    /* bitsize */
1900          FALSE,                 /* pc_relative */
1901          0,                     /* bitpos */
1902          complain_overflow_dont, /* complain_on_overflow */
1903          ppc64_elf_unhandled_reloc, /* special_function */
1904          "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1905          FALSE,                 /* partial_inplace */
1906          0,                     /* src_mask */
1907          0xfffc,                /* dst_mask */
1908          FALSE),                /* pcrel_offset */
1909
1910   /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits.  */
1911   HOWTO (R_PPC64_GOT_TPREL16_HI,
1912          16,                    /* rightshift */
1913          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1914          16,                    /* bitsize */
1915          FALSE,                 /* pc_relative */
1916          0,                     /* bitpos */
1917          complain_overflow_signed, /* complain_on_overflow */
1918          ppc64_elf_unhandled_reloc, /* special_function */
1919          "R_PPC64_GOT_TPREL16_HI", /* name */
1920          FALSE,                 /* partial_inplace */
1921          0,                     /* src_mask */
1922          0xffff,                /* dst_mask */
1923          FALSE),                /* pcrel_offset */
1924
1925   /* Like GOT_TPREL16_HI, but adjust for low 16 bits.  */
1926   HOWTO (R_PPC64_GOT_TPREL16_HA,
1927          16,                    /* rightshift */
1928          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1929          16,                    /* bitsize */
1930          FALSE,                 /* pc_relative */
1931          0,                     /* bitpos */
1932          complain_overflow_signed, /* complain_on_overflow */
1933          ppc64_elf_unhandled_reloc, /* special_function */
1934          "R_PPC64_GOT_TPREL16_HA", /* name */
1935          FALSE,                 /* partial_inplace */
1936          0,                     /* src_mask */
1937          0xffff,                /* dst_mask */
1938          FALSE),                /* pcrel_offset */
1939
1940   HOWTO (R_PPC64_JMP_IREL,      /* type */
1941          0,                     /* rightshift */
1942          0,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1943          0,                     /* bitsize */
1944          FALSE,                 /* pc_relative */
1945          0,                     /* bitpos */
1946          complain_overflow_dont, /* complain_on_overflow */
1947          ppc64_elf_unhandled_reloc, /* special_function */
1948          "R_PPC64_JMP_IREL",    /* name */
1949          FALSE,                 /* partial_inplace */
1950          0,                     /* src_mask */
1951          0,                     /* dst_mask */
1952          FALSE),                /* pcrel_offset */
1953
1954   HOWTO (R_PPC64_IRELATIVE,     /* type */
1955          0,                     /* rightshift */
1956          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1957          64,                    /* bitsize */
1958          FALSE,                 /* pc_relative */
1959          0,                     /* bitpos */
1960          complain_overflow_dont, /* complain_on_overflow */
1961          bfd_elf_generic_reloc, /* special_function */
1962          "R_PPC64_IRELATIVE",   /* name */
1963          FALSE,                 /* partial_inplace */
1964          0,                     /* src_mask */
1965          ONES (64),             /* dst_mask */
1966          FALSE),                /* pcrel_offset */
1967
1968   /* A 16 bit relative relocation.  */
1969   HOWTO (R_PPC64_REL16,         /* type */
1970          0,                     /* rightshift */
1971          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1972          16,                    /* bitsize */
1973          TRUE,                  /* pc_relative */
1974          0,                     /* bitpos */
1975          complain_overflow_signed, /* complain_on_overflow */
1976          bfd_elf_generic_reloc, /* special_function */
1977          "R_PPC64_REL16",       /* name */
1978          FALSE,                 /* partial_inplace */
1979          0,                     /* src_mask */
1980          0xffff,                /* dst_mask */
1981          TRUE),                 /* pcrel_offset */
1982
1983   /* A 16 bit relative relocation without overflow.  */
1984   HOWTO (R_PPC64_REL16_LO,      /* type */
1985          0,                     /* rightshift */
1986          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1987          16,                    /* bitsize */
1988          TRUE,                  /* pc_relative */
1989          0,                     /* bitpos */
1990          complain_overflow_dont,/* complain_on_overflow */
1991          bfd_elf_generic_reloc, /* special_function */
1992          "R_PPC64_REL16_LO",    /* name */
1993          FALSE,                 /* partial_inplace */
1994          0,                     /* src_mask */
1995          0xffff,                /* dst_mask */
1996          TRUE),                 /* pcrel_offset */
1997
1998   /* The high order 16 bits of a relative address.  */
1999   HOWTO (R_PPC64_REL16_HI,      /* type */
2000          16,                    /* rightshift */
2001          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2002          16,                    /* bitsize */
2003          TRUE,                  /* pc_relative */
2004          0,                     /* bitpos */
2005          complain_overflow_signed, /* complain_on_overflow */
2006          bfd_elf_generic_reloc, /* special_function */
2007          "R_PPC64_REL16_HI",    /* name */
2008          FALSE,                 /* partial_inplace */
2009          0,                     /* src_mask */
2010          0xffff,                /* dst_mask */
2011          TRUE),                 /* pcrel_offset */
2012
2013   /* The high order 16 bits of a relative address, plus 1 if the contents of
2014      the low 16 bits, treated as a signed number, is negative.  */
2015   HOWTO (R_PPC64_REL16_HA,      /* type */
2016          16,                    /* rightshift */
2017          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2018          16,                    /* bitsize */
2019          TRUE,                  /* pc_relative */
2020          0,                     /* bitpos */
2021          complain_overflow_signed, /* complain_on_overflow */
2022          ppc64_elf_ha_reloc,    /* special_function */
2023          "R_PPC64_REL16_HA",    /* name */
2024          FALSE,                 /* partial_inplace */
2025          0,                     /* src_mask */
2026          0xffff,                /* dst_mask */
2027          TRUE),                 /* pcrel_offset */
2028
2029   /* Like R_PPC64_REL16_HA but for split field in addpcis.  */
2030   HOWTO (R_PPC64_REL16DX_HA,    /* type */
2031          16,                    /* rightshift */
2032          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2033          16,                    /* bitsize */
2034          TRUE,                  /* pc_relative */
2035          0,                     /* bitpos */
2036          complain_overflow_signed, /* complain_on_overflow */
2037          ppc64_elf_ha_reloc,    /* special_function */
2038          "R_PPC64_REL16DX_HA",  /* name */
2039          FALSE,                 /* partial_inplace */
2040          0,                     /* src_mask */
2041          0x1fffc1,              /* dst_mask */
2042          TRUE),                 /* pcrel_offset */
2043
2044   /* Like R_PPC64_ADDR16_HI, but no overflow.  */
2045   HOWTO (R_PPC64_ADDR16_HIGH,   /* type */
2046          16,                    /* rightshift */
2047          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2048          16,                    /* bitsize */
2049          FALSE,                 /* pc_relative */
2050          0,                     /* bitpos */
2051          complain_overflow_dont, /* complain_on_overflow */
2052          bfd_elf_generic_reloc, /* special_function */
2053          "R_PPC64_ADDR16_HIGH", /* name */
2054          FALSE,                 /* partial_inplace */
2055          0,                     /* src_mask */
2056          0xffff,                /* dst_mask */
2057          FALSE),                /* pcrel_offset */
2058
2059   /* Like R_PPC64_ADDR16_HA, but no overflow.  */
2060   HOWTO (R_PPC64_ADDR16_HIGHA,  /* type */
2061          16,                    /* rightshift */
2062          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2063          16,                    /* bitsize */
2064          FALSE,                 /* pc_relative */
2065          0,                     /* bitpos */
2066          complain_overflow_dont, /* complain_on_overflow */
2067          ppc64_elf_ha_reloc,    /* special_function */
2068          "R_PPC64_ADDR16_HIGHA",        /* name */
2069          FALSE,                 /* partial_inplace */
2070          0,                     /* src_mask */
2071          0xffff,                /* dst_mask */
2072          FALSE),                /* pcrel_offset */
2073
2074   /* Like R_PPC64_DTPREL16_HI, but no overflow.  */
2075   HOWTO (R_PPC64_DTPREL16_HIGH,
2076          16,                    /* rightshift */
2077          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2078          16,                    /* bitsize */
2079          FALSE,                 /* pc_relative */
2080          0,                     /* bitpos */
2081          complain_overflow_dont, /* complain_on_overflow */
2082          ppc64_elf_unhandled_reloc, /* special_function */
2083          "R_PPC64_DTPREL16_HIGH", /* name */
2084          FALSE,                 /* partial_inplace */
2085          0,                     /* src_mask */
2086          0xffff,                /* dst_mask */
2087          FALSE),                /* pcrel_offset */
2088
2089   /* Like R_PPC64_DTPREL16_HA, but no overflow.  */
2090   HOWTO (R_PPC64_DTPREL16_HIGHA,
2091          16,                    /* rightshift */
2092          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2093          16,                    /* bitsize */
2094          FALSE,                 /* pc_relative */
2095          0,                     /* bitpos */
2096          complain_overflow_dont, /* complain_on_overflow */
2097          ppc64_elf_unhandled_reloc, /* special_function */
2098          "R_PPC64_DTPREL16_HIGHA", /* name */
2099          FALSE,                 /* partial_inplace */
2100          0,                     /* src_mask */
2101          0xffff,                /* dst_mask */
2102          FALSE),                /* pcrel_offset */
2103
2104   /* Like R_PPC64_TPREL16_HI, but no overflow.  */
2105   HOWTO (R_PPC64_TPREL16_HIGH,
2106          16,                    /* rightshift */
2107          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2108          16,                    /* bitsize */
2109          FALSE,                 /* pc_relative */
2110          0,                     /* bitpos */
2111          complain_overflow_dont, /* complain_on_overflow */
2112          ppc64_elf_unhandled_reloc, /* special_function */
2113          "R_PPC64_TPREL16_HIGH",        /* name */
2114          FALSE,                 /* partial_inplace */
2115          0,                     /* src_mask */
2116          0xffff,                /* dst_mask */
2117          FALSE),                /* pcrel_offset */
2118
2119   /* Like R_PPC64_TPREL16_HA, but no overflow.  */
2120   HOWTO (R_PPC64_TPREL16_HIGHA,
2121          16,                    /* rightshift */
2122          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2123          16,                    /* bitsize */
2124          FALSE,                 /* pc_relative */
2125          0,                     /* bitpos */
2126          complain_overflow_dont, /* complain_on_overflow */
2127          ppc64_elf_unhandled_reloc, /* special_function */
2128          "R_PPC64_TPREL16_HIGHA",       /* name */
2129          FALSE,                 /* partial_inplace */
2130          0,                     /* src_mask */
2131          0xffff,                /* dst_mask */
2132          FALSE),                /* pcrel_offset */
2133
2134   /* Marker reloc on ELFv2 large-model function entry.  */
2135   HOWTO (R_PPC64_ENTRY,
2136          0,                     /* rightshift */
2137          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2138          32,                    /* bitsize */
2139          FALSE,                 /* pc_relative */
2140          0,                     /* bitpos */
2141          complain_overflow_dont, /* complain_on_overflow */
2142          bfd_elf_generic_reloc, /* special_function */
2143          "R_PPC64_ENTRY",       /* name */
2144          FALSE,                 /* partial_inplace */
2145          0,                     /* src_mask */
2146          0,                     /* dst_mask */
2147          FALSE),                /* pcrel_offset */
2148
2149   /* Like ADDR64, but use local entry point of function.  */
2150   HOWTO (R_PPC64_ADDR64_LOCAL,  /* type */
2151          0,                     /* rightshift */
2152          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2153          64,                    /* bitsize */
2154          FALSE,                 /* pc_relative */
2155          0,                     /* bitpos */
2156          complain_overflow_dont, /* complain_on_overflow */
2157          bfd_elf_generic_reloc, /* special_function */
2158          "R_PPC64_ADDR64_LOCAL", /* name */
2159          FALSE,                 /* partial_inplace */
2160          0,                     /* src_mask */
2161          ONES (64),             /* dst_mask */
2162          FALSE),                /* pcrel_offset */
2163
2164   /* GNU extension to record C++ vtable hierarchy.  */
2165   HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2166          0,                     /* rightshift */
2167          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2168          0,                     /* bitsize */
2169          FALSE,                 /* pc_relative */
2170          0,                     /* bitpos */
2171          complain_overflow_dont, /* complain_on_overflow */
2172          NULL,                  /* special_function */
2173          "R_PPC64_GNU_VTINHERIT", /* name */
2174          FALSE,                 /* partial_inplace */
2175          0,                     /* src_mask */
2176          0,                     /* dst_mask */
2177          FALSE),                /* pcrel_offset */
2178
2179   /* GNU extension to record C++ vtable member usage.  */
2180   HOWTO (R_PPC64_GNU_VTENTRY,   /* type */
2181          0,                     /* rightshift */
2182          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2183          0,                     /* bitsize */
2184          FALSE,                 /* pc_relative */
2185          0,                     /* bitpos */
2186          complain_overflow_dont, /* complain_on_overflow */
2187          NULL,                  /* special_function */
2188          "R_PPC64_GNU_VTENTRY", /* name */
2189          FALSE,                 /* partial_inplace */
2190          0,                     /* src_mask */
2191          0,                     /* dst_mask */
2192          FALSE),                /* pcrel_offset */
2193 };
2194
2195 \f
2196 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2197    be done.  */
2198
2199 static void
2200 ppc_howto_init (void)
2201 {
2202   unsigned int i, type;
2203
2204   for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2205     {
2206       type = ppc64_elf_howto_raw[i].type;
2207       BFD_ASSERT (type < ARRAY_SIZE (ppc64_elf_howto_table));
2208       ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2209     }
2210 }
2211
2212 static reloc_howto_type *
2213 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2214                              bfd_reloc_code_real_type code)
2215 {
2216   enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2217
2218   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2219     /* Initialize howto table if needed.  */
2220     ppc_howto_init ();
2221
2222   switch (code)
2223     {
2224     default:
2225       return NULL;
2226
2227     case BFD_RELOC_NONE:                        r = R_PPC64_NONE;
2228       break;
2229     case BFD_RELOC_32:                          r = R_PPC64_ADDR32;
2230       break;
2231     case BFD_RELOC_PPC_BA26:                    r = R_PPC64_ADDR24;
2232       break;
2233     case BFD_RELOC_16:                          r = R_PPC64_ADDR16;
2234       break;
2235     case BFD_RELOC_LO16:                        r = R_PPC64_ADDR16_LO;
2236       break;
2237     case BFD_RELOC_HI16:                        r = R_PPC64_ADDR16_HI;
2238       break;
2239     case BFD_RELOC_PPC64_ADDR16_HIGH:           r = R_PPC64_ADDR16_HIGH;
2240       break;
2241     case BFD_RELOC_HI16_S:                      r = R_PPC64_ADDR16_HA;
2242       break;
2243     case BFD_RELOC_PPC64_ADDR16_HIGHA:          r = R_PPC64_ADDR16_HIGHA;
2244       break;
2245     case BFD_RELOC_PPC_BA16:                    r = R_PPC64_ADDR14;
2246       break;
2247     case BFD_RELOC_PPC_BA16_BRTAKEN:            r = R_PPC64_ADDR14_BRTAKEN;
2248       break;
2249     case BFD_RELOC_PPC_BA16_BRNTAKEN:           r = R_PPC64_ADDR14_BRNTAKEN;
2250       break;
2251     case BFD_RELOC_PPC_B26:                     r = R_PPC64_REL24;
2252       break;
2253     case BFD_RELOC_PPC_B16:                     r = R_PPC64_REL14;
2254       break;
2255     case BFD_RELOC_PPC_B16_BRTAKEN:             r = R_PPC64_REL14_BRTAKEN;
2256       break;
2257     case BFD_RELOC_PPC_B16_BRNTAKEN:            r = R_PPC64_REL14_BRNTAKEN;
2258       break;
2259     case BFD_RELOC_16_GOTOFF:                   r = R_PPC64_GOT16;
2260       break;
2261     case BFD_RELOC_LO16_GOTOFF:                 r = R_PPC64_GOT16_LO;
2262       break;
2263     case BFD_RELOC_HI16_GOTOFF:                 r = R_PPC64_GOT16_HI;
2264       break;
2265     case BFD_RELOC_HI16_S_GOTOFF:               r = R_PPC64_GOT16_HA;
2266       break;
2267     case BFD_RELOC_PPC_COPY:                    r = R_PPC64_COPY;
2268       break;
2269     case BFD_RELOC_PPC_GLOB_DAT:                r = R_PPC64_GLOB_DAT;
2270       break;
2271     case BFD_RELOC_32_PCREL:                    r = R_PPC64_REL32;
2272       break;
2273     case BFD_RELOC_32_PLTOFF:                   r = R_PPC64_PLT32;
2274       break;
2275     case BFD_RELOC_32_PLT_PCREL:                r = R_PPC64_PLTREL32;
2276       break;
2277     case BFD_RELOC_LO16_PLTOFF:                 r = R_PPC64_PLT16_LO;
2278       break;
2279     case BFD_RELOC_HI16_PLTOFF:                 r = R_PPC64_PLT16_HI;
2280       break;
2281     case BFD_RELOC_HI16_S_PLTOFF:               r = R_PPC64_PLT16_HA;
2282       break;
2283     case BFD_RELOC_16_BASEREL:                  r = R_PPC64_SECTOFF;
2284       break;
2285     case BFD_RELOC_LO16_BASEREL:                r = R_PPC64_SECTOFF_LO;
2286       break;
2287     case BFD_RELOC_HI16_BASEREL:                r = R_PPC64_SECTOFF_HI;
2288       break;
2289     case BFD_RELOC_HI16_S_BASEREL:              r = R_PPC64_SECTOFF_HA;
2290       break;
2291     case BFD_RELOC_CTOR:                        r = R_PPC64_ADDR64;
2292       break;
2293     case BFD_RELOC_64:                          r = R_PPC64_ADDR64;
2294       break;
2295     case BFD_RELOC_PPC64_HIGHER:                r = R_PPC64_ADDR16_HIGHER;
2296       break;
2297     case BFD_RELOC_PPC64_HIGHER_S:              r = R_PPC64_ADDR16_HIGHERA;
2298       break;
2299     case BFD_RELOC_PPC64_HIGHEST:               r = R_PPC64_ADDR16_HIGHEST;
2300       break;
2301     case BFD_RELOC_PPC64_HIGHEST_S:             r = R_PPC64_ADDR16_HIGHESTA;
2302       break;
2303     case BFD_RELOC_64_PCREL:                    r = R_PPC64_REL64;
2304       break;
2305     case BFD_RELOC_64_PLTOFF:                   r = R_PPC64_PLT64;
2306       break;
2307     case BFD_RELOC_64_PLT_PCREL:                r = R_PPC64_PLTREL64;
2308       break;
2309     case BFD_RELOC_PPC_TOC16:                   r = R_PPC64_TOC16;
2310       break;
2311     case BFD_RELOC_PPC64_TOC16_LO:              r = R_PPC64_TOC16_LO;
2312       break;
2313     case BFD_RELOC_PPC64_TOC16_HI:              r = R_PPC64_TOC16_HI;
2314       break;
2315     case BFD_RELOC_PPC64_TOC16_HA:              r = R_PPC64_TOC16_HA;
2316       break;
2317     case BFD_RELOC_PPC64_TOC:                   r = R_PPC64_TOC;
2318       break;
2319     case BFD_RELOC_PPC64_PLTGOT16:              r = R_PPC64_PLTGOT16;
2320       break;
2321     case BFD_RELOC_PPC64_PLTGOT16_LO:           r = R_PPC64_PLTGOT16_LO;
2322       break;
2323     case BFD_RELOC_PPC64_PLTGOT16_HI:           r = R_PPC64_PLTGOT16_HI;
2324       break;
2325     case BFD_RELOC_PPC64_PLTGOT16_HA:           r = R_PPC64_PLTGOT16_HA;
2326       break;
2327     case BFD_RELOC_PPC64_ADDR16_DS:             r = R_PPC64_ADDR16_DS;
2328       break;
2329     case BFD_RELOC_PPC64_ADDR16_LO_DS:          r = R_PPC64_ADDR16_LO_DS;
2330       break;
2331     case BFD_RELOC_PPC64_GOT16_DS:              r = R_PPC64_GOT16_DS;
2332       break;
2333     case BFD_RELOC_PPC64_GOT16_LO_DS:           r = R_PPC64_GOT16_LO_DS;
2334       break;
2335     case BFD_RELOC_PPC64_PLT16_LO_DS:           r = R_PPC64_PLT16_LO_DS;
2336       break;
2337     case BFD_RELOC_PPC64_SECTOFF_DS:            r = R_PPC64_SECTOFF_DS;
2338       break;
2339     case BFD_RELOC_PPC64_SECTOFF_LO_DS:         r = R_PPC64_SECTOFF_LO_DS;
2340       break;
2341     case BFD_RELOC_PPC64_TOC16_DS:              r = R_PPC64_TOC16_DS;
2342       break;
2343     case BFD_RELOC_PPC64_TOC16_LO_DS:           r = R_PPC64_TOC16_LO_DS;
2344       break;
2345     case BFD_RELOC_PPC64_PLTGOT16_DS:           r = R_PPC64_PLTGOT16_DS;
2346       break;
2347     case BFD_RELOC_PPC64_PLTGOT16_LO_DS:        r = R_PPC64_PLTGOT16_LO_DS;
2348       break;
2349     case BFD_RELOC_PPC_TLS:                     r = R_PPC64_TLS;
2350       break;
2351     case BFD_RELOC_PPC_TLSGD:                   r = R_PPC64_TLSGD;
2352       break;
2353     case BFD_RELOC_PPC_TLSLD:                   r = R_PPC64_TLSLD;
2354       break;
2355     case BFD_RELOC_PPC_DTPMOD:                  r = R_PPC64_DTPMOD64;
2356       break;
2357     case BFD_RELOC_PPC_TPREL16:                 r = R_PPC64_TPREL16;
2358       break;
2359     case BFD_RELOC_PPC_TPREL16_LO:              r = R_PPC64_TPREL16_LO;
2360       break;
2361     case BFD_RELOC_PPC_TPREL16_HI:              r = R_PPC64_TPREL16_HI;
2362       break;
2363     case BFD_RELOC_PPC64_TPREL16_HIGH:          r = R_PPC64_TPREL16_HIGH;
2364       break;
2365     case BFD_RELOC_PPC_TPREL16_HA:              r = R_PPC64_TPREL16_HA;
2366       break;
2367     case BFD_RELOC_PPC64_TPREL16_HIGHA:         r = R_PPC64_TPREL16_HIGHA;
2368       break;
2369     case BFD_RELOC_PPC_TPREL:                   r = R_PPC64_TPREL64;
2370       break;
2371     case BFD_RELOC_PPC_DTPREL16:                r = R_PPC64_DTPREL16;
2372       break;
2373     case BFD_RELOC_PPC_DTPREL16_LO:             r = R_PPC64_DTPREL16_LO;
2374       break;
2375     case BFD_RELOC_PPC_DTPREL16_HI:             r = R_PPC64_DTPREL16_HI;
2376       break;
2377     case BFD_RELOC_PPC64_DTPREL16_HIGH:         r = R_PPC64_DTPREL16_HIGH;
2378       break;
2379     case BFD_RELOC_PPC_DTPREL16_HA:             r = R_PPC64_DTPREL16_HA;
2380       break;
2381     case BFD_RELOC_PPC64_DTPREL16_HIGHA:        r = R_PPC64_DTPREL16_HIGHA;
2382       break;
2383     case BFD_RELOC_PPC_DTPREL:                  r = R_PPC64_DTPREL64;
2384       break;
2385     case BFD_RELOC_PPC_GOT_TLSGD16:             r = R_PPC64_GOT_TLSGD16;
2386       break;
2387     case BFD_RELOC_PPC_GOT_TLSGD16_LO:          r = R_PPC64_GOT_TLSGD16_LO;
2388       break;
2389     case BFD_RELOC_PPC_GOT_TLSGD16_HI:          r = R_PPC64_GOT_TLSGD16_HI;
2390       break;
2391     case BFD_RELOC_PPC_GOT_TLSGD16_HA:          r = R_PPC64_GOT_TLSGD16_HA;
2392       break;
2393     case BFD_RELOC_PPC_GOT_TLSLD16:             r = R_PPC64_GOT_TLSLD16;
2394       break;
2395     case BFD_RELOC_PPC_GOT_TLSLD16_LO:          r = R_PPC64_GOT_TLSLD16_LO;
2396       break;
2397     case BFD_RELOC_PPC_GOT_TLSLD16_HI:          r = R_PPC64_GOT_TLSLD16_HI;
2398       break;
2399     case BFD_RELOC_PPC_GOT_TLSLD16_HA:          r = R_PPC64_GOT_TLSLD16_HA;
2400       break;
2401     case BFD_RELOC_PPC_GOT_TPREL16:             r = R_PPC64_GOT_TPREL16_DS;
2402       break;
2403     case BFD_RELOC_PPC_GOT_TPREL16_LO:          r = R_PPC64_GOT_TPREL16_LO_DS;
2404       break;
2405     case BFD_RELOC_PPC_GOT_TPREL16_HI:          r = R_PPC64_GOT_TPREL16_HI;
2406       break;
2407     case BFD_RELOC_PPC_GOT_TPREL16_HA:          r = R_PPC64_GOT_TPREL16_HA;
2408       break;
2409     case BFD_RELOC_PPC_GOT_DTPREL16:            r = R_PPC64_GOT_DTPREL16_DS;
2410       break;
2411     case BFD_RELOC_PPC_GOT_DTPREL16_LO:         r = R_PPC64_GOT_DTPREL16_LO_DS;
2412       break;
2413     case BFD_RELOC_PPC_GOT_DTPREL16_HI:         r = R_PPC64_GOT_DTPREL16_HI;
2414       break;
2415     case BFD_RELOC_PPC_GOT_DTPREL16_HA:         r = R_PPC64_GOT_DTPREL16_HA;
2416       break;
2417     case BFD_RELOC_PPC64_TPREL16_DS:            r = R_PPC64_TPREL16_DS;
2418       break;
2419     case BFD_RELOC_PPC64_TPREL16_LO_DS:         r = R_PPC64_TPREL16_LO_DS;
2420       break;
2421     case BFD_RELOC_PPC64_TPREL16_HIGHER:        r = R_PPC64_TPREL16_HIGHER;
2422       break;
2423     case BFD_RELOC_PPC64_TPREL16_HIGHERA:       r = R_PPC64_TPREL16_HIGHERA;
2424       break;
2425     case BFD_RELOC_PPC64_TPREL16_HIGHEST:       r = R_PPC64_TPREL16_HIGHEST;
2426       break;
2427     case BFD_RELOC_PPC64_TPREL16_HIGHESTA:      r = R_PPC64_TPREL16_HIGHESTA;
2428       break;
2429     case BFD_RELOC_PPC64_DTPREL16_DS:           r = R_PPC64_DTPREL16_DS;
2430       break;
2431     case BFD_RELOC_PPC64_DTPREL16_LO_DS:        r = R_PPC64_DTPREL16_LO_DS;
2432       break;
2433     case BFD_RELOC_PPC64_DTPREL16_HIGHER:       r = R_PPC64_DTPREL16_HIGHER;
2434       break;
2435     case BFD_RELOC_PPC64_DTPREL16_HIGHERA:      r = R_PPC64_DTPREL16_HIGHERA;
2436       break;
2437     case BFD_RELOC_PPC64_DTPREL16_HIGHEST:      r = R_PPC64_DTPREL16_HIGHEST;
2438       break;
2439     case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:     r = R_PPC64_DTPREL16_HIGHESTA;
2440       break;
2441     case BFD_RELOC_16_PCREL:                    r = R_PPC64_REL16;
2442       break;
2443     case BFD_RELOC_LO16_PCREL:                  r = R_PPC64_REL16_LO;
2444       break;
2445     case BFD_RELOC_HI16_PCREL:                  r = R_PPC64_REL16_HI;
2446       break;
2447     case BFD_RELOC_HI16_S_PCREL:                r = R_PPC64_REL16_HA;
2448       break;
2449     case BFD_RELOC_PPC_REL16DX_HA:              r = R_PPC64_REL16DX_HA;
2450       break;
2451     case BFD_RELOC_PPC64_ENTRY:                 r = R_PPC64_ENTRY;
2452       break;
2453     case BFD_RELOC_PPC64_ADDR64_LOCAL:          r = R_PPC64_ADDR64_LOCAL;
2454       break;
2455     case BFD_RELOC_VTABLE_INHERIT:              r = R_PPC64_GNU_VTINHERIT;
2456       break;
2457     case BFD_RELOC_VTABLE_ENTRY:                r = R_PPC64_GNU_VTENTRY;
2458       break;
2459     }
2460
2461   return ppc64_elf_howto_table[r];
2462 };
2463
2464 static reloc_howto_type *
2465 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2466                              const char *r_name)
2467 {
2468   unsigned int i;
2469
2470   for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2471     if (ppc64_elf_howto_raw[i].name != NULL
2472         && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2473       return &ppc64_elf_howto_raw[i];
2474
2475   return NULL;
2476 }
2477
2478 /* Set the howto pointer for a PowerPC ELF reloc.  */
2479
2480 static void
2481 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2482                          Elf_Internal_Rela *dst)
2483 {
2484   unsigned int type;
2485
2486   /* Initialize howto table if needed.  */
2487   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2488     ppc_howto_init ();
2489
2490   type = ELF64_R_TYPE (dst->r_info);
2491   if (type >= ARRAY_SIZE (ppc64_elf_howto_table))
2492     {
2493       (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
2494                              abfd, (int) type);
2495       type = R_PPC64_NONE;
2496     }
2497   cache_ptr->howto = ppc64_elf_howto_table[type];
2498 }
2499
2500 /* Handle the R_PPC64_ADDR16_HA and similar relocs.  */
2501
2502 static bfd_reloc_status_type
2503 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2504                     void *data, asection *input_section,
2505                     bfd *output_bfd, char **error_message)
2506 {
2507   enum elf_ppc64_reloc_type r_type;
2508   long insn;
2509   bfd_size_type octets;
2510   bfd_vma value;
2511
2512   /* If this is a relocatable link (output_bfd test tells us), just
2513      call the generic function.  Any adjustment will be done at final
2514      link time.  */
2515   if (output_bfd != NULL)
2516     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2517                                   input_section, output_bfd, error_message);
2518
2519   /* Adjust the addend for sign extension of the low 16 bits.
2520      We won't actually be using the low 16 bits, so trashing them
2521      doesn't matter.  */
2522   reloc_entry->addend += 0x8000;
2523   r_type = reloc_entry->howto->type;
2524   if (r_type != R_PPC64_REL16DX_HA)
2525     return bfd_reloc_continue;
2526
2527   value = 0;
2528   if (!bfd_is_com_section (symbol->section))
2529     value = symbol->value;
2530   value += (reloc_entry->addend
2531             + symbol->section->output_offset
2532             + symbol->section->output_section->vma);
2533   value -= (reloc_entry->address
2534             + input_section->output_offset
2535             + input_section->output_section->vma);
2536   value = (bfd_signed_vma) value >> 16;
2537
2538   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2539   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2540   insn &= ~0x1fffc1;
2541   insn |= (value & 0xffc1) | ((value & 0x3e) << 15);
2542   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2543   if (value + 0x8000 > 0xffff)
2544     return bfd_reloc_overflow;
2545   return bfd_reloc_ok;
2546 }
2547
2548 static bfd_reloc_status_type
2549 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2550                         void *data, asection *input_section,
2551                         bfd *output_bfd, char **error_message)
2552 {
2553   if (output_bfd != NULL)
2554     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2555                                   input_section, output_bfd, error_message);
2556
2557   if (strcmp (symbol->section->name, ".opd") == 0
2558       && (symbol->section->owner->flags & DYNAMIC) == 0)
2559     {
2560       bfd_vma dest = opd_entry_value (symbol->section,
2561                                       symbol->value + reloc_entry->addend,
2562                                       NULL, NULL, FALSE);
2563       if (dest != (bfd_vma) -1)
2564         reloc_entry->addend = dest - (symbol->value
2565                                       + symbol->section->output_section->vma
2566                                       + symbol->section->output_offset);
2567     }
2568   else
2569     {
2570       elf_symbol_type *elfsym = (elf_symbol_type *) symbol;
2571
2572       if (symbol->section->owner != abfd
2573           && symbol->section->owner != NULL
2574           && abiversion (symbol->section->owner) >= 2)
2575         {
2576           unsigned int i;
2577
2578           for (i = 0; i < symbol->section->owner->symcount; ++i)
2579             {
2580               asymbol *symdef = symbol->section->owner->outsymbols[i];
2581
2582               if (strcmp (symdef->name, symbol->name) == 0)
2583                 {
2584                   elfsym = (elf_symbol_type *) symdef;
2585                   break;
2586                 }
2587             }
2588         }
2589       reloc_entry->addend
2590         += PPC64_LOCAL_ENTRY_OFFSET (elfsym->internal_elf_sym.st_other);
2591     }
2592   return bfd_reloc_continue;
2593 }
2594
2595 static bfd_reloc_status_type
2596 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2597                          void *data, asection *input_section,
2598                          bfd *output_bfd, char **error_message)
2599 {
2600   long insn;
2601   enum elf_ppc64_reloc_type r_type;
2602   bfd_size_type octets;
2603   /* Assume 'at' branch hints.  */
2604   bfd_boolean is_isa_v2 = TRUE;
2605
2606   /* If this is a relocatable link (output_bfd test tells us), just
2607      call the generic function.  Any adjustment will be done at final
2608      link time.  */
2609   if (output_bfd != NULL)
2610     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2611                                   input_section, output_bfd, error_message);
2612
2613   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2614   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2615   insn &= ~(0x01 << 21);
2616   r_type = reloc_entry->howto->type;
2617   if (r_type == R_PPC64_ADDR14_BRTAKEN
2618       || r_type == R_PPC64_REL14_BRTAKEN)
2619     insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
2620
2621   if (is_isa_v2)
2622     {
2623       /* Set 'a' bit.  This is 0b00010 in BO field for branch
2624          on CR(BI) insns (BO == 001at or 011at), and 0b01000
2625          for branch on CTR insns (BO == 1a00t or 1a01t).  */
2626       if ((insn & (0x14 << 21)) == (0x04 << 21))
2627         insn |= 0x02 << 21;
2628       else if ((insn & (0x14 << 21)) == (0x10 << 21))
2629         insn |= 0x08 << 21;
2630       else
2631         goto out;
2632     }
2633   else
2634     {
2635       bfd_vma target = 0;
2636       bfd_vma from;
2637
2638       if (!bfd_is_com_section (symbol->section))
2639         target = symbol->value;
2640       target += symbol->section->output_section->vma;
2641       target += symbol->section->output_offset;
2642       target += reloc_entry->addend;
2643
2644       from = (reloc_entry->address
2645               + input_section->output_offset
2646               + input_section->output_section->vma);
2647
2648       /* Invert 'y' bit if not the default.  */
2649       if ((bfd_signed_vma) (target - from) < 0)
2650         insn ^= 0x01 << 21;
2651     }
2652   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2653  out:
2654   return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2655                                  input_section, output_bfd, error_message);
2656 }
2657
2658 static bfd_reloc_status_type
2659 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2660                          void *data, asection *input_section,
2661                          bfd *output_bfd, char **error_message)
2662 {
2663   /* If this is a relocatable link (output_bfd test tells us), just
2664      call the generic function.  Any adjustment will be done at final
2665      link time.  */
2666   if (output_bfd != NULL)
2667     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2668                                   input_section, output_bfd, error_message);
2669
2670   /* Subtract the symbol section base address.  */
2671   reloc_entry->addend -= symbol->section->output_section->vma;
2672   return bfd_reloc_continue;
2673 }
2674
2675 static bfd_reloc_status_type
2676 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2677                             void *data, asection *input_section,
2678                             bfd *output_bfd, char **error_message)
2679 {
2680   /* If this is a relocatable link (output_bfd test tells us), just
2681      call the generic function.  Any adjustment will be done at final
2682      link time.  */
2683   if (output_bfd != NULL)
2684     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2685                                   input_section, output_bfd, error_message);
2686
2687   /* Subtract the symbol section base address.  */
2688   reloc_entry->addend -= symbol->section->output_section->vma;
2689
2690   /* Adjust the addend for sign extension of the low 16 bits.  */
2691   reloc_entry->addend += 0x8000;
2692   return bfd_reloc_continue;
2693 }
2694
2695 static bfd_reloc_status_type
2696 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2697                      void *data, asection *input_section,
2698                      bfd *output_bfd, char **error_message)
2699 {
2700   bfd_vma TOCstart;
2701
2702   /* If this is a relocatable link (output_bfd test tells us), just
2703      call the generic function.  Any adjustment will be done at final
2704      link time.  */
2705   if (output_bfd != NULL)
2706     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2707                                   input_section, output_bfd, error_message);
2708
2709   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2710   if (TOCstart == 0)
2711     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2712
2713   /* Subtract the TOC base address.  */
2714   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2715   return bfd_reloc_continue;
2716 }
2717
2718 static bfd_reloc_status_type
2719 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2720                         void *data, asection *input_section,
2721                         bfd *output_bfd, char **error_message)
2722 {
2723   bfd_vma TOCstart;
2724
2725   /* If this is a relocatable link (output_bfd test tells us), just
2726      call the generic function.  Any adjustment will be done at final
2727      link time.  */
2728   if (output_bfd != NULL)
2729     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2730                                   input_section, output_bfd, error_message);
2731
2732   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2733   if (TOCstart == 0)
2734     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2735
2736   /* Subtract the TOC base address.  */
2737   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2738
2739   /* Adjust the addend for sign extension of the low 16 bits.  */
2740   reloc_entry->addend += 0x8000;
2741   return bfd_reloc_continue;
2742 }
2743
2744 static bfd_reloc_status_type
2745 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2746                        void *data, asection *input_section,
2747                        bfd *output_bfd, char **error_message)
2748 {
2749   bfd_vma TOCstart;
2750   bfd_size_type octets;
2751
2752   /* If this is a relocatable link (output_bfd test tells us), just
2753      call the generic function.  Any adjustment will be done at final
2754      link time.  */
2755   if (output_bfd != NULL)
2756     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2757                                   input_section, output_bfd, error_message);
2758
2759   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2760   if (TOCstart == 0)
2761     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2762
2763   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2764   bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2765   return bfd_reloc_ok;
2766 }
2767
2768 static bfd_reloc_status_type
2769 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2770                            void *data, asection *input_section,
2771                            bfd *output_bfd, char **error_message)
2772 {
2773   /* If this is a relocatable link (output_bfd test tells us), just
2774      call the generic function.  Any adjustment will be done at final
2775      link time.  */
2776   if (output_bfd != NULL)
2777     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2778                                   input_section, output_bfd, error_message);
2779
2780   if (error_message != NULL)
2781     {
2782       static char buf[60];
2783       sprintf (buf, "generic linker can't handle %s",
2784                reloc_entry->howto->name);
2785       *error_message = buf;
2786     }
2787   return bfd_reloc_dangerous;
2788 }
2789
2790 /* Track GOT entries needed for a given symbol.  We might need more
2791    than one got entry per symbol.  */
2792 struct got_entry
2793 {
2794   struct got_entry *next;
2795
2796   /* The symbol addend that we'll be placing in the GOT.  */
2797   bfd_vma addend;
2798
2799   /* Unlike other ELF targets, we use separate GOT entries for the same
2800      symbol referenced from different input files.  This is to support
2801      automatic multiple TOC/GOT sections, where the TOC base can vary
2802      from one input file to another.  After partitioning into TOC groups
2803      we merge entries within the group.
2804
2805      Point to the BFD owning this GOT entry.  */
2806   bfd *owner;
2807
2808   /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2809      TLS_TPREL or TLS_DTPREL for tls entries.  */
2810   unsigned char tls_type;
2811
2812   /* Non-zero if got.ent points to real entry.  */
2813   unsigned char is_indirect;
2814
2815   /* Reference count until size_dynamic_sections, GOT offset thereafter.  */
2816   union
2817     {
2818       bfd_signed_vma refcount;
2819       bfd_vma offset;
2820       struct got_entry *ent;
2821     } got;
2822 };
2823
2824 /* The same for PLT.  */
2825 struct plt_entry
2826 {
2827   struct plt_entry *next;
2828
2829   bfd_vma addend;
2830
2831   union
2832     {
2833       bfd_signed_vma refcount;
2834       bfd_vma offset;
2835     } plt;
2836 };
2837
2838 struct ppc64_elf_obj_tdata
2839 {
2840   struct elf_obj_tdata elf;
2841
2842   /* Shortcuts to dynamic linker sections.  */
2843   asection *got;
2844   asection *relgot;
2845
2846   /* Used during garbage collection.  We attach global symbols defined
2847      on removed .opd entries to this section so that the sym is removed.  */
2848   asection *deleted_section;
2849
2850   /* TLS local dynamic got entry handling.  Support for multiple GOT
2851      sections means we potentially need one of these for each input bfd.  */
2852   struct got_entry tlsld_got;
2853
2854   union {
2855     /* A copy of relocs before they are modified for --emit-relocs.  */
2856     Elf_Internal_Rela *relocs;
2857
2858     /* Section contents.  */
2859     bfd_byte *contents;
2860   } opd;
2861
2862   /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2863      the reloc to be in the range -32768 to 32767.  */
2864   unsigned int has_small_toc_reloc : 1;
2865
2866   /* Set if toc/got ha relocs detected not using r2, or lo reloc
2867      instruction not one we handle.  */
2868   unsigned int unexpected_toc_insn : 1;
2869 };
2870
2871 #define ppc64_elf_tdata(bfd) \
2872   ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2873
2874 #define ppc64_tlsld_got(bfd) \
2875   (&ppc64_elf_tdata (bfd)->tlsld_got)
2876
2877 #define is_ppc64_elf(bfd) \
2878   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2879    && elf_object_id (bfd) == PPC64_ELF_DATA)
2880
2881 /* Override the generic function because we store some extras.  */
2882
2883 static bfd_boolean
2884 ppc64_elf_mkobject (bfd *abfd)
2885 {
2886   return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2887                                   PPC64_ELF_DATA);
2888 }
2889
2890 /* Fix bad default arch selected for a 64 bit input bfd when the
2891    default is 32 bit.  Also select arch based on apuinfo.  */
2892
2893 static bfd_boolean
2894 ppc64_elf_object_p (bfd *abfd)
2895 {
2896   if (!abfd->arch_info->the_default)
2897     return TRUE;
2898
2899   if (abfd->arch_info->bits_per_word == 32)
2900     {
2901       Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2902
2903       if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2904         {
2905           /* Relies on arch after 32 bit default being 64 bit default.  */
2906           abfd->arch_info = abfd->arch_info->next;
2907           BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2908         }
2909     }
2910   return _bfd_elf_ppc_set_arch (abfd);
2911 }
2912
2913 /* Support for core dump NOTE sections.  */
2914
2915 static bfd_boolean
2916 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2917 {
2918   size_t offset, size;
2919
2920   if (note->descsz != 504)
2921     return FALSE;
2922
2923   /* pr_cursig */
2924   elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2925
2926   /* pr_pid */
2927   elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2928
2929   /* pr_reg */
2930   offset = 112;
2931   size = 384;
2932
2933   /* Make a ".reg/999" section.  */
2934   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2935                                           size, note->descpos + offset);
2936 }
2937
2938 static bfd_boolean
2939 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2940 {
2941   if (note->descsz != 136)
2942     return FALSE;
2943
2944   elf_tdata (abfd)->core->pid
2945     = bfd_get_32 (abfd, note->descdata + 24);
2946   elf_tdata (abfd)->core->program
2947     = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2948   elf_tdata (abfd)->core->command
2949     = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2950
2951   return TRUE;
2952 }
2953
2954 static char *
2955 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2956                            ...)
2957 {
2958   switch (note_type)
2959     {
2960     default:
2961       return NULL;
2962
2963     case NT_PRPSINFO:
2964       {
2965         char data[136];
2966         va_list ap;
2967
2968         va_start (ap, note_type);
2969         memset (data, 0, sizeof (data));
2970         strncpy (data + 40, va_arg (ap, const char *), 16);
2971         strncpy (data + 56, va_arg (ap, const char *), 80);
2972         va_end (ap);
2973         return elfcore_write_note (abfd, buf, bufsiz,
2974                                    "CORE", note_type, data, sizeof (data));
2975       }
2976
2977     case NT_PRSTATUS:
2978       {
2979         char data[504];
2980         va_list ap;
2981         long pid;
2982         int cursig;
2983         const void *greg;
2984
2985         va_start (ap, note_type);
2986         memset (data, 0, 112);
2987         pid = va_arg (ap, long);
2988         bfd_put_32 (abfd, pid, data + 32);
2989         cursig = va_arg (ap, int);
2990         bfd_put_16 (abfd, cursig, data + 12);
2991         greg = va_arg (ap, const void *);
2992         memcpy (data + 112, greg, 384);
2993         memset (data + 496, 0, 8);
2994         va_end (ap);
2995         return elfcore_write_note (abfd, buf, bufsiz,
2996                                    "CORE", note_type, data, sizeof (data));
2997       }
2998     }
2999 }
3000
3001 /* Add extra PPC sections.  */
3002
3003 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
3004 {
3005   { STRING_COMMA_LEN (".plt"),    0, SHT_NOBITS,   0 },
3006   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
3007   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3008   { STRING_COMMA_LEN (".toc"),    0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3009   { STRING_COMMA_LEN (".toc1"),   0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3010   { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
3011   { NULL,                     0,  0, 0,            0 }
3012 };
3013
3014 enum _ppc64_sec_type {
3015   sec_normal = 0,
3016   sec_opd = 1,
3017   sec_toc = 2
3018 };
3019
3020 struct _ppc64_elf_section_data
3021 {
3022   struct bfd_elf_section_data elf;
3023
3024   union
3025   {
3026     /* An array with one entry for each opd function descriptor,
3027        and some spares since opd entries may be either 16 or 24 bytes.  */
3028 #define OPD_NDX(OFF) ((OFF) >> 4)
3029     struct _opd_sec_data
3030     {
3031       /* Points to the function code section for local opd entries.  */
3032       asection **func_sec;
3033
3034       /* After editing .opd, adjust references to opd local syms.  */
3035       long *adjust;
3036     } opd;
3037
3038     /* An array for toc sections, indexed by offset/8.  */
3039     struct _toc_sec_data
3040     {
3041       /* Specifies the relocation symbol index used at a given toc offset.  */
3042       unsigned *symndx;
3043
3044       /* And the relocation addend.  */
3045       bfd_vma *add;
3046     } toc;
3047   } u;
3048
3049   enum _ppc64_sec_type sec_type:2;
3050
3051   /* Flag set when small branches are detected.  Used to
3052      select suitable defaults for the stub group size.  */
3053   unsigned int has_14bit_branch:1;
3054 };
3055
3056 #define ppc64_elf_section_data(sec) \
3057   ((struct _ppc64_elf_section_data *) elf_section_data (sec))
3058
3059 static bfd_boolean
3060 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
3061 {
3062   if (!sec->used_by_bfd)
3063     {
3064       struct _ppc64_elf_section_data *sdata;
3065       bfd_size_type amt = sizeof (*sdata);
3066
3067       sdata = bfd_zalloc (abfd, amt);
3068       if (sdata == NULL)
3069         return FALSE;
3070       sec->used_by_bfd = sdata;
3071     }
3072
3073   return _bfd_elf_new_section_hook (abfd, sec);
3074 }
3075
3076 static struct _opd_sec_data *
3077 get_opd_info (asection * sec)
3078 {
3079   if (sec != NULL
3080       && ppc64_elf_section_data (sec) != NULL
3081       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
3082     return &ppc64_elf_section_data (sec)->u.opd;
3083   return NULL;
3084 }
3085 \f
3086 /* Parameters for the qsort hook.  */
3087 static bfd_boolean synthetic_relocatable;
3088
3089 /* qsort comparison function for ppc64_elf_get_synthetic_symtab.  */
3090
3091 static int
3092 compare_symbols (const void *ap, const void *bp)
3093 {
3094   const asymbol *a = * (const asymbol **) ap;
3095   const asymbol *b = * (const asymbol **) bp;
3096
3097   /* Section symbols first.  */
3098   if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
3099     return -1;
3100   if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
3101     return 1;
3102
3103   /* then .opd symbols.  */
3104   if (strcmp (a->section->name, ".opd") == 0
3105       && strcmp (b->section->name, ".opd") != 0)
3106     return -1;
3107   if (strcmp (a->section->name, ".opd") != 0
3108       && strcmp (b->section->name, ".opd") == 0)
3109     return 1;
3110
3111   /* then other code symbols.  */
3112   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3113       == (SEC_CODE | SEC_ALLOC)
3114       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3115          != (SEC_CODE | SEC_ALLOC))
3116     return -1;
3117
3118   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3119       != (SEC_CODE | SEC_ALLOC)
3120       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3121          == (SEC_CODE | SEC_ALLOC))
3122     return 1;
3123
3124   if (synthetic_relocatable)
3125     {
3126       if (a->section->id < b->section->id)
3127         return -1;
3128
3129       if (a->section->id > b->section->id)
3130         return 1;
3131     }
3132
3133   if (a->value + a->section->vma < b->value + b->section->vma)
3134     return -1;
3135
3136   if (a->value + a->section->vma > b->value + b->section->vma)
3137     return 1;
3138
3139   /* For syms with the same value, prefer strong dynamic global function
3140      syms over other syms.  */
3141   if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3142     return -1;
3143
3144   if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3145     return 1;
3146
3147   if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3148     return -1;
3149
3150   if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3151     return 1;
3152
3153   if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3154     return -1;
3155
3156   if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3157     return 1;
3158
3159   if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3160     return -1;
3161
3162   if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3163     return 1;
3164
3165   return 0;
3166 }
3167
3168 /* Search SYMS for a symbol of the given VALUE.  */
3169
3170 static asymbol *
3171 sym_exists_at (asymbol **syms, long lo, long hi, unsigned int id, bfd_vma value)
3172 {
3173   long mid;
3174
3175   if (id == (unsigned) -1)
3176     {
3177       while (lo < hi)
3178         {
3179           mid = (lo + hi) >> 1;
3180           if (syms[mid]->value + syms[mid]->section->vma < value)
3181             lo = mid + 1;
3182           else if (syms[mid]->value + syms[mid]->section->vma > value)
3183             hi = mid;
3184           else
3185             return syms[mid];
3186         }
3187     }
3188   else
3189     {
3190       while (lo < hi)
3191         {
3192           mid = (lo + hi) >> 1;
3193           if (syms[mid]->section->id < id)
3194             lo = mid + 1;
3195           else if (syms[mid]->section->id > id)
3196             hi = mid;
3197           else if (syms[mid]->value < value)
3198             lo = mid + 1;
3199           else if (syms[mid]->value > value)
3200             hi = mid;
3201           else
3202             return syms[mid];
3203         }
3204     }
3205   return NULL;
3206 }
3207
3208 static bfd_boolean
3209 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3210 {
3211   bfd_vma vma = *(bfd_vma *) ptr;
3212   return ((section->flags & SEC_ALLOC) != 0
3213           && section->vma <= vma
3214           && vma < section->vma + section->size);
3215 }
3216
3217 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3218    entry syms.  Also generate @plt symbols for the glink branch table.
3219    Returns count of synthetic symbols in RET or -1 on error.  */
3220
3221 static long
3222 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3223                                 long static_count, asymbol **static_syms,
3224                                 long dyn_count, asymbol **dyn_syms,
3225                                 asymbol **ret)
3226 {
3227   asymbol *s;
3228   long i;
3229   long count;
3230   char *names;
3231   long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3232   asection *opd = NULL;
3233   bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3234   asymbol **syms;
3235   int abi = abiversion (abfd);
3236
3237   *ret = NULL;
3238
3239   if (abi < 2)
3240     {
3241       opd = bfd_get_section_by_name (abfd, ".opd");
3242       if (opd == NULL && abi == 1)
3243         return 0;
3244     }
3245
3246   symcount = static_count;
3247   if (!relocatable)
3248     symcount += dyn_count;
3249   if (symcount == 0)
3250     return 0;
3251
3252   syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3253   if (syms == NULL)
3254     return -1;
3255
3256   if (!relocatable && static_count != 0 && dyn_count != 0)
3257     {
3258       /* Use both symbol tables.  */
3259       memcpy (syms, static_syms, static_count * sizeof (*syms));
3260       memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3261     }
3262   else if (!relocatable && static_count == 0)
3263     memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3264   else
3265     memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3266
3267   synthetic_relocatable = relocatable;
3268   qsort (syms, symcount, sizeof (*syms), compare_symbols);
3269
3270   if (!relocatable && symcount > 1)
3271     {
3272       long j;
3273       /* Trim duplicate syms, since we may have merged the normal and
3274          dynamic symbols.  Actually, we only care about syms that have
3275          different values, so trim any with the same value.  */
3276       for (i = 1, j = 1; i < symcount; ++i)
3277         if (syms[i - 1]->value + syms[i - 1]->section->vma
3278             != syms[i]->value + syms[i]->section->vma)
3279           syms[j++] = syms[i];
3280       symcount = j;
3281     }
3282
3283   i = 0;
3284   if (strcmp (syms[i]->section->name, ".opd") == 0)
3285     ++i;
3286   codesecsym = i;
3287
3288   for (; i < symcount; ++i)
3289     if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3290          != (SEC_CODE | SEC_ALLOC))
3291         || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3292       break;
3293   codesecsymend = i;
3294
3295   for (; i < symcount; ++i)
3296     if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3297       break;
3298   secsymend = i;
3299
3300   for (; i < symcount; ++i)
3301     if (strcmp (syms[i]->section->name, ".opd") != 0)
3302       break;
3303   opdsymend = i;
3304
3305   for (; i < symcount; ++i)
3306     if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3307         != (SEC_CODE | SEC_ALLOC))
3308       break;
3309   symcount = i;
3310
3311   count = 0;
3312
3313   if (relocatable)
3314     {
3315       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3316       arelent *r;
3317       size_t size;
3318       long relcount;
3319
3320       if (opdsymend == secsymend)
3321         goto done;
3322
3323       slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3324       relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3325       if (relcount == 0)
3326         goto done;
3327
3328       if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3329         {
3330           count = -1;
3331           goto done;
3332         }
3333
3334       size = 0;
3335       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3336         {
3337           asymbol *sym;
3338
3339           while (r < opd->relocation + relcount
3340                  && r->address < syms[i]->value + opd->vma)
3341             ++r;
3342
3343           if (r == opd->relocation + relcount)
3344             break;
3345
3346           if (r->address != syms[i]->value + opd->vma)
3347             continue;
3348
3349           if (r->howto->type != R_PPC64_ADDR64)
3350             continue;
3351
3352           sym = *r->sym_ptr_ptr;
3353           if (!sym_exists_at (syms, opdsymend, symcount,
3354                               sym->section->id, sym->value + r->addend))
3355             {
3356               ++count;
3357               size += sizeof (asymbol);
3358               size += strlen (syms[i]->name) + 2;
3359             }
3360         }
3361
3362       if (size == 0)
3363         goto done;
3364       s = *ret = bfd_malloc (size);
3365       if (s == NULL)
3366         {
3367           count = -1;
3368           goto done;
3369         }
3370
3371       names = (char *) (s + count);
3372
3373       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3374         {
3375           asymbol *sym;
3376
3377           while (r < opd->relocation + relcount
3378                  && r->address < syms[i]->value + opd->vma)
3379             ++r;
3380
3381           if (r == opd->relocation + relcount)
3382             break;
3383
3384           if (r->address != syms[i]->value + opd->vma)
3385             continue;
3386
3387           if (r->howto->type != R_PPC64_ADDR64)
3388             continue;
3389
3390           sym = *r->sym_ptr_ptr;
3391           if (!sym_exists_at (syms, opdsymend, symcount,
3392                               sym->section->id, sym->value + r->addend))
3393             {
3394               size_t len;
3395
3396               *s = *syms[i];
3397               s->flags |= BSF_SYNTHETIC;
3398               s->section = sym->section;
3399               s->value = sym->value + r->addend;
3400               s->name = names;
3401               *names++ = '.';
3402               len = strlen (syms[i]->name);
3403               memcpy (names, syms[i]->name, len + 1);
3404               names += len + 1;
3405               /* Have udata.p point back to the original symbol this
3406                  synthetic symbol was derived from.  */
3407               s->udata.p = syms[i];
3408               s++;
3409             }
3410         }
3411     }
3412   else
3413     {
3414       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3415       bfd_byte *contents = NULL;
3416       size_t size;
3417       long plt_count = 0;
3418       bfd_vma glink_vma = 0, resolv_vma = 0;
3419       asection *dynamic, *glink = NULL, *relplt = NULL;
3420       arelent *p;
3421
3422       if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3423         {
3424         free_contents_and_exit_err:
3425           count = -1;
3426         free_contents_and_exit:
3427           if (contents)
3428             free (contents);
3429           goto done;
3430         }
3431
3432       size = 0;
3433       for (i = secsymend; i < opdsymend; ++i)
3434         {
3435           bfd_vma ent;
3436
3437           /* Ignore bogus symbols.  */
3438           if (syms[i]->value > opd->size - 8)
3439             continue;
3440
3441           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3442           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3443             {
3444               ++count;
3445               size += sizeof (asymbol);
3446               size += strlen (syms[i]->name) + 2;
3447             }
3448         }
3449
3450       /* Get start of .glink stubs from DT_PPC64_GLINK.  */
3451       if (dyn_count != 0
3452           && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3453         {
3454           bfd_byte *dynbuf, *extdyn, *extdynend;
3455           size_t extdynsize;
3456           void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3457
3458           if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3459             goto free_contents_and_exit_err;
3460
3461           extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3462           swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3463
3464           extdyn = dynbuf;
3465           extdynend = extdyn + dynamic->size;
3466           for (; extdyn < extdynend; extdyn += extdynsize)
3467             {
3468               Elf_Internal_Dyn dyn;
3469               (*swap_dyn_in) (abfd, extdyn, &dyn);
3470
3471               if (dyn.d_tag == DT_NULL)
3472                 break;
3473
3474               if (dyn.d_tag == DT_PPC64_GLINK)
3475                 {
3476                   /* The first glink stub starts at offset 32; see
3477                      comment in ppc64_elf_finish_dynamic_sections. */
3478                   glink_vma = dyn.d_un.d_val + GLINK_CALL_STUB_SIZE - 8 * 4;
3479                   /* The .glink section usually does not survive the final
3480                      link; search for the section (usually .text) where the
3481                      glink stubs now reside.  */
3482                   glink = bfd_sections_find_if (abfd, section_covers_vma,
3483                                                 &glink_vma);
3484                   break;
3485                 }
3486             }
3487
3488           free (dynbuf);
3489         }
3490
3491       if (glink != NULL)
3492         {
3493           /* Determine __glink trampoline by reading the relative branch
3494              from the first glink stub.  */
3495           bfd_byte buf[4];
3496           unsigned int off = 0;
3497
3498           while (bfd_get_section_contents (abfd, glink, buf,
3499                                            glink_vma + off - glink->vma, 4))
3500             {
3501               unsigned int insn = bfd_get_32 (abfd, buf);
3502               insn ^= B_DOT;
3503               if ((insn & ~0x3fffffc) == 0)
3504                 {
3505                   resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3506                   break;
3507                 }
3508               off += 4;
3509               if (off > 4)
3510                 break;
3511             }
3512
3513           if (resolv_vma)
3514             size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3515
3516           relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3517           if (relplt != NULL)
3518             {
3519               slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3520               if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3521                 goto free_contents_and_exit_err;
3522
3523               plt_count = relplt->size / sizeof (Elf64_External_Rela);
3524               size += plt_count * sizeof (asymbol);
3525
3526               p = relplt->relocation;
3527               for (i = 0; i < plt_count; i++, p++)
3528                 {
3529                   size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3530                   if (p->addend != 0)
3531                     size += sizeof ("+0x") - 1 + 16;
3532                 }
3533             }
3534         }
3535
3536       if (size == 0)
3537         goto free_contents_and_exit;
3538       s = *ret = bfd_malloc (size);
3539       if (s == NULL)
3540         goto free_contents_and_exit_err;
3541
3542       names = (char *) (s + count + plt_count + (resolv_vma != 0));
3543
3544       for (i = secsymend; i < opdsymend; ++i)
3545         {
3546           bfd_vma ent;
3547
3548           if (syms[i]->value > opd->size - 8)
3549             continue;
3550
3551           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3552           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3553             {
3554               long lo, hi;
3555               size_t len;
3556               asection *sec = abfd->sections;
3557
3558               *s = *syms[i];
3559               lo = codesecsym;
3560               hi = codesecsymend;
3561               while (lo < hi)
3562                 {
3563                   long mid = (lo + hi) >> 1;
3564                   if (syms[mid]->section->vma < ent)
3565                     lo = mid + 1;
3566                   else if (syms[mid]->section->vma > ent)
3567                     hi = mid;
3568                   else
3569                     {
3570                       sec = syms[mid]->section;
3571                       break;
3572                     }
3573                 }
3574
3575               if (lo >= hi && lo > codesecsym)
3576                 sec = syms[lo - 1]->section;
3577
3578               for (; sec != NULL; sec = sec->next)
3579                 {
3580                   if (sec->vma > ent)
3581                     break;
3582                   /* SEC_LOAD may not be set if SEC is from a separate debug
3583                      info file.  */
3584                   if ((sec->flags & SEC_ALLOC) == 0)
3585                     break;
3586                   if ((sec->flags & SEC_CODE) != 0)
3587                     s->section = sec;
3588                 }
3589               s->flags |= BSF_SYNTHETIC;
3590               s->value = ent - s->section->vma;
3591               s->name = names;
3592               *names++ = '.';
3593               len = strlen (syms[i]->name);
3594               memcpy (names, syms[i]->name, len + 1);
3595               names += len + 1;
3596               /* Have udata.p point back to the original symbol this
3597                  synthetic symbol was derived from.  */
3598               s->udata.p = syms[i];
3599               s++;
3600             }
3601         }
3602       free (contents);
3603
3604       if (glink != NULL && relplt != NULL)
3605         {
3606           if (resolv_vma)
3607             {
3608               /* Add a symbol for the main glink trampoline.  */
3609               memset (s, 0, sizeof *s);
3610               s->the_bfd = abfd;
3611               s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3612               s->section = glink;
3613               s->value = resolv_vma - glink->vma;
3614               s->name = names;
3615               memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3616               names += sizeof ("__glink_PLTresolve");
3617               s++;
3618               count++;
3619             }
3620
3621           /* FIXME: It would be very much nicer to put sym@plt on the
3622              stub rather than on the glink branch table entry.  The
3623              objdump disassembler would then use a sensible symbol
3624              name on plt calls.  The difficulty in doing so is
3625              a) finding the stubs, and,
3626              b) matching stubs against plt entries, and,
3627              c) there can be multiple stubs for a given plt entry.
3628
3629              Solving (a) could be done by code scanning, but older
3630              ppc64 binaries used different stubs to current code.
3631              (b) is the tricky one since you need to known the toc
3632              pointer for at least one function that uses a pic stub to
3633              be able to calculate the plt address referenced.
3634              (c) means gdb would need to set multiple breakpoints (or
3635              find the glink branch itself) when setting breakpoints
3636              for pending shared library loads.  */
3637           p = relplt->relocation;
3638           for (i = 0; i < plt_count; i++, p++)
3639             {
3640               size_t len;
3641
3642               *s = **p->sym_ptr_ptr;
3643               /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
3644                  we are defining a symbol, ensure one of them is set.  */
3645               if ((s->flags & BSF_LOCAL) == 0)
3646                 s->flags |= BSF_GLOBAL;
3647               s->flags |= BSF_SYNTHETIC;
3648               s->section = glink;
3649               s->value = glink_vma - glink->vma;
3650               s->name = names;
3651               s->udata.p = NULL;
3652               len = strlen ((*p->sym_ptr_ptr)->name);
3653               memcpy (names, (*p->sym_ptr_ptr)->name, len);
3654               names += len;
3655               if (p->addend != 0)
3656                 {
3657                   memcpy (names, "+0x", sizeof ("+0x") - 1);
3658                   names += sizeof ("+0x") - 1;
3659                   bfd_sprintf_vma (abfd, names, p->addend);
3660                   names += strlen (names);
3661                 }
3662               memcpy (names, "@plt", sizeof ("@plt"));
3663               names += sizeof ("@plt");
3664               s++;
3665               if (abi < 2)
3666                 {
3667                   glink_vma += 8;
3668                   if (i >= 0x8000)
3669                     glink_vma += 4;
3670                 }
3671               else
3672                 glink_vma += 4;
3673             }
3674           count += plt_count;
3675         }
3676     }
3677
3678  done:
3679   free (syms);
3680   return count;
3681 }
3682 \f
3683 /* The following functions are specific to the ELF linker, while
3684    functions above are used generally.  Those named ppc64_elf_* are
3685    called by the main ELF linker code.  They appear in this file more
3686    or less in the order in which they are called.  eg.
3687    ppc64_elf_check_relocs is called early in the link process,
3688    ppc64_elf_finish_dynamic_sections is one of the last functions
3689    called.
3690
3691    PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3692    functions have both a function code symbol and a function descriptor
3693    symbol.  A call to foo in a relocatable object file looks like:
3694
3695    .            .text
3696    .    x:
3697    .            bl      .foo
3698    .            nop
3699
3700    The function definition in another object file might be:
3701
3702    .            .section .opd
3703    .    foo:    .quad   .foo
3704    .            .quad   .TOC.@tocbase
3705    .            .quad   0
3706    .
3707    .            .text
3708    .    .foo:   blr
3709
3710    When the linker resolves the call during a static link, the branch
3711    unsurprisingly just goes to .foo and the .opd information is unused.
3712    If the function definition is in a shared library, things are a little
3713    different:  The call goes via a plt call stub, the opd information gets
3714    copied to the plt, and the linker patches the nop.
3715
3716    .    x:
3717    .            bl      .foo_stub
3718    .            ld      2,40(1)
3719    .
3720    .
3721    .    .foo_stub:
3722    .            std     2,40(1)                 # in practice, the call stub
3723    .            addis   11,2,Lfoo@toc@ha        # is slightly optimized, but
3724    .            addi    11,11,Lfoo@toc@l        # this is the general idea
3725    .            ld      12,0(11)
3726    .            ld      2,8(11)
3727    .            mtctr   12
3728    .            ld      11,16(11)
3729    .            bctr
3730    .
3731    .            .section .plt
3732    .    Lfoo:   reloc (R_PPC64_JMP_SLOT, foo)
3733
3734    The "reloc ()" notation is supposed to indicate that the linker emits
3735    an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
3736    copying.
3737
3738    What are the difficulties here?  Well, firstly, the relocations
3739    examined by the linker in check_relocs are against the function code
3740    sym .foo, while the dynamic relocation in the plt is emitted against
3741    the function descriptor symbol, foo.  Somewhere along the line, we need
3742    to carefully copy dynamic link information from one symbol to the other.
3743    Secondly, the generic part of the elf linker will make .foo a dynamic
3744    symbol as is normal for most other backends.  We need foo dynamic
3745    instead, at least for an application final link.  However, when
3746    creating a shared library containing foo, we need to have both symbols
3747    dynamic so that references to .foo are satisfied during the early
3748    stages of linking.  Otherwise the linker might decide to pull in a
3749    definition from some other object, eg. a static library.
3750
3751    Update: As of August 2004, we support a new convention.  Function
3752    calls may use the function descriptor symbol, ie. "bl foo".  This
3753    behaves exactly as "bl .foo".  */
3754
3755 /* Of those relocs that might be copied as dynamic relocs, this function
3756    selects those that must be copied when linking a shared library,
3757    even when the symbol is local.  */
3758
3759 static int
3760 must_be_dyn_reloc (struct bfd_link_info *info,
3761                    enum elf_ppc64_reloc_type r_type)
3762 {
3763   switch (r_type)
3764     {
3765     default:
3766       return 1;
3767
3768     case R_PPC64_REL32:
3769     case R_PPC64_REL64:
3770     case R_PPC64_REL30:
3771       return 0;
3772
3773     case R_PPC64_TPREL16:
3774     case R_PPC64_TPREL16_LO:
3775     case R_PPC64_TPREL16_HI:
3776     case R_PPC64_TPREL16_HA:
3777     case R_PPC64_TPREL16_DS:
3778     case R_PPC64_TPREL16_LO_DS:
3779     case R_PPC64_TPREL16_HIGH:
3780     case R_PPC64_TPREL16_HIGHA:
3781     case R_PPC64_TPREL16_HIGHER:
3782     case R_PPC64_TPREL16_HIGHERA:
3783     case R_PPC64_TPREL16_HIGHEST:
3784     case R_PPC64_TPREL16_HIGHESTA:
3785     case R_PPC64_TPREL64:
3786       return !bfd_link_executable (info);
3787     }
3788 }
3789
3790 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3791    copying dynamic variables from a shared lib into an app's dynbss
3792    section, and instead use a dynamic relocation to point into the
3793    shared lib.  With code that gcc generates, it's vital that this be
3794    enabled;  In the PowerPC64 ABI, the address of a function is actually
3795    the address of a function descriptor, which resides in the .opd
3796    section.  gcc uses the descriptor directly rather than going via the
3797    GOT as some other ABI's do, which means that initialized function
3798    pointers must reference the descriptor.  Thus, a function pointer
3799    initialized to the address of a function in a shared library will
3800    either require a copy reloc, or a dynamic reloc.  Using a copy reloc
3801    redefines the function descriptor symbol to point to the copy.  This
3802    presents a problem as a plt entry for that function is also
3803    initialized from the function descriptor symbol and the copy reloc
3804    may not be initialized first.  */
3805 #define ELIMINATE_COPY_RELOCS 1
3806
3807 /* Section name for stubs is the associated section name plus this
3808    string.  */
3809 #define STUB_SUFFIX ".stub"
3810
3811 /* Linker stubs.
3812    ppc_stub_long_branch:
3813    Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3814    destination, but a 24 bit branch in a stub section will reach.
3815    .    b       dest
3816
3817    ppc_stub_plt_branch:
3818    Similar to the above, but a 24 bit branch in the stub section won't
3819    reach its destination.
3820    .    addis   %r11,%r2,xxx@toc@ha
3821    .    ld      %r12,xxx@toc@l(%r11)
3822    .    mtctr   %r12
3823    .    bctr
3824
3825    ppc_stub_plt_call:
3826    Used to call a function in a shared library.  If it so happens that
3827    the plt entry referenced crosses a 64k boundary, then an extra
3828    "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3829    .    std     %r2,40(%r1)
3830    .    addis   %r11,%r2,xxx@toc@ha
3831    .    ld      %r12,xxx+0@toc@l(%r11)
3832    .    mtctr   %r12
3833    .    ld      %r2,xxx+8@toc@l(%r11)
3834    .    ld      %r11,xxx+16@toc@l(%r11)
3835    .    bctr
3836
3837    ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3838    code to adjust the value and save r2 to support multiple toc sections.
3839    A ppc_stub_long_branch with an r2 offset looks like:
3840    .    std     %r2,40(%r1)
3841    .    addis   %r2,%r2,off@ha
3842    .    addi    %r2,%r2,off@l
3843    .    b       dest
3844
3845    A ppc_stub_plt_branch with an r2 offset looks like:
3846    .    std     %r2,40(%r1)
3847    .    addis   %r11,%r2,xxx@toc@ha
3848    .    ld      %r12,xxx@toc@l(%r11)
3849    .    addis   %r2,%r2,off@ha
3850    .    addi    %r2,%r2,off@l
3851    .    mtctr   %r12
3852    .    bctr
3853
3854    In cases where the "addis" instruction would add zero, the "addis" is
3855    omitted and following instructions modified slightly in some cases.
3856 */
3857
3858 enum ppc_stub_type {
3859   ppc_stub_none,
3860   ppc_stub_long_branch,
3861   ppc_stub_long_branch_r2off,
3862   ppc_stub_plt_branch,
3863   ppc_stub_plt_branch_r2off,
3864   ppc_stub_plt_call,
3865   ppc_stub_plt_call_r2save,
3866   ppc_stub_global_entry,
3867   ppc_stub_save_res
3868 };
3869
3870 /* Information on stub grouping.  */
3871 struct map_stub
3872 {
3873   /* The stub section.  */
3874   asection *stub_sec;
3875   /* This is the section to which stubs in the group will be attached.  */
3876   asection *link_sec;
3877   /* Next group.  */
3878   struct map_stub *next;
3879   /* Whether to emit a copy of register save/restore functions in this
3880      group.  */
3881   int needs_save_res;
3882 };
3883
3884 struct ppc_stub_hash_entry {
3885
3886   /* Base hash table entry structure.  */
3887   struct bfd_hash_entry root;
3888
3889   enum ppc_stub_type stub_type;
3890
3891   /* Group information.  */
3892   struct map_stub *group;
3893
3894   /* Offset within stub_sec of the beginning of this stub.  */
3895   bfd_vma stub_offset;
3896
3897   /* Given the symbol's value and its section we can determine its final
3898      value when building the stubs (so the stub knows where to jump.  */
3899   bfd_vma target_value;
3900   asection *target_section;
3901
3902   /* The symbol table entry, if any, that this was derived from.  */
3903   struct ppc_link_hash_entry *h;
3904   struct plt_entry *plt_ent;
3905
3906   /* Symbol st_other.  */
3907   unsigned char other;
3908 };
3909
3910 struct ppc_branch_hash_entry {
3911
3912   /* Base hash table entry structure.  */
3913   struct bfd_hash_entry root;
3914
3915   /* Offset within branch lookup table.  */
3916   unsigned int offset;
3917
3918   /* Generation marker.  */
3919   unsigned int iter;
3920 };
3921
3922 /* Used to track dynamic relocations for local symbols.  */
3923 struct ppc_dyn_relocs
3924 {
3925   struct ppc_dyn_relocs *next;
3926
3927   /* The input section of the reloc.  */
3928   asection *sec;
3929
3930   /* Total number of relocs copied for the input section.  */
3931   unsigned int count : 31;
3932
3933   /* Whether this entry is for STT_GNU_IFUNC symbols.  */
3934   unsigned int ifunc : 1;
3935 };
3936
3937 struct ppc_link_hash_entry
3938 {
3939   struct elf_link_hash_entry elf;
3940
3941   union {
3942     /* A pointer to the most recently used stub hash entry against this
3943        symbol.  */
3944     struct ppc_stub_hash_entry *stub_cache;
3945
3946     /* A pointer to the next symbol starting with a '.'  */
3947     struct ppc_link_hash_entry *next_dot_sym;
3948   } u;
3949
3950   /* Track dynamic relocs copied for this symbol.  */
3951   struct elf_dyn_relocs *dyn_relocs;
3952
3953   /* Chain of aliases referring to a weakdef.  */
3954   struct ppc_link_hash_entry *weakref;
3955
3956   /* Link between function code and descriptor symbols.  */
3957   struct ppc_link_hash_entry *oh;
3958
3959   /* Flag function code and descriptor symbols.  */
3960   unsigned int is_func:1;
3961   unsigned int is_func_descriptor:1;
3962   unsigned int fake:1;
3963
3964   /* Whether global opd/toc sym has been adjusted or not.
3965      After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3966      should be set for all globals defined in any opd/toc section.  */
3967   unsigned int adjust_done:1;
3968
3969   /* Set if we twiddled this symbol to weak at some stage.  */
3970   unsigned int was_undefined:1;
3971
3972   /* Set if this is an out-of-line register save/restore function,
3973      with non-standard calling convention.  */
3974   unsigned int save_res:1;
3975
3976   /* Contexts in which symbol is used in the GOT (or TOC).
3977      TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3978      corresponding relocs are encountered during check_relocs.
3979      tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3980      indicate the corresponding GOT entry type is not needed.
3981      tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3982      a TPREL one.  We use a separate flag rather than setting TPREL
3983      just for convenience in distinguishing the two cases.  */
3984 #define TLS_GD           1      /* GD reloc. */
3985 #define TLS_LD           2      /* LD reloc. */
3986 #define TLS_TPREL        4      /* TPREL reloc, => IE. */
3987 #define TLS_DTPREL       8      /* DTPREL reloc, => LD. */
3988 #define TLS_TLS         16      /* Any TLS reloc.  */
3989 #define TLS_EXPLICIT    32      /* Marks TOC section TLS relocs. */
3990 #define TLS_TPRELGD     64      /* TPREL reloc resulting from GD->IE. */
3991 #define PLT_IFUNC      128      /* STT_GNU_IFUNC.  */
3992   unsigned char tls_mask;
3993 };
3994
3995 /* ppc64 ELF linker hash table.  */
3996
3997 struct ppc_link_hash_table
3998 {
3999   struct elf_link_hash_table elf;
4000
4001   /* The stub hash table.  */
4002   struct bfd_hash_table stub_hash_table;
4003
4004   /* Another hash table for plt_branch stubs.  */
4005   struct bfd_hash_table branch_hash_table;
4006
4007   /* Hash table for function prologue tocsave.  */
4008   htab_t tocsave_htab;
4009
4010   /* Various options and other info passed from the linker.  */
4011   struct ppc64_elf_params *params;
4012
4013   /* The size of sec_info below.  */
4014   unsigned int sec_info_arr_size;
4015
4016   /* Per-section array of extra section info.  Done this way rather
4017      than as part of ppc64_elf_section_data so we have the info for
4018      non-ppc64 sections.  */
4019   struct
4020   {
4021     /* Along with elf_gp, specifies the TOC pointer used by this section.  */
4022     bfd_vma toc_off;
4023
4024     union
4025     {
4026       /* The section group that this section belongs to.  */
4027       struct map_stub *group;
4028       /* A temp section list pointer.  */
4029       asection *list;
4030     } u;
4031   } *sec_info;
4032
4033   /* Linked list of groups.  */
4034   struct map_stub *group;
4035
4036   /* Temp used when calculating TOC pointers.  */
4037   bfd_vma toc_curr;
4038   bfd *toc_bfd;
4039   asection *toc_first_sec;
4040
4041   /* Used when adding symbols.  */
4042   struct ppc_link_hash_entry *dot_syms;
4043
4044   /* Shortcuts to get to dynamic linker sections.  */
4045   asection *dynbss;
4046   asection *relbss;
4047   asection *glink;
4048   asection *sfpr;
4049   asection *brlt;
4050   asection *relbrlt;
4051   asection *glink_eh_frame;
4052
4053   /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
4054   struct ppc_link_hash_entry *tls_get_addr;
4055   struct ppc_link_hash_entry *tls_get_addr_fd;
4056
4057   /* The size of reliplt used by got entry relocs.  */
4058   bfd_size_type got_reli_size;
4059
4060   /* Statistics.  */
4061   unsigned long stub_count[ppc_stub_global_entry];
4062
4063   /* Number of stubs against global syms.  */
4064   unsigned long stub_globals;
4065
4066   /* Set if we're linking code with function descriptors.  */
4067   unsigned int opd_abi:1;
4068
4069   /* Support for multiple toc sections.  */
4070   unsigned int do_multi_toc:1;
4071   unsigned int multi_toc_needed:1;
4072   unsigned int second_toc_pass:1;
4073   unsigned int do_toc_opt:1;
4074
4075   /* Set on error.  */
4076   unsigned int stub_error:1;
4077
4078   /* Temp used by ppc64_elf_before_check_relocs.  */
4079   unsigned int twiddled_syms:1;
4080
4081   /* Incremented every time we size stubs.  */
4082   unsigned int stub_iteration;
4083
4084   /* Small local sym cache.  */
4085   struct sym_cache sym_cache;
4086 };
4087
4088 /* Rename some of the generic section flags to better document how they
4089    are used here.  */
4090
4091 /* Nonzero if this section has TLS related relocations.  */
4092 #define has_tls_reloc sec_flg0
4093
4094 /* Nonzero if this section has a call to __tls_get_addr.  */
4095 #define has_tls_get_addr_call sec_flg1
4096
4097 /* Nonzero if this section has any toc or got relocs.  */
4098 #define has_toc_reloc sec_flg2
4099
4100 /* Nonzero if this section has a call to another section that uses
4101    the toc or got.  */
4102 #define makes_toc_func_call sec_flg3
4103
4104 /* Recursion protection when determining above flag.  */
4105 #define call_check_in_progress sec_flg4
4106 #define call_check_done sec_flg5
4107
4108 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
4109
4110 #define ppc_hash_table(p) \
4111   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
4112   == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
4113
4114 #define ppc_stub_hash_lookup(table, string, create, copy) \
4115   ((struct ppc_stub_hash_entry *) \
4116    bfd_hash_lookup ((table), (string), (create), (copy)))
4117
4118 #define ppc_branch_hash_lookup(table, string, create, copy) \
4119   ((struct ppc_branch_hash_entry *) \
4120    bfd_hash_lookup ((table), (string), (create), (copy)))
4121
4122 /* Create an entry in the stub hash table.  */
4123
4124 static struct bfd_hash_entry *
4125 stub_hash_newfunc (struct bfd_hash_entry *entry,
4126                    struct bfd_hash_table *table,
4127                    const char *string)
4128 {
4129   /* Allocate the structure if it has not already been allocated by a
4130      subclass.  */
4131   if (entry == NULL)
4132     {
4133       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4134       if (entry == NULL)
4135         return entry;
4136     }
4137
4138   /* Call the allocation method of the superclass.  */
4139   entry = bfd_hash_newfunc (entry, table, string);
4140   if (entry != NULL)
4141     {
4142       struct ppc_stub_hash_entry *eh;
4143
4144       /* Initialize the local fields.  */
4145       eh = (struct ppc_stub_hash_entry *) entry;
4146       eh->stub_type = ppc_stub_none;
4147       eh->group = NULL;
4148       eh->stub_offset = 0;
4149       eh->target_value = 0;
4150       eh->target_section = NULL;
4151       eh->h = NULL;
4152       eh->plt_ent = NULL;
4153       eh->other = 0;
4154     }
4155
4156   return entry;
4157 }
4158
4159 /* Create an entry in the branch hash table.  */
4160
4161 static struct bfd_hash_entry *
4162 branch_hash_newfunc (struct bfd_hash_entry *entry,
4163                      struct bfd_hash_table *table,
4164                      const char *string)
4165 {
4166   /* Allocate the structure if it has not already been allocated by a
4167      subclass.  */
4168   if (entry == NULL)
4169     {
4170       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4171       if (entry == NULL)
4172         return entry;
4173     }
4174
4175   /* Call the allocation method of the superclass.  */
4176   entry = bfd_hash_newfunc (entry, table, string);
4177   if (entry != NULL)
4178     {
4179       struct ppc_branch_hash_entry *eh;
4180
4181       /* Initialize the local fields.  */
4182       eh = (struct ppc_branch_hash_entry *) entry;
4183       eh->offset = 0;
4184       eh->iter = 0;
4185     }
4186
4187   return entry;
4188 }
4189
4190 /* Create an entry in a ppc64 ELF linker hash table.  */
4191
4192 static struct bfd_hash_entry *
4193 link_hash_newfunc (struct bfd_hash_entry *entry,
4194                    struct bfd_hash_table *table,
4195                    const char *string)
4196 {
4197   /* Allocate the structure if it has not already been allocated by a
4198      subclass.  */
4199   if (entry == NULL)
4200     {
4201       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4202       if (entry == NULL)
4203         return entry;
4204     }
4205
4206   /* Call the allocation method of the superclass.  */
4207   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4208   if (entry != NULL)
4209     {
4210       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4211
4212       memset (&eh->u.stub_cache, 0,
4213               (sizeof (struct ppc_link_hash_entry)
4214                - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4215
4216       /* When making function calls, old ABI code references function entry
4217          points (dot symbols), while new ABI code references the function
4218          descriptor symbol.  We need to make any combination of reference and
4219          definition work together, without breaking archive linking.
4220
4221          For a defined function "foo" and an undefined call to "bar":
4222          An old object defines "foo" and ".foo", references ".bar" (possibly
4223          "bar" too).
4224          A new object defines "foo" and references "bar".
4225
4226          A new object thus has no problem with its undefined symbols being
4227          satisfied by definitions in an old object.  On the other hand, the
4228          old object won't have ".bar" satisfied by a new object.
4229
4230          Keep a list of newly added dot-symbols.  */
4231
4232       if (string[0] == '.')
4233         {
4234           struct ppc_link_hash_table *htab;
4235
4236           htab = (struct ppc_link_hash_table *) table;
4237           eh->u.next_dot_sym = htab->dot_syms;
4238           htab->dot_syms = eh;
4239         }
4240     }
4241
4242   return entry;
4243 }
4244
4245 struct tocsave_entry {
4246   asection *sec;
4247   bfd_vma offset;
4248 };
4249
4250 static hashval_t
4251 tocsave_htab_hash (const void *p)
4252 {
4253   const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4254   return ((bfd_vma)(intptr_t) e->sec ^ e->offset) >> 3;
4255 }
4256
4257 static int
4258 tocsave_htab_eq (const void *p1, const void *p2)
4259 {
4260   const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4261   const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4262   return e1->sec == e2->sec && e1->offset == e2->offset;
4263 }
4264
4265 /* Destroy a ppc64 ELF linker hash table.  */
4266
4267 static void
4268 ppc64_elf_link_hash_table_free (bfd *obfd)
4269 {
4270   struct ppc_link_hash_table *htab;
4271
4272   htab = (struct ppc_link_hash_table *) obfd->link.hash;
4273   if (htab->tocsave_htab)
4274     htab_delete (htab->tocsave_htab);
4275   bfd_hash_table_free (&htab->branch_hash_table);
4276   bfd_hash_table_free (&htab->stub_hash_table);
4277   _bfd_elf_link_hash_table_free (obfd);
4278 }
4279
4280 /* Create a ppc64 ELF linker hash table.  */
4281
4282 static struct bfd_link_hash_table *
4283 ppc64_elf_link_hash_table_create (bfd *abfd)
4284 {
4285   struct ppc_link_hash_table *htab;
4286   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4287
4288   htab = bfd_zmalloc (amt);
4289   if (htab == NULL)
4290     return NULL;
4291
4292   if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4293                                       sizeof (struct ppc_link_hash_entry),
4294                                       PPC64_ELF_DATA))
4295     {
4296       free (htab);
4297       return NULL;
4298     }
4299
4300   /* Init the stub hash table too.  */
4301   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4302                             sizeof (struct ppc_stub_hash_entry)))
4303     {
4304       _bfd_elf_link_hash_table_free (abfd);
4305       return NULL;
4306     }
4307
4308   /* And the branch hash table.  */
4309   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4310                             sizeof (struct ppc_branch_hash_entry)))
4311     {
4312       bfd_hash_table_free (&htab->stub_hash_table);
4313       _bfd_elf_link_hash_table_free (abfd);
4314       return NULL;
4315     }
4316
4317   htab->tocsave_htab = htab_try_create (1024,
4318                                         tocsave_htab_hash,
4319                                         tocsave_htab_eq,
4320                                         NULL);
4321   if (htab->tocsave_htab == NULL)
4322     {
4323       ppc64_elf_link_hash_table_free (abfd);
4324       return NULL;
4325     }
4326   htab->elf.root.hash_table_free = ppc64_elf_link_hash_table_free;
4327
4328   /* Initializing two fields of the union is just cosmetic.  We really
4329      only care about glist, but when compiled on a 32-bit host the
4330      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
4331      debugger inspection of these fields look nicer.  */
4332   htab->elf.init_got_refcount.refcount = 0;
4333   htab->elf.init_got_refcount.glist = NULL;
4334   htab->elf.init_plt_refcount.refcount = 0;
4335   htab->elf.init_plt_refcount.glist = NULL;
4336   htab->elf.init_got_offset.offset = 0;
4337   htab->elf.init_got_offset.glist = NULL;
4338   htab->elf.init_plt_offset.offset = 0;
4339   htab->elf.init_plt_offset.glist = NULL;
4340
4341   return &htab->elf.root;
4342 }
4343
4344 /* Create sections for linker generated code.  */
4345
4346 static bfd_boolean
4347 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4348 {
4349   struct ppc_link_hash_table *htab;
4350   flagword flags;
4351
4352   htab = ppc_hash_table (info);
4353
4354   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4355            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4356   if (htab->params->save_restore_funcs)
4357     {
4358       /* Create .sfpr for code to save and restore fp regs.  */
4359       htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4360                                                        flags);
4361       if (htab->sfpr == NULL
4362           || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4363         return FALSE;
4364     }
4365
4366   if (bfd_link_relocatable (info))
4367     return TRUE;
4368
4369   /* Create .glink for lazy dynamic linking support.  */
4370   htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4371                                                     flags);
4372   if (htab->glink == NULL
4373       || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4374     return FALSE;
4375
4376   if (!info->no_ld_generated_unwind_info)
4377     {
4378       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4379                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4380       htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4381                                                                  ".eh_frame",
4382                                                                  flags);
4383       if (htab->glink_eh_frame == NULL
4384           || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4385         return FALSE;
4386     }
4387
4388   flags = SEC_ALLOC | SEC_LINKER_CREATED;
4389   htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4390   if (htab->elf.iplt == NULL
4391       || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4392     return FALSE;
4393
4394   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4395            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4396   htab->elf.irelplt
4397     = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4398   if (htab->elf.irelplt == NULL
4399       || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4400     return FALSE;
4401
4402   /* Create branch lookup table for plt_branch stubs.  */
4403   flags = (SEC_ALLOC | SEC_LOAD
4404            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4405   htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4406                                                    flags);
4407   if (htab->brlt == NULL
4408       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4409     return FALSE;
4410
4411   if (!bfd_link_pic (info))
4412     return TRUE;
4413
4414   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4415            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4416   htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4417                                                       ".rela.branch_lt",
4418                                                       flags);
4419   if (htab->relbrlt == NULL
4420       || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4421     return FALSE;
4422
4423   return TRUE;
4424 }
4425
4426 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
4427
4428 bfd_boolean
4429 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4430                          struct ppc64_elf_params *params)
4431 {
4432   struct ppc_link_hash_table *htab;
4433
4434   elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4435
4436 /* Always hook our dynamic sections into the first bfd, which is the
4437    linker created stub bfd.  This ensures that the GOT header is at
4438    the start of the output TOC section.  */
4439   htab = ppc_hash_table (info);
4440   htab->elf.dynobj = params->stub_bfd;
4441   htab->params = params;
4442
4443   return create_linkage_sections (htab->elf.dynobj, info);
4444 }
4445
4446 /* Build a name for an entry in the stub hash table.  */
4447
4448 static char *
4449 ppc_stub_name (const asection *input_section,
4450                const asection *sym_sec,
4451                const struct ppc_link_hash_entry *h,
4452                const Elf_Internal_Rela *rel)
4453 {
4454   char *stub_name;
4455   ssize_t len;
4456
4457   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4458      offsets from a sym as a branch target?  In fact, we could
4459      probably assume the addend is always zero.  */
4460   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4461
4462   if (h)
4463     {
4464       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4465       stub_name = bfd_malloc (len);
4466       if (stub_name == NULL)
4467         return stub_name;
4468
4469       len = sprintf (stub_name, "%08x.%s+%x",
4470                      input_section->id & 0xffffffff,
4471                      h->elf.root.root.string,
4472                      (int) rel->r_addend & 0xffffffff);
4473     }
4474   else
4475     {
4476       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4477       stub_name = bfd_malloc (len);
4478       if (stub_name == NULL)
4479         return stub_name;
4480
4481       len = sprintf (stub_name, "%08x.%x:%x+%x",
4482                      input_section->id & 0xffffffff,
4483                      sym_sec->id & 0xffffffff,
4484                      (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4485                      (int) rel->r_addend & 0xffffffff);
4486     }
4487   if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4488     stub_name[len - 2] = 0;
4489   return stub_name;
4490 }
4491
4492 /* Look up an entry in the stub hash.  Stub entries are cached because
4493    creating the stub name takes a bit of time.  */
4494
4495 static struct ppc_stub_hash_entry *
4496 ppc_get_stub_entry (const asection *input_section,
4497                     const asection *sym_sec,
4498                     struct ppc_link_hash_entry *h,
4499                     const Elf_Internal_Rela *rel,
4500                     struct ppc_link_hash_table *htab)
4501 {
4502   struct ppc_stub_hash_entry *stub_entry;
4503   struct map_stub *group;
4504
4505   /* If this input section is part of a group of sections sharing one
4506      stub section, then use the id of the first section in the group.
4507      Stub names need to include a section id, as there may well be
4508      more than one stub used to reach say, printf, and we need to
4509      distinguish between them.  */
4510   group = htab->sec_info[input_section->id].u.group;
4511   if (group == NULL)
4512     return NULL;
4513
4514   if (h != NULL && h->u.stub_cache != NULL
4515       && h->u.stub_cache->h == h
4516       && h->u.stub_cache->group == group)
4517     {
4518       stub_entry = h->u.stub_cache;
4519     }
4520   else
4521     {
4522       char *stub_name;
4523
4524       stub_name = ppc_stub_name (group->link_sec, sym_sec, h, rel);
4525       if (stub_name == NULL)
4526         return NULL;
4527
4528       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4529                                          stub_name, FALSE, FALSE);
4530       if (h != NULL)
4531         h->u.stub_cache = stub_entry;
4532
4533       free (stub_name);
4534     }
4535
4536   return stub_entry;
4537 }
4538
4539 /* Add a new stub entry to the stub hash.  Not all fields of the new
4540    stub entry are initialised.  */
4541
4542 static struct ppc_stub_hash_entry *
4543 ppc_add_stub (const char *stub_name,
4544               asection *section,
4545               struct bfd_link_info *info)
4546 {
4547   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4548   struct map_stub *group;
4549   asection *link_sec;
4550   asection *stub_sec;
4551   struct ppc_stub_hash_entry *stub_entry;
4552
4553   group = htab->sec_info[section->id].u.group;
4554   link_sec = group->link_sec;
4555   stub_sec = group->stub_sec;
4556   if (stub_sec == NULL)
4557     {
4558       size_t namelen;
4559       bfd_size_type len;
4560       char *s_name;
4561
4562       namelen = strlen (link_sec->name);
4563       len = namelen + sizeof (STUB_SUFFIX);
4564       s_name = bfd_alloc (htab->params->stub_bfd, len);
4565       if (s_name == NULL)
4566         return NULL;
4567
4568       memcpy (s_name, link_sec->name, namelen);
4569       memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4570       stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4571       if (stub_sec == NULL)
4572         return NULL;
4573       group->stub_sec = stub_sec;
4574     }
4575
4576   /* Enter this entry into the linker stub hash table.  */
4577   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4578                                      TRUE, FALSE);
4579   if (stub_entry == NULL)
4580     {
4581       info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4582                               section->owner, stub_name);
4583       return NULL;
4584     }
4585
4586   stub_entry->group = group;
4587   stub_entry->stub_offset = 0;
4588   return stub_entry;
4589 }
4590
4591 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4592    not already done.  */
4593
4594 static bfd_boolean
4595 create_got_section (bfd *abfd, struct bfd_link_info *info)
4596 {
4597   asection *got, *relgot;
4598   flagword flags;
4599   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4600
4601   if (!is_ppc64_elf (abfd))
4602     return FALSE;
4603   if (htab == NULL)
4604     return FALSE;
4605
4606   if (!htab->elf.sgot
4607       && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4608     return FALSE;
4609
4610   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4611            | SEC_LINKER_CREATED);
4612
4613   got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4614   if (!got
4615       || !bfd_set_section_alignment (abfd, got, 3))
4616     return FALSE;
4617
4618   relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4619                                                flags | SEC_READONLY);
4620   if (!relgot
4621       || ! bfd_set_section_alignment (abfd, relgot, 3))
4622     return FALSE;
4623
4624   ppc64_elf_tdata (abfd)->got = got;
4625   ppc64_elf_tdata (abfd)->relgot = relgot;
4626   return TRUE;
4627 }
4628
4629 /* Create the dynamic sections, and set up shortcuts.  */
4630
4631 static bfd_boolean
4632 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4633 {
4634   struct ppc_link_hash_table *htab;
4635
4636   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4637     return FALSE;
4638
4639   htab = ppc_hash_table (info);
4640   if (htab == NULL)
4641     return FALSE;
4642
4643   htab->dynbss = bfd_get_linker_section (dynobj, ".dynbss");
4644   if (!bfd_link_pic (info))
4645     htab->relbss = bfd_get_linker_section (dynobj, ".rela.bss");
4646
4647   if (!htab->elf.sgot || !htab->elf.splt || !htab->elf.srelplt || !htab->dynbss
4648       || (!bfd_link_pic (info) && !htab->relbss))
4649     abort ();
4650
4651   return TRUE;
4652 }
4653
4654 /* Follow indirect and warning symbol links.  */
4655
4656 static inline struct bfd_link_hash_entry *
4657 follow_link (struct bfd_link_hash_entry *h)
4658 {
4659   while (h->type == bfd_link_hash_indirect
4660          || h->type == bfd_link_hash_warning)
4661     h = h->u.i.link;
4662   return h;
4663 }
4664
4665 static inline struct elf_link_hash_entry *
4666 elf_follow_link (struct elf_link_hash_entry *h)
4667 {
4668   return (struct elf_link_hash_entry *) follow_link (&h->root);
4669 }
4670
4671 static inline struct ppc_link_hash_entry *
4672 ppc_follow_link (struct ppc_link_hash_entry *h)
4673 {
4674   return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4675 }
4676
4677 /* Merge PLT info on FROM with that on TO.  */
4678
4679 static void
4680 move_plt_plist (struct ppc_link_hash_entry *from,
4681                 struct ppc_link_hash_entry *to)
4682 {
4683   if (from->elf.plt.plist != NULL)
4684     {
4685       if (to->elf.plt.plist != NULL)
4686         {
4687           struct plt_entry **entp;
4688           struct plt_entry *ent;
4689
4690           for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4691             {
4692               struct plt_entry *dent;
4693
4694               for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4695                 if (dent->addend == ent->addend)
4696                   {
4697                     dent->plt.refcount += ent->plt.refcount;
4698                     *entp = ent->next;
4699                     break;
4700                   }
4701               if (dent == NULL)
4702                 entp = &ent->next;
4703             }
4704           *entp = to->elf.plt.plist;
4705         }
4706
4707       to->elf.plt.plist = from->elf.plt.plist;
4708       from->elf.plt.plist = NULL;
4709     }
4710 }
4711
4712 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
4713
4714 static void
4715 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4716                                 struct elf_link_hash_entry *dir,
4717                                 struct elf_link_hash_entry *ind)
4718 {
4719   struct ppc_link_hash_entry *edir, *eind;
4720
4721   edir = (struct ppc_link_hash_entry *) dir;
4722   eind = (struct ppc_link_hash_entry *) ind;
4723
4724   edir->is_func |= eind->is_func;
4725   edir->is_func_descriptor |= eind->is_func_descriptor;
4726   edir->tls_mask |= eind->tls_mask;
4727   if (eind->oh != NULL)
4728     edir->oh = ppc_follow_link (eind->oh);
4729
4730   /* If called to transfer flags for a weakdef during processing
4731      of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4732      We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
4733   if (!(ELIMINATE_COPY_RELOCS
4734         && eind->elf.root.type != bfd_link_hash_indirect
4735         && edir->elf.dynamic_adjusted))
4736     edir->elf.non_got_ref |= eind->elf.non_got_ref;
4737
4738   edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4739   edir->elf.ref_regular |= eind->elf.ref_regular;
4740   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4741   edir->elf.needs_plt |= eind->elf.needs_plt;
4742   edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4743
4744   /* If we were called to copy over info for a weak sym, don't copy
4745      dyn_relocs, plt/got info, or dynindx.  We used to copy dyn_relocs
4746      in order to simplify readonly_dynrelocs and save a field in the
4747      symbol hash entry, but that means dyn_relocs can't be used in any
4748      tests about a specific symbol, or affect other symbol flags which
4749      are then tested.
4750      Chain weakdefs so we can get from the weakdef back to an alias.
4751      The list is circular so that we don't need to use u.weakdef as
4752      well as this list to look at all aliases.  */
4753   if (eind->elf.root.type != bfd_link_hash_indirect)
4754     {
4755       struct ppc_link_hash_entry *cur, *add, *next;
4756
4757       add = eind;
4758       do
4759         {
4760           cur = edir->weakref;
4761           if (cur != NULL)
4762             {
4763               do
4764                 {
4765                   /* We can be called twice for the same symbols.
4766                      Don't make multiple loops.  */
4767                   if (cur == add)
4768                     return;
4769                   cur = cur->weakref;
4770                 } while (cur != edir);
4771             }
4772           next = add->weakref;
4773           if (cur != add)
4774             {
4775               add->weakref = edir->weakref != NULL ? edir->weakref : edir;
4776               edir->weakref = add;
4777             }
4778           add = next;
4779         } while (add != NULL && add != eind);
4780       return;
4781     }
4782
4783   /* Copy over any dynamic relocs we may have on the indirect sym.  */
4784   if (eind->dyn_relocs != NULL)
4785     {
4786       if (edir->dyn_relocs != NULL)
4787         {
4788           struct elf_dyn_relocs **pp;
4789           struct elf_dyn_relocs *p;
4790
4791           /* Add reloc counts against the indirect sym to the direct sym
4792              list.  Merge any entries against the same section.  */
4793           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4794             {
4795               struct elf_dyn_relocs *q;
4796
4797               for (q = edir->dyn_relocs; q != NULL; q = q->next)
4798                 if (q->sec == p->sec)
4799                   {
4800                     q->pc_count += p->pc_count;
4801                     q->count += p->count;
4802                     *pp = p->next;
4803                     break;
4804                   }
4805               if (q == NULL)
4806                 pp = &p->next;
4807             }
4808           *pp = edir->dyn_relocs;
4809         }
4810
4811       edir->dyn_relocs = eind->dyn_relocs;
4812       eind->dyn_relocs = NULL;
4813     }
4814
4815   /* Copy over got entries that we may have already seen to the
4816      symbol which just became indirect.  */
4817   if (eind->elf.got.glist != NULL)
4818     {
4819       if (edir->elf.got.glist != NULL)
4820         {
4821           struct got_entry **entp;
4822           struct got_entry *ent;
4823
4824           for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4825             {
4826               struct got_entry *dent;
4827
4828               for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4829                 if (dent->addend == ent->addend
4830                     && dent->owner == ent->owner
4831                     && dent->tls_type == ent->tls_type)
4832                   {
4833                     dent->got.refcount += ent->got.refcount;
4834                     *entp = ent->next;
4835                     break;
4836                   }
4837               if (dent == NULL)
4838                 entp = &ent->next;
4839             }
4840           *entp = edir->elf.got.glist;
4841         }
4842
4843       edir->elf.got.glist = eind->elf.got.glist;
4844       eind->elf.got.glist = NULL;
4845     }
4846
4847   /* And plt entries.  */
4848   move_plt_plist (eind, edir);
4849
4850   if (eind->elf.dynindx != -1)
4851     {
4852       if (edir->elf.dynindx != -1)
4853         _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4854                                 edir->elf.dynstr_index);
4855       edir->elf.dynindx = eind->elf.dynindx;
4856       edir->elf.dynstr_index = eind->elf.dynstr_index;
4857       eind->elf.dynindx = -1;
4858       eind->elf.dynstr_index = 0;
4859     }
4860 }
4861
4862 /* Find the function descriptor hash entry from the given function code
4863    hash entry FH.  Link the entries via their OH fields.  */
4864
4865 static struct ppc_link_hash_entry *
4866 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4867 {
4868   struct ppc_link_hash_entry *fdh = fh->oh;
4869
4870   if (fdh == NULL)
4871     {
4872       const char *fd_name = fh->elf.root.root.string + 1;
4873
4874       fdh = (struct ppc_link_hash_entry *)
4875         elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4876       if (fdh == NULL)
4877         return fdh;
4878
4879       fdh->is_func_descriptor = 1;
4880       fdh->oh = fh;
4881       fh->is_func = 1;
4882       fh->oh = fdh;
4883     }
4884
4885   return ppc_follow_link (fdh);
4886 }
4887
4888 /* Make a fake function descriptor sym for the code sym FH.  */
4889
4890 static struct ppc_link_hash_entry *
4891 make_fdh (struct bfd_link_info *info,
4892           struct ppc_link_hash_entry *fh)
4893 {
4894   bfd *abfd;
4895   asymbol *newsym;
4896   struct bfd_link_hash_entry *bh;
4897   struct ppc_link_hash_entry *fdh;
4898
4899   abfd = fh->elf.root.u.undef.abfd;
4900   newsym = bfd_make_empty_symbol (abfd);
4901   newsym->name = fh->elf.root.root.string + 1;
4902   newsym->section = bfd_und_section_ptr;
4903   newsym->value = 0;
4904   newsym->flags = BSF_WEAK;
4905
4906   bh = NULL;
4907   if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4908                                          newsym->flags, newsym->section,
4909                                          newsym->value, NULL, FALSE, FALSE,
4910                                          &bh))
4911     return NULL;
4912
4913   fdh = (struct ppc_link_hash_entry *) bh;
4914   fdh->elf.non_elf = 0;
4915   fdh->fake = 1;
4916   fdh->is_func_descriptor = 1;
4917   fdh->oh = fh;
4918   fh->is_func = 1;
4919   fh->oh = fdh;
4920   return fdh;
4921 }
4922
4923 /* Fix function descriptor symbols defined in .opd sections to be
4924    function type.  */
4925
4926 static bfd_boolean
4927 ppc64_elf_add_symbol_hook (bfd *ibfd,
4928                            struct bfd_link_info *info,
4929                            Elf_Internal_Sym *isym,
4930                            const char **name,
4931                            flagword *flags ATTRIBUTE_UNUSED,
4932                            asection **sec,
4933                            bfd_vma *value)
4934 {
4935   if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4936       && (ibfd->flags & DYNAMIC) == 0
4937       && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
4938     elf_tdata (info->output_bfd)->has_gnu_symbols |= elf_gnu_symbol_ifunc;
4939
4940   if (*sec != NULL
4941       && strcmp ((*sec)->name, ".opd") == 0)
4942     {
4943       asection *code_sec;
4944
4945       if (!(ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4946             || ELF_ST_TYPE (isym->st_info) == STT_FUNC))
4947         isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4948
4949       /* If the symbol is a function defined in .opd, and the function
4950          code is in a discarded group, let it appear to be undefined.  */
4951       if (!bfd_link_relocatable (info)
4952           && (*sec)->reloc_count != 0
4953           && opd_entry_value (*sec, *value, &code_sec, NULL,
4954                               FALSE) != (bfd_vma) -1
4955           && discarded_section (code_sec))
4956         {
4957           *sec = bfd_und_section_ptr;
4958           isym->st_shndx = SHN_UNDEF;
4959         }
4960     }
4961   else if (*sec != NULL
4962            && strcmp ((*sec)->name, ".toc") == 0
4963            && ELF_ST_TYPE (isym->st_info) == STT_OBJECT)
4964     {
4965       struct ppc_link_hash_table *htab = ppc_hash_table (info);
4966       if (htab != NULL)
4967         htab->params->object_in_toc = 1;
4968     }
4969
4970   if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4971     {
4972       if (abiversion (ibfd) == 0)
4973         set_abiversion (ibfd, 2);
4974       else if (abiversion (ibfd) == 1)
4975         {
4976           info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other"
4977                                     " for ABI version 1\n"), name);
4978           bfd_set_error (bfd_error_bad_value);
4979           return FALSE;
4980         }
4981     }
4982
4983   return TRUE;
4984 }
4985
4986 /* Merge non-visibility st_other attributes: local entry point.  */
4987
4988 static void
4989 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
4990                                   const Elf_Internal_Sym *isym,
4991                                   bfd_boolean definition,
4992                                   bfd_boolean dynamic)
4993 {
4994   if (definition && !dynamic)
4995     h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
4996                 | ELF_ST_VISIBILITY (h->other));
4997 }
4998
4999 /* This function makes an old ABI object reference to ".bar" cause the
5000    inclusion of a new ABI object archive that defines "bar".
5001    NAME is a symbol defined in an archive.  Return a symbol in the hash
5002    table that might be satisfied by the archive symbols.  */
5003
5004 static struct elf_link_hash_entry *
5005 ppc64_elf_archive_symbol_lookup (bfd *abfd,
5006                                  struct bfd_link_info *info,
5007                                  const char *name)
5008 {
5009   struct elf_link_hash_entry *h;
5010   char *dot_name;
5011   size_t len;
5012
5013   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
5014   if (h != NULL
5015       /* Don't return this sym if it is a fake function descriptor
5016          created by add_symbol_adjust.  */
5017       && !(h->root.type == bfd_link_hash_undefweak
5018            && ((struct ppc_link_hash_entry *) h)->fake))
5019     return h;
5020
5021   if (name[0] == '.')
5022     return h;
5023
5024   len = strlen (name);
5025   dot_name = bfd_alloc (abfd, len + 2);
5026   if (dot_name == NULL)
5027     return (struct elf_link_hash_entry *) 0 - 1;
5028   dot_name[0] = '.';
5029   memcpy (dot_name + 1, name, len + 1);
5030   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
5031   bfd_release (abfd, dot_name);
5032   return h;
5033 }
5034
5035 /* This function satisfies all old ABI object references to ".bar" if a
5036    new ABI object defines "bar".  Well, at least, undefined dot symbols
5037    are made weak.  This stops later archive searches from including an
5038    object if we already have a function descriptor definition.  It also
5039    prevents the linker complaining about undefined symbols.
5040    We also check and correct mismatched symbol visibility here.  The
5041    most restrictive visibility of the function descriptor and the
5042    function entry symbol is used.  */
5043
5044 static bfd_boolean
5045 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
5046 {
5047   struct ppc_link_hash_table *htab;
5048   struct ppc_link_hash_entry *fdh;
5049
5050   if (eh->elf.root.type == bfd_link_hash_indirect)
5051     return TRUE;
5052
5053   if (eh->elf.root.type == bfd_link_hash_warning)
5054     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
5055
5056   if (eh->elf.root.root.string[0] != '.')
5057     abort ();
5058
5059   htab = ppc_hash_table (info);
5060   if (htab == NULL)
5061     return FALSE;
5062
5063   fdh = lookup_fdh (eh, htab);
5064   if (fdh == NULL)
5065     {
5066       if (!bfd_link_relocatable (info)
5067           && (eh->elf.root.type == bfd_link_hash_undefined
5068               || eh->elf.root.type == bfd_link_hash_undefweak)
5069           && eh->elf.ref_regular)
5070         {
5071           /* Make an undefweak function descriptor sym, which is enough to
5072              pull in an --as-needed shared lib, but won't cause link
5073              errors.  Archives are handled elsewhere.  */
5074           fdh = make_fdh (info, eh);
5075           if (fdh == NULL)
5076             return FALSE;
5077           fdh->elf.ref_regular = 1;
5078         }
5079     }
5080   else
5081     {
5082       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
5083       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
5084       if (entry_vis < descr_vis)
5085         fdh->elf.other += entry_vis - descr_vis;
5086       else if (entry_vis > descr_vis)
5087         eh->elf.other += descr_vis - entry_vis;
5088
5089       if ((fdh->elf.root.type == bfd_link_hash_defined
5090            || fdh->elf.root.type == bfd_link_hash_defweak)
5091           && eh->elf.root.type == bfd_link_hash_undefined)
5092         {
5093           eh->elf.root.type = bfd_link_hash_undefweak;
5094           eh->was_undefined = 1;
5095           htab->twiddled_syms = 1;
5096         }
5097     }
5098
5099   return TRUE;
5100 }
5101
5102 /* Set up opd section info and abiversion for IBFD, and process list
5103    of dot-symbols we made in link_hash_newfunc.  */
5104
5105 static bfd_boolean
5106 ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
5107 {
5108   struct ppc_link_hash_table *htab;
5109   struct ppc_link_hash_entry **p, *eh;
5110   asection *opd = bfd_get_section_by_name (ibfd, ".opd");
5111
5112   if (opd != NULL && opd->size != 0)
5113     {
5114       if (abiversion (ibfd) == 0)
5115         set_abiversion (ibfd, 1);
5116       else if (abiversion (ibfd) >= 2)
5117         {
5118           info->callbacks->einfo (_("%P: %B .opd not allowed in ABI"
5119                                     " version %d\n"),
5120                                   ibfd, abiversion (ibfd));
5121           bfd_set_error (bfd_error_bad_value);
5122           return FALSE;
5123         }
5124
5125       if ((ibfd->flags & DYNAMIC) == 0
5126           && (opd->flags & SEC_RELOC) != 0
5127           && opd->reloc_count != 0
5128           && !bfd_is_abs_section (opd->output_section))
5129         {
5130           /* Garbage collection needs some extra help with .opd sections.
5131              We don't want to necessarily keep everything referenced by
5132              relocs in .opd, as that would keep all functions.  Instead,
5133              if we reference an .opd symbol (a function descriptor), we
5134              want to keep the function code symbol's section.  This is
5135              easy for global symbols, but for local syms we need to keep
5136              information about the associated function section.  */
5137           bfd_size_type amt;
5138           asection **opd_sym_map;
5139
5140           amt = OPD_NDX (opd->size) * sizeof (*opd_sym_map);
5141           opd_sym_map = bfd_zalloc (ibfd, amt);
5142           if (opd_sym_map == NULL)
5143             return FALSE;
5144           ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
5145           BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
5146           ppc64_elf_section_data (opd)->sec_type = sec_opd;
5147         }
5148     }
5149
5150   if (!is_ppc64_elf (info->output_bfd))
5151     return TRUE;
5152   htab = ppc_hash_table (info);
5153   if (htab == NULL)
5154     return FALSE;
5155
5156   /* For input files without an explicit abiversion in e_flags
5157      we should have flagged any with symbol st_other bits set
5158      as ELFv1 and above flagged those with .opd as ELFv2.
5159      Set the output abiversion if not yet set, and for any input
5160      still ambiguous, take its abiversion from the output.
5161      Differences in ABI are reported later.  */
5162   if (abiversion (info->output_bfd) == 0)
5163     set_abiversion (info->output_bfd, abiversion (ibfd));
5164   else if (abiversion (ibfd) == 0)
5165     set_abiversion (ibfd, abiversion (info->output_bfd));
5166
5167   p = &htab->dot_syms;
5168   while ((eh = *p) != NULL)
5169     {
5170       *p = NULL;
5171       if (&eh->elf == htab->elf.hgot)
5172         ;
5173       else if (htab->elf.hgot == NULL
5174                && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
5175         htab->elf.hgot = &eh->elf;
5176       else if (!add_symbol_adjust (eh, info))
5177         return FALSE;
5178       p = &eh->u.next_dot_sym;
5179     }
5180
5181   /* Clear the list for non-ppc64 input files.  */
5182   p = &htab->dot_syms;
5183   while ((eh = *p) != NULL)
5184     {
5185       *p = NULL;
5186       p = &eh->u.next_dot_sym;
5187     }
5188
5189   /* We need to fix the undefs list for any syms we have twiddled to
5190      undefweak.  */
5191   if (htab->twiddled_syms)
5192     {
5193       bfd_link_repair_undef_list (&htab->elf.root);
5194       htab->twiddled_syms = 0;
5195     }
5196   return TRUE;
5197 }
5198
5199 /* Undo hash table changes when an --as-needed input file is determined
5200    not to be needed.  */
5201
5202 static bfd_boolean
5203 ppc64_elf_notice_as_needed (bfd *ibfd,
5204                             struct bfd_link_info *info,
5205                             enum notice_asneeded_action act)
5206 {
5207   if (act == notice_not_needed)
5208     {
5209       struct ppc_link_hash_table *htab = ppc_hash_table (info);
5210
5211       if (htab == NULL)
5212         return FALSE;
5213
5214       htab->dot_syms = NULL;
5215     }
5216   return _bfd_elf_notice_as_needed (ibfd, info, act);
5217 }
5218
5219 /* If --just-symbols against a final linked binary, then assume we need
5220    toc adjusting stubs when calling functions defined there.  */
5221
5222 static void
5223 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5224 {
5225   if ((sec->flags & SEC_CODE) != 0
5226       && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5227       && is_ppc64_elf (sec->owner))
5228     {
5229       if (abiversion (sec->owner) >= 2
5230           || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5231         sec->has_toc_reloc = 1;
5232     }
5233   _bfd_elf_link_just_syms (sec, info);
5234 }
5235
5236 static struct plt_entry **
5237 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5238                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5239 {
5240   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5241   struct plt_entry **local_plt;
5242   unsigned char *local_got_tls_masks;
5243
5244   if (local_got_ents == NULL)
5245     {
5246       bfd_size_type size = symtab_hdr->sh_info;
5247
5248       size *= (sizeof (*local_got_ents)
5249                + sizeof (*local_plt)
5250                + sizeof (*local_got_tls_masks));
5251       local_got_ents = bfd_zalloc (abfd, size);
5252       if (local_got_ents == NULL)
5253         return NULL;
5254       elf_local_got_ents (abfd) = local_got_ents;
5255     }
5256
5257   if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
5258     {
5259       struct got_entry *ent;
5260
5261       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5262         if (ent->addend == r_addend
5263             && ent->owner == abfd
5264             && ent->tls_type == tls_type)
5265           break;
5266       if (ent == NULL)
5267         {
5268           bfd_size_type amt = sizeof (*ent);
5269           ent = bfd_alloc (abfd, amt);
5270           if (ent == NULL)
5271             return FALSE;
5272           ent->next = local_got_ents[r_symndx];
5273           ent->addend = r_addend;
5274           ent->owner = abfd;
5275           ent->tls_type = tls_type;
5276           ent->is_indirect = FALSE;
5277           ent->got.refcount = 0;
5278           local_got_ents[r_symndx] = ent;
5279         }
5280       ent->got.refcount += 1;
5281     }
5282
5283   local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5284   local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5285   local_got_tls_masks[r_symndx] |= tls_type;
5286
5287   return local_plt + r_symndx;
5288 }
5289
5290 static bfd_boolean
5291 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5292 {
5293   struct plt_entry *ent;
5294
5295   for (ent = *plist; ent != NULL; ent = ent->next)
5296     if (ent->addend == addend)
5297       break;
5298   if (ent == NULL)
5299     {
5300       bfd_size_type amt = sizeof (*ent);
5301       ent = bfd_alloc (abfd, amt);
5302       if (ent == NULL)
5303         return FALSE;
5304       ent->next = *plist;
5305       ent->addend = addend;
5306       ent->plt.refcount = 0;
5307       *plist = ent;
5308     }
5309   ent->plt.refcount += 1;
5310   return TRUE;
5311 }
5312
5313 static bfd_boolean
5314 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5315 {
5316   return (r_type == R_PPC64_REL24
5317           || r_type == R_PPC64_REL14
5318           || r_type == R_PPC64_REL14_BRTAKEN
5319           || r_type == R_PPC64_REL14_BRNTAKEN
5320           || r_type == R_PPC64_ADDR24
5321           || r_type == R_PPC64_ADDR14
5322           || r_type == R_PPC64_ADDR14_BRTAKEN
5323           || r_type == R_PPC64_ADDR14_BRNTAKEN);
5324 }
5325
5326 /* Look through the relocs for a section during the first phase, and
5327    calculate needed space in the global offset table, procedure
5328    linkage table, and dynamic reloc sections.  */
5329
5330 static bfd_boolean
5331 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5332                         asection *sec, const Elf_Internal_Rela *relocs)
5333 {
5334   struct ppc_link_hash_table *htab;
5335   Elf_Internal_Shdr *symtab_hdr;
5336   struct elf_link_hash_entry **sym_hashes;
5337   const Elf_Internal_Rela *rel;
5338   const Elf_Internal_Rela *rel_end;
5339   asection *sreloc;
5340   asection **opd_sym_map;
5341   struct elf_link_hash_entry *tga, *dottga;
5342
5343   if (bfd_link_relocatable (info))
5344     return TRUE;
5345
5346   /* Don't do anything special with non-loaded, non-alloced sections.
5347      In particular, any relocs in such sections should not affect GOT
5348      and PLT reference counting (ie. we don't allow them to create GOT
5349      or PLT entries), there's no possibility or desire to optimize TLS
5350      relocs, and there's not much point in propagating relocs to shared
5351      libs that the dynamic linker won't relocate.  */
5352   if ((sec->flags & SEC_ALLOC) == 0)
5353     return TRUE;
5354
5355   BFD_ASSERT (is_ppc64_elf (abfd));
5356
5357   htab = ppc_hash_table (info);
5358   if (htab == NULL)
5359     return FALSE;
5360
5361   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5362                               FALSE, FALSE, TRUE);
5363   dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5364                                  FALSE, FALSE, TRUE);
5365   symtab_hdr = &elf_symtab_hdr (abfd);
5366   sym_hashes = elf_sym_hashes (abfd);
5367   sreloc = NULL;
5368   opd_sym_map = NULL;
5369   if (ppc64_elf_section_data (sec) != NULL
5370       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
5371     opd_sym_map = ppc64_elf_section_data (sec)->u.opd.func_sec;
5372
5373   rel_end = relocs + sec->reloc_count;
5374   for (rel = relocs; rel < rel_end; rel++)
5375     {
5376       unsigned long r_symndx;
5377       struct elf_link_hash_entry *h;
5378       enum elf_ppc64_reloc_type r_type;
5379       int tls_type;
5380       struct _ppc64_elf_section_data *ppc64_sec;
5381       struct plt_entry **ifunc, **plt_list;
5382
5383       r_symndx = ELF64_R_SYM (rel->r_info);
5384       if (r_symndx < symtab_hdr->sh_info)
5385         h = NULL;
5386       else
5387         {
5388           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5389           h = elf_follow_link (h);
5390
5391           /* PR15323, ref flags aren't set for references in the same
5392              object.  */
5393           h->root.non_ir_ref = 1;
5394
5395           if (h == htab->elf.hgot)
5396             sec->has_toc_reloc = 1;
5397         }
5398
5399       tls_type = 0;
5400       ifunc = NULL;
5401       if (h != NULL)
5402         {
5403           if (h->type == STT_GNU_IFUNC)
5404             {
5405               h->needs_plt = 1;
5406               ifunc = &h->plt.plist;
5407             }
5408         }
5409       else
5410         {
5411           Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5412                                                           abfd, r_symndx);
5413           if (isym == NULL)
5414             return FALSE;
5415
5416           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5417             {
5418               ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5419                                              rel->r_addend, PLT_IFUNC);
5420               if (ifunc == NULL)
5421                 return FALSE;
5422             }
5423         }
5424
5425       r_type = ELF64_R_TYPE (rel->r_info);
5426       switch (r_type)
5427         {
5428         case R_PPC64_TLSGD:
5429         case R_PPC64_TLSLD:
5430           /* These special tls relocs tie a call to __tls_get_addr with
5431              its parameter symbol.  */
5432           break;
5433
5434         case R_PPC64_GOT_TLSLD16:
5435         case R_PPC64_GOT_TLSLD16_LO:
5436         case R_PPC64_GOT_TLSLD16_HI:
5437         case R_PPC64_GOT_TLSLD16_HA:
5438           tls_type = TLS_TLS | TLS_LD;
5439           goto dogottls;
5440
5441         case R_PPC64_GOT_TLSGD16:
5442         case R_PPC64_GOT_TLSGD16_LO:
5443         case R_PPC64_GOT_TLSGD16_HI:
5444         case R_PPC64_GOT_TLSGD16_HA:
5445           tls_type = TLS_TLS | TLS_GD;
5446           goto dogottls;
5447
5448         case R_PPC64_GOT_TPREL16_DS:
5449         case R_PPC64_GOT_TPREL16_LO_DS:
5450         case R_PPC64_GOT_TPREL16_HI:
5451         case R_PPC64_GOT_TPREL16_HA:
5452           if (bfd_link_pic (info))
5453             info->flags |= DF_STATIC_TLS;
5454           tls_type = TLS_TLS | TLS_TPREL;
5455           goto dogottls;
5456
5457         case R_PPC64_GOT_DTPREL16_DS:
5458         case R_PPC64_GOT_DTPREL16_LO_DS:
5459         case R_PPC64_GOT_DTPREL16_HI:
5460         case R_PPC64_GOT_DTPREL16_HA:
5461           tls_type = TLS_TLS | TLS_DTPREL;
5462         dogottls:
5463           sec->has_tls_reloc = 1;
5464           /* Fall thru */
5465
5466         case R_PPC64_GOT16:
5467         case R_PPC64_GOT16_DS:
5468         case R_PPC64_GOT16_HA:
5469         case R_PPC64_GOT16_HI:
5470         case R_PPC64_GOT16_LO:
5471         case R_PPC64_GOT16_LO_DS:
5472           /* This symbol requires a global offset table entry.  */
5473           sec->has_toc_reloc = 1;
5474           if (r_type == R_PPC64_GOT_TLSLD16
5475               || r_type == R_PPC64_GOT_TLSGD16
5476               || r_type == R_PPC64_GOT_TPREL16_DS
5477               || r_type == R_PPC64_GOT_DTPREL16_DS
5478               || r_type == R_PPC64_GOT16
5479               || r_type == R_PPC64_GOT16_DS)
5480             {
5481               htab->do_multi_toc = 1;
5482               ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5483             }
5484
5485           if (ppc64_elf_tdata (abfd)->got == NULL
5486               && !create_got_section (abfd, info))
5487             return FALSE;
5488
5489           if (h != NULL)
5490             {
5491               struct ppc_link_hash_entry *eh;
5492               struct got_entry *ent;
5493
5494               eh = (struct ppc_link_hash_entry *) h;
5495               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5496                 if (ent->addend == rel->r_addend
5497                     && ent->owner == abfd
5498                     && ent->tls_type == tls_type)
5499                   break;
5500               if (ent == NULL)
5501                 {
5502                   bfd_size_type amt = sizeof (*ent);
5503                   ent = bfd_alloc (abfd, amt);
5504                   if (ent == NULL)
5505                     return FALSE;
5506                   ent->next = eh->elf.got.glist;
5507                   ent->addend = rel->r_addend;
5508                   ent->owner = abfd;
5509                   ent->tls_type = tls_type;
5510                   ent->is_indirect = FALSE;
5511                   ent->got.refcount = 0;
5512                   eh->elf.got.glist = ent;
5513                 }
5514               ent->got.refcount += 1;
5515               eh->tls_mask |= tls_type;
5516             }
5517           else
5518             /* This is a global offset table entry for a local symbol.  */
5519             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5520                                         rel->r_addend, tls_type))
5521               return FALSE;
5522
5523           /* We may also need a plt entry if the symbol turns out to be
5524              an ifunc.  */
5525           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1)
5526             {
5527               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5528                 return FALSE;
5529             }
5530           break;
5531
5532         case R_PPC64_PLT16_HA:
5533         case R_PPC64_PLT16_HI:
5534         case R_PPC64_PLT16_LO:
5535         case R_PPC64_PLT32:
5536         case R_PPC64_PLT64:
5537           /* This symbol requires a procedure linkage table entry.  */
5538           plt_list = ifunc;
5539           if (h != NULL)
5540             {
5541               h->needs_plt = 1;
5542               if (h->root.root.string[0] == '.'
5543                   && h->root.root.string[1] != '\0')
5544                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5545               plt_list = &h->plt.plist;
5546             }
5547           if (plt_list == NULL)
5548             {
5549               /* It does not make sense to have a procedure linkage
5550                  table entry for a non-ifunc local symbol.  */
5551               info->callbacks->einfo
5552                 (_("%P: %H: %s reloc against local symbol\n"),
5553                  abfd, sec, rel->r_offset,
5554                  ppc64_elf_howto_table[r_type]->name);
5555               bfd_set_error (bfd_error_bad_value);
5556               return FALSE;
5557             }
5558           if (!update_plt_info (abfd, plt_list, rel->r_addend))
5559             return FALSE;
5560           break;
5561
5562           /* The following relocations don't need to propagate the
5563              relocation if linking a shared object since they are
5564              section relative.  */
5565         case R_PPC64_SECTOFF:
5566         case R_PPC64_SECTOFF_LO:
5567         case R_PPC64_SECTOFF_HI:
5568         case R_PPC64_SECTOFF_HA:
5569         case R_PPC64_SECTOFF_DS:
5570         case R_PPC64_SECTOFF_LO_DS:
5571         case R_PPC64_DTPREL16:
5572         case R_PPC64_DTPREL16_LO:
5573         case R_PPC64_DTPREL16_HI:
5574         case R_PPC64_DTPREL16_HA:
5575         case R_PPC64_DTPREL16_DS:
5576         case R_PPC64_DTPREL16_LO_DS:
5577         case R_PPC64_DTPREL16_HIGH:
5578         case R_PPC64_DTPREL16_HIGHA:
5579         case R_PPC64_DTPREL16_HIGHER:
5580         case R_PPC64_DTPREL16_HIGHERA:
5581         case R_PPC64_DTPREL16_HIGHEST:
5582         case R_PPC64_DTPREL16_HIGHESTA:
5583           break;
5584
5585           /* Nor do these.  */
5586         case R_PPC64_REL16:
5587         case R_PPC64_REL16_LO:
5588         case R_PPC64_REL16_HI:
5589         case R_PPC64_REL16_HA:
5590         case R_PPC64_REL16DX_HA:
5591           break;
5592
5593           /* Not supported as a dynamic relocation.  */
5594         case R_PPC64_ADDR64_LOCAL:
5595           if (bfd_link_pic (info))
5596             {
5597               if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5598                 ppc_howto_init ();
5599               info->callbacks->einfo (_("%P: %H: %s reloc unsupported "
5600                                         "in shared libraries and PIEs.\n"),
5601                                       abfd, sec, rel->r_offset,
5602                                       ppc64_elf_howto_table[r_type]->name);
5603               bfd_set_error (bfd_error_bad_value);
5604               return FALSE;
5605             }
5606           break;
5607
5608         case R_PPC64_TOC16:
5609         case R_PPC64_TOC16_DS:
5610           htab->do_multi_toc = 1;
5611           ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5612         case R_PPC64_TOC16_LO:
5613         case R_PPC64_TOC16_HI:
5614         case R_PPC64_TOC16_HA:
5615         case R_PPC64_TOC16_LO_DS:
5616           sec->has_toc_reloc = 1;
5617           break;
5618
5619           /* Marker reloc.  */
5620         case R_PPC64_ENTRY:
5621           break;
5622
5623           /* This relocation describes the C++ object vtable hierarchy.
5624              Reconstruct it for later use during GC.  */
5625         case R_PPC64_GNU_VTINHERIT:
5626           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5627             return FALSE;
5628           break;
5629
5630           /* This relocation describes which C++ vtable entries are actually
5631              used.  Record for later use during GC.  */
5632         case R_PPC64_GNU_VTENTRY:
5633           BFD_ASSERT (h != NULL);
5634           if (h != NULL
5635               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5636             return FALSE;
5637           break;
5638
5639         case R_PPC64_REL14:
5640         case R_PPC64_REL14_BRTAKEN:
5641         case R_PPC64_REL14_BRNTAKEN:
5642           {
5643             asection *dest = NULL;
5644
5645             /* Heuristic: If jumping outside our section, chances are
5646                we are going to need a stub.  */
5647             if (h != NULL)
5648               {
5649                 /* If the sym is weak it may be overridden later, so
5650                    don't assume we know where a weak sym lives.  */
5651                 if (h->root.type == bfd_link_hash_defined)
5652                   dest = h->root.u.def.section;
5653               }
5654             else
5655               {
5656                 Elf_Internal_Sym *isym;
5657
5658                 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5659                                               abfd, r_symndx);
5660                 if (isym == NULL)
5661                   return FALSE;
5662
5663                 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5664               }
5665
5666             if (dest != sec)
5667               ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5668           }
5669           /* Fall through.  */
5670
5671         case R_PPC64_REL24:
5672           plt_list = ifunc;
5673           if (h != NULL)
5674             {
5675               h->needs_plt = 1;
5676               if (h->root.root.string[0] == '.'
5677                   && h->root.root.string[1] != '\0')
5678                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5679
5680               if (h == tga || h == dottga)
5681                 {
5682                   sec->has_tls_reloc = 1;
5683                   if (rel != relocs
5684                       && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5685                           || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5686                     /* We have a new-style __tls_get_addr call with
5687                        a marker reloc.  */
5688                     ;
5689                   else
5690                     /* Mark this section as having an old-style call.  */
5691                     sec->has_tls_get_addr_call = 1;
5692                 }
5693               plt_list = &h->plt.plist;
5694             }
5695
5696           /* We may need a .plt entry if the function this reloc
5697              refers to is in a shared lib.  */
5698           if (plt_list
5699               && !update_plt_info (abfd, plt_list, rel->r_addend))
5700             return FALSE;
5701           break;
5702
5703         case R_PPC64_ADDR14:
5704         case R_PPC64_ADDR14_BRNTAKEN:
5705         case R_PPC64_ADDR14_BRTAKEN:
5706         case R_PPC64_ADDR24:
5707           goto dodyn;
5708
5709         case R_PPC64_TPREL64:
5710           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5711           if (bfd_link_pic (info))
5712             info->flags |= DF_STATIC_TLS;
5713           goto dotlstoc;
5714
5715         case R_PPC64_DTPMOD64:
5716           if (rel + 1 < rel_end
5717               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5718               && rel[1].r_offset == rel->r_offset + 8)
5719             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5720           else
5721             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5722           goto dotlstoc;
5723
5724         case R_PPC64_DTPREL64:
5725           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5726           if (rel != relocs
5727               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5728               && rel[-1].r_offset == rel->r_offset - 8)
5729             /* This is the second reloc of a dtpmod, dtprel pair.
5730                Don't mark with TLS_DTPREL.  */
5731             goto dodyn;
5732
5733         dotlstoc:
5734           sec->has_tls_reloc = 1;
5735           if (h != NULL)
5736             {
5737               struct ppc_link_hash_entry *eh;
5738               eh = (struct ppc_link_hash_entry *) h;
5739               eh->tls_mask |= tls_type;
5740             }
5741           else
5742             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5743                                         rel->r_addend, tls_type))
5744               return FALSE;
5745
5746           ppc64_sec = ppc64_elf_section_data (sec);
5747           if (ppc64_sec->sec_type != sec_toc)
5748             {
5749               bfd_size_type amt;
5750
5751               /* One extra to simplify get_tls_mask.  */
5752               amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5753               ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5754               if (ppc64_sec->u.toc.symndx == NULL)
5755                 return FALSE;
5756               amt = sec->size * sizeof (bfd_vma) / 8;
5757               ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5758               if (ppc64_sec->u.toc.add == NULL)
5759                 return FALSE;
5760               BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5761               ppc64_sec->sec_type = sec_toc;
5762             }
5763           BFD_ASSERT (rel->r_offset % 8 == 0);
5764           ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5765           ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5766
5767           /* Mark the second slot of a GD or LD entry.
5768              -1 to indicate GD and -2 to indicate LD.  */
5769           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5770             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5771           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5772             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5773           goto dodyn;
5774
5775         case R_PPC64_TPREL16:
5776         case R_PPC64_TPREL16_LO:
5777         case R_PPC64_TPREL16_HI:
5778         case R_PPC64_TPREL16_HA:
5779         case R_PPC64_TPREL16_DS:
5780         case R_PPC64_TPREL16_LO_DS:
5781         case R_PPC64_TPREL16_HIGH:
5782         case R_PPC64_TPREL16_HIGHA:
5783         case R_PPC64_TPREL16_HIGHER:
5784         case R_PPC64_TPREL16_HIGHERA:
5785         case R_PPC64_TPREL16_HIGHEST:
5786         case R_PPC64_TPREL16_HIGHESTA:
5787           if (bfd_link_pic (info))
5788             {
5789               info->flags |= DF_STATIC_TLS;
5790               goto dodyn;
5791             }
5792           break;
5793
5794         case R_PPC64_ADDR64:
5795           if (opd_sym_map != NULL
5796               && rel + 1 < rel_end
5797               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5798             {
5799               if (h != NULL)
5800                 {
5801                   if (h->root.root.string[0] == '.'
5802                       && h->root.root.string[1] != 0
5803                       && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
5804                     ;
5805                   else
5806                     ((struct ppc_link_hash_entry *) h)->is_func = 1;
5807                 }
5808               else
5809                 {
5810                   asection *s;
5811                   Elf_Internal_Sym *isym;
5812
5813                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5814                                                 abfd, r_symndx);
5815                   if (isym == NULL)
5816                     return FALSE;
5817
5818                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5819                   if (s != NULL && s != sec)
5820                     opd_sym_map[OPD_NDX (rel->r_offset)] = s;
5821                 }
5822             }
5823           /* Fall through.  */
5824
5825         case R_PPC64_ADDR16:
5826         case R_PPC64_ADDR16_DS:
5827         case R_PPC64_ADDR16_HA:
5828         case R_PPC64_ADDR16_HI:
5829         case R_PPC64_ADDR16_HIGH:
5830         case R_PPC64_ADDR16_HIGHA:
5831         case R_PPC64_ADDR16_HIGHER:
5832         case R_PPC64_ADDR16_HIGHERA:
5833         case R_PPC64_ADDR16_HIGHEST:
5834         case R_PPC64_ADDR16_HIGHESTA:
5835         case R_PPC64_ADDR16_LO:
5836         case R_PPC64_ADDR16_LO_DS:
5837           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1
5838               && rel->r_addend == 0)
5839             {
5840               /* We may need a .plt entry if this reloc refers to a
5841                  function in a shared lib.  */
5842               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5843                 return FALSE;
5844               h->pointer_equality_needed = 1;
5845             }
5846           /* Fall through.  */
5847
5848         case R_PPC64_REL30:
5849         case R_PPC64_REL32:
5850         case R_PPC64_REL64:
5851         case R_PPC64_ADDR32:
5852         case R_PPC64_UADDR16:
5853         case R_PPC64_UADDR32:
5854         case R_PPC64_UADDR64:
5855         case R_PPC64_TOC:
5856           if (h != NULL && !bfd_link_pic (info))
5857             /* We may need a copy reloc.  */
5858             h->non_got_ref = 1;
5859
5860           /* Don't propagate .opd relocs.  */
5861           if (NO_OPD_RELOCS && opd_sym_map != NULL)
5862             break;
5863
5864           /* If we are creating a shared library, and this is a reloc
5865              against a global symbol, or a non PC relative reloc
5866              against a local symbol, then we need to copy the reloc
5867              into the shared library.  However, if we are linking with
5868              -Bsymbolic, we do not need to copy a reloc against a
5869              global symbol which is defined in an object we are
5870              including in the link (i.e., DEF_REGULAR is set).  At
5871              this point we have not seen all the input files, so it is
5872              possible that DEF_REGULAR is not set now but will be set
5873              later (it is never cleared).  In case of a weak definition,
5874              DEF_REGULAR may be cleared later by a strong definition in
5875              a shared library.  We account for that possibility below by
5876              storing information in the dyn_relocs field of the hash
5877              table entry.  A similar situation occurs when creating
5878              shared libraries and symbol visibility changes render the
5879              symbol local.
5880
5881              If on the other hand, we are creating an executable, we
5882              may need to keep relocations for symbols satisfied by a
5883              dynamic library if we manage to avoid copy relocs for the
5884              symbol.  */
5885         dodyn:
5886           if ((bfd_link_pic (info)
5887                && (must_be_dyn_reloc (info, r_type)
5888                    || (h != NULL
5889                        && (!SYMBOLIC_BIND (info, h)
5890                            || h->root.type == bfd_link_hash_defweak
5891                            || !h->def_regular))))
5892               || (ELIMINATE_COPY_RELOCS
5893                   && !bfd_link_pic (info)
5894                   && h != NULL
5895                   && (h->root.type == bfd_link_hash_defweak
5896                       || !h->def_regular))
5897               || (!bfd_link_pic (info)
5898                   && ifunc != NULL))
5899             {
5900               /* We must copy these reloc types into the output file.
5901                  Create a reloc section in dynobj and make room for
5902                  this reloc.  */
5903               if (sreloc == NULL)
5904                 {
5905                   sreloc = _bfd_elf_make_dynamic_reloc_section
5906                     (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5907
5908                   if (sreloc == NULL)
5909                     return FALSE;
5910                 }
5911
5912               /* If this is a global symbol, we count the number of
5913                  relocations we need for this symbol.  */
5914               if (h != NULL)
5915                 {
5916                   struct elf_dyn_relocs *p;
5917                   struct elf_dyn_relocs **head;
5918
5919                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5920                   p = *head;
5921                   if (p == NULL || p->sec != sec)
5922                     {
5923                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5924                       if (p == NULL)
5925                         return FALSE;
5926                       p->next = *head;
5927                       *head = p;
5928                       p->sec = sec;
5929                       p->count = 0;
5930                       p->pc_count = 0;
5931                     }
5932                   p->count += 1;
5933                   if (!must_be_dyn_reloc (info, r_type))
5934                     p->pc_count += 1;
5935                 }
5936               else
5937                 {
5938                   /* Track dynamic relocs needed for local syms too.
5939                      We really need local syms available to do this
5940                      easily.  Oh well.  */
5941                   struct ppc_dyn_relocs *p;
5942                   struct ppc_dyn_relocs **head;
5943                   bfd_boolean is_ifunc;
5944                   asection *s;
5945                   void *vpp;
5946                   Elf_Internal_Sym *isym;
5947
5948                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5949                                                 abfd, r_symndx);
5950                   if (isym == NULL)
5951                     return FALSE;
5952
5953                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5954                   if (s == NULL)
5955                     s = sec;
5956
5957                   vpp = &elf_section_data (s)->local_dynrel;
5958                   head = (struct ppc_dyn_relocs **) vpp;
5959                   is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5960                   p = *head;
5961                   if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5962                     p = p->next;
5963                   if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5964                     {
5965                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5966                       if (p == NULL)
5967                         return FALSE;
5968                       p->next = *head;
5969                       *head = p;
5970                       p->sec = sec;
5971                       p->ifunc = is_ifunc;
5972                       p->count = 0;
5973                     }
5974                   p->count += 1;
5975                 }
5976             }
5977           break;
5978
5979         default:
5980           break;
5981         }
5982     }
5983
5984   return TRUE;
5985 }
5986
5987 /* Merge backend specific data from an object file to the output
5988    object file when linking.  */
5989
5990 static bfd_boolean
5991 ppc64_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
5992 {
5993   unsigned long iflags, oflags;
5994
5995   if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
5996     return TRUE;
5997
5998   if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
5999     return TRUE;
6000
6001   if (!_bfd_generic_verify_endian_match (ibfd, obfd))
6002     return FALSE;
6003
6004   iflags = elf_elfheader (ibfd)->e_flags;
6005   oflags = elf_elfheader (obfd)->e_flags;
6006
6007   if (iflags & ~EF_PPC64_ABI)
6008     {
6009       (*_bfd_error_handler)
6010         (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
6011       bfd_set_error (bfd_error_bad_value);
6012       return FALSE;
6013     }
6014   else if (iflags != oflags && iflags != 0)
6015     {
6016       (*_bfd_error_handler)
6017         (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
6018          ibfd, iflags, oflags);
6019       bfd_set_error (bfd_error_bad_value);
6020       return FALSE;
6021     }
6022
6023   /* Merge Tag_compatibility attributes and any common GNU ones.  */
6024   _bfd_elf_merge_object_attributes (ibfd, obfd);
6025
6026   return TRUE;
6027 }
6028
6029 static bfd_boolean
6030 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
6031 {
6032   /* Print normal ELF private data.  */
6033   _bfd_elf_print_private_bfd_data (abfd, ptr);
6034
6035   if (elf_elfheader (abfd)->e_flags != 0)
6036     {
6037       FILE *file = ptr;
6038
6039       /* xgettext:c-format */
6040       fprintf (file, _("private flags = 0x%lx:"),
6041                elf_elfheader (abfd)->e_flags);
6042
6043       if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
6044         fprintf (file, _(" [abiv%ld]"),
6045                  elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
6046       fputc ('\n', file);
6047     }
6048
6049   return TRUE;
6050 }
6051
6052 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
6053    of the code entry point, and its section, which must be in the same
6054    object as OPD_SEC.  Returns (bfd_vma) -1 on error.  */
6055
6056 static bfd_vma
6057 opd_entry_value (asection *opd_sec,
6058                  bfd_vma offset,
6059                  asection **code_sec,
6060                  bfd_vma *code_off,
6061                  bfd_boolean in_code_sec)
6062 {
6063   bfd *opd_bfd = opd_sec->owner;
6064   Elf_Internal_Rela *relocs;
6065   Elf_Internal_Rela *lo, *hi, *look;
6066   bfd_vma val;
6067
6068   /* No relocs implies we are linking a --just-symbols object, or looking
6069      at a final linked executable with addr2line or somesuch.  */
6070   if (opd_sec->reloc_count == 0)
6071     {
6072       bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
6073
6074       if (contents == NULL)
6075         {
6076           if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
6077             return (bfd_vma) -1;
6078           ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
6079         }
6080
6081       /* PR 17512: file: 64b9dfbb.  */
6082       if (offset + 7 >= opd_sec->size || offset + 7 < offset)
6083         return (bfd_vma) -1;
6084
6085       val = bfd_get_64 (opd_bfd, contents + offset);
6086       if (code_sec != NULL)
6087         {
6088           asection *sec, *likely = NULL;
6089
6090           if (in_code_sec)
6091             {
6092               sec = *code_sec;
6093               if (sec->vma <= val
6094                   && val < sec->vma + sec->size)
6095                 likely = sec;
6096               else
6097                 val = -1;
6098             }
6099           else
6100             for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
6101               if (sec->vma <= val
6102                   && (sec->flags & SEC_LOAD) != 0
6103                   && (sec->flags & SEC_ALLOC) != 0)
6104                 likely = sec;
6105           if (likely != NULL)
6106             {
6107               *code_sec = likely;
6108               if (code_off != NULL)
6109                 *code_off = val - likely->vma;
6110             }
6111         }
6112       return val;
6113     }
6114
6115   BFD_ASSERT (is_ppc64_elf (opd_bfd));
6116
6117   relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
6118   if (relocs == NULL)
6119     relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
6120   /* PR 17512: file: df8e1fd6.  */
6121   if (relocs == NULL)
6122     return (bfd_vma) -1;
6123
6124   /* Go find the opd reloc at the sym address.  */
6125   lo = relocs;
6126   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
6127   val = (bfd_vma) -1;
6128   while (lo < hi)
6129     {
6130       look = lo + (hi - lo) / 2;
6131       if (look->r_offset < offset)
6132         lo = look + 1;
6133       else if (look->r_offset > offset)
6134         hi = look;
6135       else
6136         {
6137           Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
6138
6139           if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
6140               && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
6141             {
6142               unsigned long symndx = ELF64_R_SYM (look->r_info);
6143               asection *sec = NULL;
6144
6145               if (symndx >= symtab_hdr->sh_info
6146                   && elf_sym_hashes (opd_bfd) != NULL)
6147                 {
6148                   struct elf_link_hash_entry **sym_hashes;
6149                   struct elf_link_hash_entry *rh;
6150
6151                   sym_hashes = elf_sym_hashes (opd_bfd);
6152                   rh = sym_hashes[symndx - symtab_hdr->sh_info];
6153                   if (rh != NULL)
6154                     {
6155                       rh = elf_follow_link (rh);
6156                       if (rh->root.type != bfd_link_hash_defined
6157                           && rh->root.type != bfd_link_hash_defweak)
6158                         break;
6159                       if (rh->root.u.def.section->owner == opd_bfd)
6160                         {
6161                           val = rh->root.u.def.value;
6162                           sec = rh->root.u.def.section;
6163                         }
6164                     }
6165                 }
6166
6167               if (sec == NULL)
6168                 {
6169                   Elf_Internal_Sym *sym;
6170
6171                   if (symndx < symtab_hdr->sh_info)
6172                     {
6173                       sym = (Elf_Internal_Sym *) symtab_hdr->contents;
6174                       if (sym == NULL)
6175                         {
6176                           size_t symcnt = symtab_hdr->sh_info;
6177                           sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6178                                                       symcnt, 0,
6179                                                       NULL, NULL, NULL);
6180                           if (sym == NULL)
6181                             break;
6182                           symtab_hdr->contents = (bfd_byte *) sym;
6183                         }
6184                       sym += symndx;
6185                     }
6186                   else
6187                     {
6188                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6189                                                   1, symndx,
6190                                                   NULL, NULL, NULL);
6191                       if (sym == NULL)
6192                         break;
6193                     }
6194                   sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6195                   if (sec == NULL)
6196                     break;
6197                   BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
6198                   val = sym->st_value;
6199                 }
6200
6201               val += look->r_addend;
6202               if (code_off != NULL)
6203                 *code_off = val;
6204               if (code_sec != NULL)
6205                 {
6206                   if (in_code_sec && *code_sec != sec)
6207                     return -1;
6208                   else
6209                     *code_sec = sec;
6210                 }
6211               if (sec->output_section != NULL)
6212                 val += sec->output_section->vma + sec->output_offset;
6213             }
6214           break;
6215         }
6216     }
6217
6218   return val;
6219 }
6220
6221 /* If the ELF symbol SYM might be a function in SEC, return the
6222    function size and set *CODE_OFF to the function's entry point,
6223    otherwise return zero.  */
6224
6225 static bfd_size_type
6226 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6227                               bfd_vma *code_off)
6228 {
6229   bfd_size_type size;
6230
6231   if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6232                      | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6233     return 0;
6234
6235   size = 0;
6236   if (!(sym->flags & BSF_SYNTHETIC))
6237     size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6238
6239   if (strcmp (sym->section->name, ".opd") == 0)
6240     {
6241       struct _opd_sec_data *opd = get_opd_info (sym->section);
6242       bfd_vma symval = sym->value;
6243
6244       if (opd != NULL
6245           && opd->adjust != NULL
6246           && elf_section_data (sym->section)->relocs != NULL)
6247         {
6248           /* opd_entry_value will use cached relocs that have been
6249              adjusted, but with raw symbols.  That means both local
6250              and global symbols need adjusting.  */
6251           long adjust = opd->adjust[OPD_NDX (symval)];
6252           if (adjust == -1)
6253             return 0;
6254           symval += adjust;
6255         }
6256
6257       if (opd_entry_value (sym->section, symval,
6258                            &sec, code_off, TRUE) == (bfd_vma) -1)
6259         return 0;
6260       /* An old ABI binary with dot-syms has a size of 24 on the .opd
6261          symbol.  This size has nothing to do with the code size of the
6262          function, which is what we're supposed to return, but the
6263          code size isn't available without looking up the dot-sym.
6264          However, doing that would be a waste of time particularly
6265          since elf_find_function will look at the dot-sym anyway.
6266          Now, elf_find_function will keep the largest size of any
6267          function sym found at the code address of interest, so return
6268          1 here to avoid it incorrectly caching a larger function size
6269          for a small function.  This does mean we return the wrong
6270          size for a new-ABI function of size 24, but all that does is
6271          disable caching for such functions.  */
6272       if (size == 24)
6273         size = 1;
6274     }
6275   else
6276     {
6277       if (sym->section != sec)
6278         return 0;
6279       *code_off = sym->value;
6280     }
6281   if (size == 0)
6282     size = 1;
6283   return size;
6284 }
6285
6286 /* Return true if symbol is defined in a regular object file.  */
6287
6288 static bfd_boolean
6289 is_static_defined (struct elf_link_hash_entry *h)
6290 {
6291   return ((h->root.type == bfd_link_hash_defined
6292            || h->root.type == bfd_link_hash_defweak)
6293           && h->root.u.def.section != NULL
6294           && h->root.u.def.section->output_section != NULL);
6295 }
6296
6297 /* If FDH is a function descriptor symbol, return the associated code
6298    entry symbol if it is defined.  Return NULL otherwise.  */
6299
6300 static struct ppc_link_hash_entry *
6301 defined_code_entry (struct ppc_link_hash_entry *fdh)
6302 {
6303   if (fdh->is_func_descriptor)
6304     {
6305       struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6306       if (fh->elf.root.type == bfd_link_hash_defined
6307           || fh->elf.root.type == bfd_link_hash_defweak)
6308         return fh;
6309     }
6310   return NULL;
6311 }
6312
6313 /* If FH is a function code entry symbol, return the associated
6314    function descriptor symbol if it is defined.  Return NULL otherwise.  */
6315
6316 static struct ppc_link_hash_entry *
6317 defined_func_desc (struct ppc_link_hash_entry *fh)
6318 {
6319   if (fh->oh != NULL
6320       && fh->oh->is_func_descriptor)
6321     {
6322       struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6323       if (fdh->elf.root.type == bfd_link_hash_defined
6324           || fdh->elf.root.type == bfd_link_hash_defweak)
6325         return fdh;
6326     }
6327   return NULL;
6328 }
6329
6330 /* Mark all our entry sym sections, both opd and code section.  */
6331
6332 static void
6333 ppc64_elf_gc_keep (struct bfd_link_info *info)
6334 {
6335   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6336   struct bfd_sym_chain *sym;
6337
6338   if (htab == NULL)
6339     return;
6340
6341   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6342     {
6343       struct ppc_link_hash_entry *eh, *fh;
6344       asection *sec;
6345
6346       eh = (struct ppc_link_hash_entry *)
6347         elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6348       if (eh == NULL)
6349         continue;
6350       if (eh->elf.root.type != bfd_link_hash_defined
6351           && eh->elf.root.type != bfd_link_hash_defweak)
6352         continue;
6353
6354       fh = defined_code_entry (eh);
6355       if (fh != NULL)
6356         {
6357           sec = fh->elf.root.u.def.section;
6358           sec->flags |= SEC_KEEP;
6359         }
6360       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6361                && opd_entry_value (eh->elf.root.u.def.section,
6362                                    eh->elf.root.u.def.value,
6363                                    &sec, NULL, FALSE) != (bfd_vma) -1)
6364         sec->flags |= SEC_KEEP;
6365
6366       sec = eh->elf.root.u.def.section;
6367       sec->flags |= SEC_KEEP;
6368     }
6369 }
6370
6371 /* Mark sections containing dynamically referenced symbols.  When
6372    building shared libraries, we must assume that any visible symbol is
6373    referenced.  */
6374
6375 static bfd_boolean
6376 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6377 {
6378   struct bfd_link_info *info = (struct bfd_link_info *) inf;
6379   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6380   struct ppc_link_hash_entry *fdh;
6381   struct bfd_elf_dynamic_list *d = info->dynamic_list;
6382
6383   /* Dynamic linking info is on the func descriptor sym.  */
6384   fdh = defined_func_desc (eh);
6385   if (fdh != NULL)
6386     eh = fdh;
6387
6388   if ((eh->elf.root.type == bfd_link_hash_defined
6389        || eh->elf.root.type == bfd_link_hash_defweak)
6390       && (eh->elf.ref_dynamic
6391           || ((eh->elf.def_regular || ELF_COMMON_DEF_P (&eh->elf))
6392               && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6393               && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6394               && (!bfd_link_executable (info)
6395                   || info->export_dynamic
6396                   || (eh->elf.dynamic
6397                       && d != NULL
6398                       && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
6399               && (strchr (eh->elf.root.root.string, ELF_VER_CHR) != NULL
6400                   || !bfd_hide_sym_by_version (info->version_info,
6401                                                eh->elf.root.root.string)))))
6402     {
6403       asection *code_sec;
6404       struct ppc_link_hash_entry *fh;
6405
6406       eh->elf.root.u.def.section->flags |= SEC_KEEP;
6407
6408       /* Function descriptor syms cause the associated
6409          function code sym section to be marked.  */
6410       fh = defined_code_entry (eh);
6411       if (fh != NULL)
6412         {
6413           code_sec = fh->elf.root.u.def.section;
6414           code_sec->flags |= SEC_KEEP;
6415         }
6416       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6417                && opd_entry_value (eh->elf.root.u.def.section,
6418                                    eh->elf.root.u.def.value,
6419                                    &code_sec, NULL, FALSE) != (bfd_vma) -1)
6420         code_sec->flags |= SEC_KEEP;
6421     }
6422
6423   return TRUE;
6424 }
6425
6426 /* Return the section that should be marked against GC for a given
6427    relocation.  */
6428
6429 static asection *
6430 ppc64_elf_gc_mark_hook (asection *sec,
6431                         struct bfd_link_info *info,
6432                         Elf_Internal_Rela *rel,
6433                         struct elf_link_hash_entry *h,
6434                         Elf_Internal_Sym *sym)
6435 {
6436   asection *rsec;
6437
6438   /* Syms return NULL if we're marking .opd, so we avoid marking all
6439      function sections, as all functions are referenced in .opd.  */
6440   rsec = NULL;
6441   if (get_opd_info (sec) != NULL)
6442     return rsec;
6443
6444   if (h != NULL)
6445     {
6446       enum elf_ppc64_reloc_type r_type;
6447       struct ppc_link_hash_entry *eh, *fh, *fdh;
6448
6449       r_type = ELF64_R_TYPE (rel->r_info);
6450       switch (r_type)
6451         {
6452         case R_PPC64_GNU_VTINHERIT:
6453         case R_PPC64_GNU_VTENTRY:
6454           break;
6455
6456         default:
6457           switch (h->root.type)
6458             {
6459             case bfd_link_hash_defined:
6460             case bfd_link_hash_defweak:
6461               eh = (struct ppc_link_hash_entry *) h;
6462               fdh = defined_func_desc (eh);
6463               if (fdh != NULL)
6464                 eh = fdh;
6465
6466               /* Function descriptor syms cause the associated
6467                  function code sym section to be marked.  */
6468               fh = defined_code_entry (eh);
6469               if (fh != NULL)
6470                 {
6471                   /* They also mark their opd section.  */
6472                   eh->elf.root.u.def.section->gc_mark = 1;
6473
6474                   rsec = fh->elf.root.u.def.section;
6475                 }
6476               else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6477                        && opd_entry_value (eh->elf.root.u.def.section,
6478                                            eh->elf.root.u.def.value,
6479                                            &rsec, NULL, FALSE) != (bfd_vma) -1)
6480                 eh->elf.root.u.def.section->gc_mark = 1;
6481               else
6482                 rsec = h->root.u.def.section;
6483               break;
6484
6485             case bfd_link_hash_common:
6486               rsec = h->root.u.c.p->section;
6487               break;
6488
6489             default:
6490               return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6491             }
6492         }
6493     }
6494   else
6495     {
6496       struct _opd_sec_data *opd;
6497
6498       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6499       opd = get_opd_info (rsec);
6500       if (opd != NULL && opd->func_sec != NULL)
6501         {
6502           rsec->gc_mark = 1;
6503
6504           rsec = opd->func_sec[OPD_NDX (sym->st_value + rel->r_addend)];
6505         }
6506     }
6507
6508   return rsec;
6509 }
6510
6511 /* Update the .got, .plt. and dynamic reloc reference counts for the
6512    section being removed.  */
6513
6514 static bfd_boolean
6515 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
6516                          asection *sec, const Elf_Internal_Rela *relocs)
6517 {
6518   struct ppc_link_hash_table *htab;
6519   Elf_Internal_Shdr *symtab_hdr;
6520   struct elf_link_hash_entry **sym_hashes;
6521   struct got_entry **local_got_ents;
6522   const Elf_Internal_Rela *rel, *relend;
6523
6524   if (bfd_link_relocatable (info))
6525     return TRUE;
6526
6527   if ((sec->flags & SEC_ALLOC) == 0)
6528     return TRUE;
6529
6530   elf_section_data (sec)->local_dynrel = NULL;
6531
6532   htab = ppc_hash_table (info);
6533   if (htab == NULL)
6534     return FALSE;
6535
6536   symtab_hdr = &elf_symtab_hdr (abfd);
6537   sym_hashes = elf_sym_hashes (abfd);
6538   local_got_ents = elf_local_got_ents (abfd);
6539
6540   relend = relocs + sec->reloc_count;
6541   for (rel = relocs; rel < relend; rel++)
6542     {
6543       unsigned long r_symndx;
6544       enum elf_ppc64_reloc_type r_type;
6545       struct elf_link_hash_entry *h = NULL;
6546       struct plt_entry **plt_list;
6547       unsigned char tls_type = 0;
6548
6549       r_symndx = ELF64_R_SYM (rel->r_info);
6550       r_type = ELF64_R_TYPE (rel->r_info);
6551       if (r_symndx >= symtab_hdr->sh_info)
6552         {
6553           struct ppc_link_hash_entry *eh;
6554           struct elf_dyn_relocs **pp;
6555           struct elf_dyn_relocs *p;
6556
6557           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6558           h = elf_follow_link (h);
6559           eh = (struct ppc_link_hash_entry *) h;
6560
6561           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6562             if (p->sec == sec)
6563               {
6564                 /* Everything must go for SEC.  */
6565                 *pp = p->next;
6566                 break;
6567               }
6568         }
6569
6570       switch (r_type)
6571         {
6572         case R_PPC64_GOT_TLSLD16:
6573         case R_PPC64_GOT_TLSLD16_LO:
6574         case R_PPC64_GOT_TLSLD16_HI:
6575         case R_PPC64_GOT_TLSLD16_HA:
6576           tls_type = TLS_TLS | TLS_LD;
6577           goto dogot;
6578
6579         case R_PPC64_GOT_TLSGD16:
6580         case R_PPC64_GOT_TLSGD16_LO:
6581         case R_PPC64_GOT_TLSGD16_HI:
6582         case R_PPC64_GOT_TLSGD16_HA:
6583           tls_type = TLS_TLS | TLS_GD;
6584           goto dogot;
6585
6586         case R_PPC64_GOT_TPREL16_DS:
6587         case R_PPC64_GOT_TPREL16_LO_DS:
6588         case R_PPC64_GOT_TPREL16_HI:
6589         case R_PPC64_GOT_TPREL16_HA:
6590           tls_type = TLS_TLS | TLS_TPREL;
6591           goto dogot;
6592
6593         case R_PPC64_GOT_DTPREL16_DS:
6594         case R_PPC64_GOT_DTPREL16_LO_DS:
6595         case R_PPC64_GOT_DTPREL16_HI:
6596         case R_PPC64_GOT_DTPREL16_HA:
6597           tls_type = TLS_TLS | TLS_DTPREL;
6598           goto dogot;
6599
6600         case R_PPC64_GOT16:
6601         case R_PPC64_GOT16_DS:
6602         case R_PPC64_GOT16_HA:
6603         case R_PPC64_GOT16_HI:
6604         case R_PPC64_GOT16_LO:
6605         case R_PPC64_GOT16_LO_DS:
6606         dogot:
6607           {
6608             struct got_entry *ent;
6609
6610             if (h != NULL)
6611               ent = h->got.glist;
6612             else
6613               ent = local_got_ents[r_symndx];
6614
6615             for (; ent != NULL; ent = ent->next)
6616               if (ent->addend == rel->r_addend
6617                   && ent->owner == abfd
6618                   && ent->tls_type == tls_type)
6619                 break;
6620             if (ent == NULL)
6621               abort ();
6622             if (ent->got.refcount > 0)
6623               ent->got.refcount -= 1;
6624           }
6625           break;
6626
6627         case R_PPC64_PLT16_HA:
6628         case R_PPC64_PLT16_HI:
6629         case R_PPC64_PLT16_LO:
6630         case R_PPC64_PLT32:
6631         case R_PPC64_PLT64:
6632         case R_PPC64_REL14:
6633         case R_PPC64_REL14_BRNTAKEN:
6634         case R_PPC64_REL14_BRTAKEN:
6635         case R_PPC64_REL24:
6636           plt_list = NULL;
6637           if (h != NULL)
6638             plt_list = &h->plt.plist;
6639           else if (local_got_ents != NULL)
6640             {
6641               struct plt_entry **local_plt = (struct plt_entry **)
6642                 (local_got_ents + symtab_hdr->sh_info);
6643               unsigned char *local_got_tls_masks = (unsigned char *)
6644                 (local_plt + symtab_hdr->sh_info);
6645               if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6646                 plt_list = local_plt + r_symndx;
6647             }
6648           if (plt_list)
6649             {
6650               struct plt_entry *ent;
6651
6652               for (ent = *plt_list; ent != NULL; ent = ent->next)
6653                 if (ent->addend == rel->r_addend)
6654                   break;
6655               if (ent != NULL && ent->plt.refcount > 0)
6656                 ent->plt.refcount -= 1;
6657             }
6658           break;
6659
6660         default:
6661           break;
6662         }
6663     }
6664   return TRUE;
6665 }
6666
6667 /* The maximum size of .sfpr.  */
6668 #define SFPR_MAX (218*4)
6669
6670 struct sfpr_def_parms
6671 {
6672   const char name[12];
6673   unsigned char lo, hi;
6674   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6675   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6676 };
6677
6678 /* Auto-generate _save*, _rest* functions in .sfpr.
6679    If STUB_SEC is non-null, define alias symbols in STUB_SEC
6680    instead.  */
6681
6682 static bfd_boolean
6683 sfpr_define (struct bfd_link_info *info,
6684              const struct sfpr_def_parms *parm,
6685              asection *stub_sec)
6686 {
6687   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6688   unsigned int i;
6689   size_t len = strlen (parm->name);
6690   bfd_boolean writing = FALSE;
6691   char sym[16];
6692
6693   if (htab == NULL)
6694     return FALSE;
6695
6696   memcpy (sym, parm->name, len);
6697   sym[len + 2] = 0;
6698
6699   for (i = parm->lo; i <= parm->hi; i++)
6700     {
6701       struct ppc_link_hash_entry *h;
6702
6703       sym[len + 0] = i / 10 + '0';
6704       sym[len + 1] = i % 10 + '0';
6705       h = (struct ppc_link_hash_entry *)
6706         elf_link_hash_lookup (&htab->elf, sym, writing, TRUE, TRUE);
6707       if (stub_sec != NULL)
6708         {
6709           if (h != NULL
6710               && h->elf.root.type == bfd_link_hash_defined
6711               && h->elf.root.u.def.section == htab->sfpr)
6712             {
6713               struct elf_link_hash_entry *s;
6714               char buf[32];
6715               sprintf (buf, "%08x.%s", stub_sec->id & 0xffffffff, sym);
6716               s = elf_link_hash_lookup (&htab->elf, buf, TRUE, TRUE, FALSE);
6717               if (s == NULL)
6718                 return FALSE;
6719               if (s->root.type == bfd_link_hash_new
6720                   || (s->root.type = bfd_link_hash_defined
6721                       && s->root.u.def.section == stub_sec))
6722                 {
6723                   s->root.type = bfd_link_hash_defined;
6724                   s->root.u.def.section = stub_sec;
6725                   s->root.u.def.value = (stub_sec->size
6726                                          + h->elf.root.u.def.value);
6727                   s->ref_regular = 1;
6728                   s->def_regular = 1;
6729                   s->ref_regular_nonweak = 1;
6730                   s->forced_local = 1;
6731                   s->non_elf = 0;
6732                   s->root.linker_def = 1;
6733                 }
6734             }
6735           continue;
6736         }
6737       if (h != NULL)
6738         {
6739           h->save_res = 1;
6740           if (!h->elf.def_regular)
6741             {
6742               h->elf.root.type = bfd_link_hash_defined;
6743               h->elf.root.u.def.section = htab->sfpr;
6744               h->elf.root.u.def.value = htab->sfpr->size;
6745               h->elf.type = STT_FUNC;
6746               h->elf.def_regular = 1;
6747               h->elf.non_elf = 0;
6748               _bfd_elf_link_hash_hide_symbol (info, &h->elf, TRUE);
6749               writing = TRUE;
6750               if (htab->sfpr->contents == NULL)
6751                 {
6752                   htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6753                   if (htab->sfpr->contents == NULL)
6754                     return FALSE;
6755                 }
6756             }
6757         }
6758       if (writing)
6759         {
6760           bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6761           if (i != parm->hi)
6762             p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6763           else
6764             p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6765           htab->sfpr->size = p - htab->sfpr->contents;
6766         }
6767     }
6768
6769   return TRUE;
6770 }
6771
6772 static bfd_byte *
6773 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6774 {
6775   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6776   return p + 4;
6777 }
6778
6779 static bfd_byte *
6780 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6781 {
6782   p = savegpr0 (abfd, p, r);
6783   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6784   p = p + 4;
6785   bfd_put_32 (abfd, BLR, p);
6786   return p + 4;
6787 }
6788
6789 static bfd_byte *
6790 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6791 {
6792   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6793   return p + 4;
6794 }
6795
6796 static bfd_byte *
6797 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6798 {
6799   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6800   p = p + 4;
6801   p = restgpr0 (abfd, p, r);
6802   bfd_put_32 (abfd, MTLR_R0, p);
6803   p = p + 4;
6804   if (r == 29)
6805     {
6806       p = restgpr0 (abfd, p, 30);
6807       p = restgpr0 (abfd, p, 31);
6808     }
6809   bfd_put_32 (abfd, BLR, p);
6810   return p + 4;
6811 }
6812
6813 static bfd_byte *
6814 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6815 {
6816   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6817   return p + 4;
6818 }
6819
6820 static bfd_byte *
6821 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6822 {
6823   p = savegpr1 (abfd, p, r);
6824   bfd_put_32 (abfd, BLR, p);
6825   return p + 4;
6826 }
6827
6828 static bfd_byte *
6829 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6830 {
6831   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6832   return p + 4;
6833 }
6834
6835 static bfd_byte *
6836 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6837 {
6838   p = restgpr1 (abfd, p, r);
6839   bfd_put_32 (abfd, BLR, p);
6840   return p + 4;
6841 }
6842
6843 static bfd_byte *
6844 savefpr (bfd *abfd, bfd_byte *p, int r)
6845 {
6846   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6847   return p + 4;
6848 }
6849
6850 static bfd_byte *
6851 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6852 {
6853   p = savefpr (abfd, p, r);
6854   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6855   p = p + 4;
6856   bfd_put_32 (abfd, BLR, p);
6857   return p + 4;
6858 }
6859
6860 static bfd_byte *
6861 restfpr (bfd *abfd, bfd_byte *p, int r)
6862 {
6863   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6864   return p + 4;
6865 }
6866
6867 static bfd_byte *
6868 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6869 {
6870   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6871   p = p + 4;
6872   p = restfpr (abfd, p, r);
6873   bfd_put_32 (abfd, MTLR_R0, p);
6874   p = p + 4;
6875   if (r == 29)
6876     {
6877       p = restfpr (abfd, p, 30);
6878       p = restfpr (abfd, p, 31);
6879     }
6880   bfd_put_32 (abfd, BLR, p);
6881   return p + 4;
6882 }
6883
6884 static bfd_byte *
6885 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6886 {
6887   p = savefpr (abfd, p, r);
6888   bfd_put_32 (abfd, BLR, p);
6889   return p + 4;
6890 }
6891
6892 static bfd_byte *
6893 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6894 {
6895   p = restfpr (abfd, p, r);
6896   bfd_put_32 (abfd, BLR, p);
6897   return p + 4;
6898 }
6899
6900 static bfd_byte *
6901 savevr (bfd *abfd, bfd_byte *p, int r)
6902 {
6903   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6904   p = p + 4;
6905   bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6906   return p + 4;
6907 }
6908
6909 static bfd_byte *
6910 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6911 {
6912   p = savevr (abfd, p, r);
6913   bfd_put_32 (abfd, BLR, p);
6914   return p + 4;
6915 }
6916
6917 static bfd_byte *
6918 restvr (bfd *abfd, bfd_byte *p, int r)
6919 {
6920   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6921   p = p + 4;
6922   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6923   return p + 4;
6924 }
6925
6926 static bfd_byte *
6927 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6928 {
6929   p = restvr (abfd, p, r);
6930   bfd_put_32 (abfd, BLR, p);
6931   return p + 4;
6932 }
6933
6934 /* Called via elf_link_hash_traverse to transfer dynamic linking
6935    information on function code symbol entries to their corresponding
6936    function descriptor symbol entries.  */
6937
6938 static bfd_boolean
6939 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6940 {
6941   struct bfd_link_info *info;
6942   struct ppc_link_hash_table *htab;
6943   struct plt_entry *ent;
6944   struct ppc_link_hash_entry *fh;
6945   struct ppc_link_hash_entry *fdh;
6946   bfd_boolean force_local;
6947
6948   fh = (struct ppc_link_hash_entry *) h;
6949   if (fh->elf.root.type == bfd_link_hash_indirect)
6950     return TRUE;
6951
6952   info = inf;
6953   htab = ppc_hash_table (info);
6954   if (htab == NULL)
6955     return FALSE;
6956
6957   /* Resolve undefined references to dot-symbols as the value
6958      in the function descriptor, if we have one in a regular object.
6959      This is to satisfy cases like ".quad .foo".  Calls to functions
6960      in dynamic objects are handled elsewhere.  */
6961   if (fh->elf.root.type == bfd_link_hash_undefweak
6962       && fh->was_undefined
6963       && (fdh = defined_func_desc (fh)) != NULL
6964       && get_opd_info (fdh->elf.root.u.def.section) != NULL
6965       && opd_entry_value (fdh->elf.root.u.def.section,
6966                           fdh->elf.root.u.def.value,
6967                           &fh->elf.root.u.def.section,
6968                           &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
6969     {
6970       fh->elf.root.type = fdh->elf.root.type;
6971       fh->elf.forced_local = 1;
6972       fh->elf.def_regular = fdh->elf.def_regular;
6973       fh->elf.def_dynamic = fdh->elf.def_dynamic;
6974     }
6975
6976   /* If this is a function code symbol, transfer dynamic linking
6977      information to the function descriptor symbol.  */
6978   if (!fh->is_func)
6979     return TRUE;
6980
6981   for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6982     if (ent->plt.refcount > 0)
6983       break;
6984   if (ent == NULL
6985       || fh->elf.root.root.string[0] != '.'
6986       || fh->elf.root.root.string[1] == '\0')
6987     return TRUE;
6988
6989   /* Find the corresponding function descriptor symbol.  Create it
6990      as undefined if necessary.  */
6991
6992   fdh = lookup_fdh (fh, htab);
6993   if (fdh == NULL
6994       && !bfd_link_executable (info)
6995       && (fh->elf.root.type == bfd_link_hash_undefined
6996           || fh->elf.root.type == bfd_link_hash_undefweak))
6997     {
6998       fdh = make_fdh (info, fh);
6999       if (fdh == NULL)
7000         return FALSE;
7001     }
7002
7003   /* Fake function descriptors are made undefweak.  If the function
7004      code symbol is strong undefined, make the fake sym the same.
7005      If the function code symbol is defined, then force the fake
7006      descriptor local;  We can't support overriding of symbols in a
7007      shared library on a fake descriptor.  */
7008
7009   if (fdh != NULL
7010       && fdh->fake
7011       && fdh->elf.root.type == bfd_link_hash_undefweak)
7012     {
7013       if (fh->elf.root.type == bfd_link_hash_undefined)
7014         {
7015           fdh->elf.root.type = bfd_link_hash_undefined;
7016           bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
7017         }
7018       else if (fh->elf.root.type == bfd_link_hash_defined
7019                || fh->elf.root.type == bfd_link_hash_defweak)
7020         {
7021           _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
7022         }
7023     }
7024
7025   if (fdh != NULL
7026       && !fdh->elf.forced_local
7027       && (!bfd_link_executable (info)
7028           || fdh->elf.def_dynamic
7029           || fdh->elf.ref_dynamic
7030           || (fdh->elf.root.type == bfd_link_hash_undefweak
7031               && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
7032     {
7033       if (fdh->elf.dynindx == -1)
7034         if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
7035           return FALSE;
7036       fdh->elf.ref_regular |= fh->elf.ref_regular;
7037       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
7038       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
7039       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
7040       if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
7041         {
7042           move_plt_plist (fh, fdh);
7043           fdh->elf.needs_plt = 1;
7044         }
7045       fdh->is_func_descriptor = 1;
7046       fdh->oh = fh;
7047       fh->oh = fdh;
7048     }
7049
7050   /* Now that the info is on the function descriptor, clear the
7051      function code sym info.  Any function code syms for which we
7052      don't have a definition in a regular file, we force local.
7053      This prevents a shared library from exporting syms that have
7054      been imported from another library.  Function code syms that
7055      are really in the library we must leave global to prevent the
7056      linker dragging in a definition from a static library.  */
7057   force_local = (!fh->elf.def_regular
7058                  || fdh == NULL
7059                  || !fdh->elf.def_regular
7060                  || fdh->elf.forced_local);
7061   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7062
7063   return TRUE;
7064 }
7065
7066 static const struct sfpr_def_parms save_res_funcs[] =
7067   {
7068     { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
7069     { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
7070     { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
7071     { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
7072     { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
7073     { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
7074     { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
7075     { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
7076     { "._savef", 14, 31, savefpr, savefpr1_tail },
7077     { "._restf", 14, 31, restfpr, restfpr1_tail },
7078     { "_savevr_", 20, 31, savevr, savevr_tail },
7079     { "_restvr_", 20, 31, restvr, restvr_tail }
7080   };
7081
7082 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
7083    this hook to a) provide some gcc support functions, and b) transfer
7084    dynamic linking information gathered so far on function code symbol
7085    entries, to their corresponding function descriptor symbol entries.  */
7086
7087 static bfd_boolean
7088 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
7089                             struct bfd_link_info *info)
7090 {
7091   struct ppc_link_hash_table *htab;
7092
7093   htab = ppc_hash_table (info);
7094   if (htab == NULL)
7095     return FALSE;
7096
7097   /* Provide any missing _save* and _rest* functions.  */
7098   if (htab->sfpr != NULL)
7099     {
7100       unsigned int i;
7101
7102       htab->sfpr->size = 0;
7103       for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
7104         if (!sfpr_define (info, &save_res_funcs[i], NULL))
7105           return FALSE;
7106       if (htab->sfpr->size == 0)
7107         htab->sfpr->flags |= SEC_EXCLUDE;
7108     }
7109
7110   if (bfd_link_relocatable (info))
7111     return TRUE;
7112
7113   if (htab->elf.hgot != NULL)
7114     {
7115       _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
7116       /* Make .TOC. defined so as to prevent it being made dynamic.
7117          The wrong value here is fixed later in ppc64_elf_set_toc.  */
7118       if (!htab->elf.hgot->def_regular
7119           || htab->elf.hgot->root.type != bfd_link_hash_defined)
7120         {
7121           htab->elf.hgot->root.type = bfd_link_hash_defined;
7122           htab->elf.hgot->root.u.def.value = 0;
7123           htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
7124           htab->elf.hgot->def_regular = 1;
7125           htab->elf.hgot->root.linker_def = 1;
7126         }
7127       htab->elf.hgot->type = STT_OBJECT;
7128       htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
7129                                | STV_HIDDEN);
7130     }
7131
7132   elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
7133
7134   return TRUE;
7135 }
7136
7137 /* Return true if we have dynamic relocs against H that apply to
7138    read-only sections.  */
7139
7140 static bfd_boolean
7141 readonly_dynrelocs (struct elf_link_hash_entry *h)
7142 {
7143   struct ppc_link_hash_entry *eh;
7144   struct elf_dyn_relocs *p;
7145
7146   eh = (struct ppc_link_hash_entry *) h;
7147   for (p = eh->dyn_relocs; p != NULL; p = p->next)
7148     {
7149       asection *s = p->sec->output_section;
7150
7151       if (s != NULL && (s->flags & SEC_READONLY) != 0)
7152         return TRUE;
7153     }
7154   return FALSE;
7155 }
7156
7157 /* Return true if we have dynamic relocs against H or any of its weak
7158    aliases, that apply to read-only sections.  */
7159
7160 static bfd_boolean
7161 alias_readonly_dynrelocs (struct elf_link_hash_entry *h)
7162 {
7163   struct ppc_link_hash_entry *eh;
7164
7165   eh = (struct ppc_link_hash_entry *) h;
7166   do
7167     {
7168       if (readonly_dynrelocs (&eh->elf))
7169         return TRUE;
7170       eh = eh->weakref;
7171     } while (eh != NULL && &eh->elf != h);
7172
7173   return FALSE;
7174 }
7175
7176 /* Return true if a global entry stub will be created for H.  Valid
7177    for ELFv2 before plt entries have been allocated.  */
7178
7179 static bfd_boolean
7180 global_entry_stub (struct elf_link_hash_entry *h)
7181 {
7182   struct plt_entry *pent;
7183
7184   if (!h->pointer_equality_needed
7185       || h->def_regular)
7186     return FALSE;
7187
7188   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
7189     if (pent->plt.refcount > 0
7190         && pent->addend == 0)
7191       return TRUE;
7192
7193   return FALSE;
7194 }
7195
7196 /* Adjust a symbol defined by a dynamic object and referenced by a
7197    regular object.  The current definition is in some section of the
7198    dynamic object, but we're not including those sections.  We have to
7199    change the definition to something the rest of the link can
7200    understand.  */
7201
7202 static bfd_boolean
7203 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
7204                                  struct elf_link_hash_entry *h)
7205 {
7206   struct ppc_link_hash_table *htab;
7207   asection *s;
7208
7209   htab = ppc_hash_table (info);
7210   if (htab == NULL)
7211     return FALSE;
7212
7213   /* Deal with function syms.  */
7214   if (h->type == STT_FUNC
7215       || h->type == STT_GNU_IFUNC
7216       || h->needs_plt)
7217     {
7218       /* Clear procedure linkage table information for any symbol that
7219          won't need a .plt entry.  */
7220       struct plt_entry *ent;
7221       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
7222         if (ent->plt.refcount > 0)
7223           break;
7224       if (ent == NULL
7225           || (h->type != STT_GNU_IFUNC
7226               && (SYMBOL_CALLS_LOCAL (info, h)
7227                   || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
7228                       && h->root.type == bfd_link_hash_undefweak)))
7229           || ((struct ppc_link_hash_entry *) h)->save_res)
7230         {
7231           h->plt.plist = NULL;
7232           h->needs_plt = 0;
7233           h->pointer_equality_needed = 0;
7234         }
7235       else if (abiversion (info->output_bfd) >= 2)
7236         {
7237           /* Taking a function's address in a read/write section
7238              doesn't require us to define the function symbol in the
7239              executable on a global entry stub.  A dynamic reloc can
7240              be used instead.  The reason we prefer a few more dynamic
7241              relocs is that calling via a global entry stub costs a
7242              few more instructions, and pointer_equality_needed causes
7243              extra work in ld.so when resolving these symbols.  */
7244           if (global_entry_stub (h)
7245               && !alias_readonly_dynrelocs (h))
7246             {
7247               h->pointer_equality_needed = 0;
7248               /* After adjust_dynamic_symbol, non_got_ref set in
7249                  the non-pic case means that dyn_relocs for this
7250                  symbol should be discarded.  */
7251               h->non_got_ref = 0;
7252             }
7253
7254           /* If making a plt entry, then we don't need copy relocs.  */
7255           return TRUE;
7256         }
7257     }
7258   else
7259     h->plt.plist = NULL;
7260
7261   /* If this is a weak symbol, and there is a real definition, the
7262      processor independent code will have arranged for us to see the
7263      real definition first, and we can just use the same value.  */
7264   if (h->u.weakdef != NULL)
7265     {
7266       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
7267                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
7268       h->root.u.def.section = h->u.weakdef->root.u.def.section;
7269       h->root.u.def.value = h->u.weakdef->root.u.def.value;
7270       if (ELIMINATE_COPY_RELOCS)
7271         h->non_got_ref = h->u.weakdef->non_got_ref;
7272       return TRUE;
7273     }
7274
7275   /* If we are creating a shared library, we must presume that the
7276      only references to the symbol are via the global offset table.
7277      For such cases we need not do anything here; the relocations will
7278      be handled correctly by relocate_section.  */
7279   if (bfd_link_pic (info))
7280     return TRUE;
7281
7282   /* If there are no references to this symbol that do not use the
7283      GOT, we don't need to generate a copy reloc.  */
7284   if (!h->non_got_ref)
7285     return TRUE;
7286
7287   /* Don't generate a copy reloc for symbols defined in the executable.  */
7288   if (!h->def_dynamic || !h->ref_regular || h->def_regular
7289
7290       /* If -z nocopyreloc was given, don't generate them either.  */
7291       || info->nocopyreloc
7292
7293       /* If we didn't find any dynamic relocs in read-only sections, then
7294          we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
7295       || (ELIMINATE_COPY_RELOCS && !alias_readonly_dynrelocs (h))
7296
7297       /* Protected variables do not work with .dynbss.  The copy in
7298          .dynbss won't be used by the shared library with the protected
7299          definition for the variable.  Text relocations are preferable
7300          to an incorrect program.  */
7301       || h->protected_def)
7302     {
7303       h->non_got_ref = 0;
7304       return TRUE;
7305     }
7306
7307   if (h->plt.plist != NULL)
7308     {
7309       /* We should never get here, but unfortunately there are versions
7310          of gcc out there that improperly (for this ABI) put initialized
7311          function pointers, vtable refs and suchlike in read-only
7312          sections.  Allow them to proceed, but warn that this might
7313          break at runtime.  */
7314       info->callbacks->einfo
7315         (_("%P: copy reloc against `%T' requires lazy plt linking; "
7316            "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7317          h->root.root.string);
7318     }
7319
7320   /* This is a reference to a symbol defined by a dynamic object which
7321      is not a function.  */
7322
7323   /* We must allocate the symbol in our .dynbss section, which will
7324      become part of the .bss section of the executable.  There will be
7325      an entry for this symbol in the .dynsym section.  The dynamic
7326      object will contain position independent code, so all references
7327      from the dynamic object to this symbol will go through the global
7328      offset table.  The dynamic linker will use the .dynsym entry to
7329      determine the address it must put in the global offset table, so
7330      both the dynamic object and the regular object will refer to the
7331      same memory location for the variable.  */
7332
7333   /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
7334      to copy the initial value out of the dynamic object and into the
7335      runtime process image.  We need to remember the offset into the
7336      .rela.bss section we are going to use.  */
7337   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7338     {
7339       htab->relbss->size += sizeof (Elf64_External_Rela);
7340       h->needs_copy = 1;
7341     }
7342
7343   s = htab->dynbss;
7344
7345   return _bfd_elf_adjust_dynamic_copy (info, h, s);
7346 }
7347
7348 /* If given a function descriptor symbol, hide both the function code
7349    sym and the descriptor.  */
7350 static void
7351 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7352                        struct elf_link_hash_entry *h,
7353                        bfd_boolean force_local)
7354 {
7355   struct ppc_link_hash_entry *eh;
7356   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7357
7358   eh = (struct ppc_link_hash_entry *) h;
7359   if (eh->is_func_descriptor)
7360     {
7361       struct ppc_link_hash_entry *fh = eh->oh;
7362
7363       if (fh == NULL)
7364         {
7365           const char *p, *q;
7366           struct ppc_link_hash_table *htab;
7367           char save;
7368
7369           /* We aren't supposed to use alloca in BFD because on
7370              systems which do not have alloca the version in libiberty
7371              calls xmalloc, which might cause the program to crash
7372              when it runs out of memory.  This function doesn't have a
7373              return status, so there's no way to gracefully return an
7374              error.  So cheat.  We know that string[-1] can be safely
7375              accessed;  It's either a string in an ELF string table,
7376              or allocated in an objalloc structure.  */
7377
7378           p = eh->elf.root.root.string - 1;
7379           save = *p;
7380           *(char *) p = '.';
7381           htab = ppc_hash_table (info);
7382           if (htab == NULL)
7383             return;
7384
7385           fh = (struct ppc_link_hash_entry *)
7386             elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7387           *(char *) p = save;
7388
7389           /* Unfortunately, if it so happens that the string we were
7390              looking for was allocated immediately before this string,
7391              then we overwrote the string terminator.  That's the only
7392              reason the lookup should fail.  */
7393           if (fh == NULL)
7394             {
7395               q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7396               while (q >= eh->elf.root.root.string && *q == *p)
7397                 --q, --p;
7398               if (q < eh->elf.root.root.string && *p == '.')
7399                 fh = (struct ppc_link_hash_entry *)
7400                   elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7401             }
7402           if (fh != NULL)
7403             {
7404               eh->oh = fh;
7405               fh->oh = eh;
7406             }
7407         }
7408       if (fh != NULL)
7409         _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7410     }
7411 }
7412
7413 static bfd_boolean
7414 get_sym_h (struct elf_link_hash_entry **hp,
7415            Elf_Internal_Sym **symp,
7416            asection **symsecp,
7417            unsigned char **tls_maskp,
7418            Elf_Internal_Sym **locsymsp,
7419            unsigned long r_symndx,
7420            bfd *ibfd)
7421 {
7422   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7423
7424   if (r_symndx >= symtab_hdr->sh_info)
7425     {
7426       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7427       struct elf_link_hash_entry *h;
7428
7429       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7430       h = elf_follow_link (h);
7431
7432       if (hp != NULL)
7433         *hp = h;
7434
7435       if (symp != NULL)
7436         *symp = NULL;
7437
7438       if (symsecp != NULL)
7439         {
7440           asection *symsec = NULL;
7441           if (h->root.type == bfd_link_hash_defined
7442               || h->root.type == bfd_link_hash_defweak)
7443             symsec = h->root.u.def.section;
7444           *symsecp = symsec;
7445         }
7446
7447       if (tls_maskp != NULL)
7448         {
7449           struct ppc_link_hash_entry *eh;
7450
7451           eh = (struct ppc_link_hash_entry *) h;
7452           *tls_maskp = &eh->tls_mask;
7453         }
7454     }
7455   else
7456     {
7457       Elf_Internal_Sym *sym;
7458       Elf_Internal_Sym *locsyms = *locsymsp;
7459
7460       if (locsyms == NULL)
7461         {
7462           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7463           if (locsyms == NULL)
7464             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7465                                             symtab_hdr->sh_info,
7466                                             0, NULL, NULL, NULL);
7467           if (locsyms == NULL)
7468             return FALSE;
7469           *locsymsp = locsyms;
7470         }
7471       sym = locsyms + r_symndx;
7472
7473       if (hp != NULL)
7474         *hp = NULL;
7475
7476       if (symp != NULL)
7477         *symp = sym;
7478
7479       if (symsecp != NULL)
7480         *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7481
7482       if (tls_maskp != NULL)
7483         {
7484           struct got_entry **lgot_ents;
7485           unsigned char *tls_mask;
7486
7487           tls_mask = NULL;
7488           lgot_ents = elf_local_got_ents (ibfd);
7489           if (lgot_ents != NULL)
7490             {
7491               struct plt_entry **local_plt = (struct plt_entry **)
7492                 (lgot_ents + symtab_hdr->sh_info);
7493               unsigned char *lgot_masks = (unsigned char *)
7494                 (local_plt + symtab_hdr->sh_info);
7495               tls_mask = &lgot_masks[r_symndx];
7496             }
7497           *tls_maskp = tls_mask;
7498         }
7499     }
7500   return TRUE;
7501 }
7502
7503 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
7504    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7505    type suitable for optimization, and 1 otherwise.  */
7506
7507 static int
7508 get_tls_mask (unsigned char **tls_maskp,
7509               unsigned long *toc_symndx,
7510               bfd_vma *toc_addend,
7511               Elf_Internal_Sym **locsymsp,
7512               const Elf_Internal_Rela *rel,
7513               bfd *ibfd)
7514 {
7515   unsigned long r_symndx;
7516   int next_r;
7517   struct elf_link_hash_entry *h;
7518   Elf_Internal_Sym *sym;
7519   asection *sec;
7520   bfd_vma off;
7521
7522   r_symndx = ELF64_R_SYM (rel->r_info);
7523   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7524     return 0;
7525
7526   if ((*tls_maskp != NULL && **tls_maskp != 0)
7527       || sec == NULL
7528       || ppc64_elf_section_data (sec) == NULL
7529       || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7530     return 1;
7531
7532   /* Look inside a TOC section too.  */
7533   if (h != NULL)
7534     {
7535       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7536       off = h->root.u.def.value;
7537     }
7538   else
7539     off = sym->st_value;
7540   off += rel->r_addend;
7541   BFD_ASSERT (off % 8 == 0);
7542   r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7543   next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7544   if (toc_symndx != NULL)
7545     *toc_symndx = r_symndx;
7546   if (toc_addend != NULL)
7547     *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7548   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7549     return 0;
7550   if ((h == NULL || is_static_defined (h))
7551       && (next_r == -1 || next_r == -2))
7552     return 1 - next_r;
7553   return 1;
7554 }
7555
7556 /* Find (or create) an entry in the tocsave hash table.  */
7557
7558 static struct tocsave_entry *
7559 tocsave_find (struct ppc_link_hash_table *htab,
7560               enum insert_option insert,
7561               Elf_Internal_Sym **local_syms,
7562               const Elf_Internal_Rela *irela,
7563               bfd *ibfd)
7564 {
7565   unsigned long r_indx;
7566   struct elf_link_hash_entry *h;
7567   Elf_Internal_Sym *sym;
7568   struct tocsave_entry ent, *p;
7569   hashval_t hash;
7570   struct tocsave_entry **slot;
7571
7572   r_indx = ELF64_R_SYM (irela->r_info);
7573   if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7574     return NULL;
7575   if (ent.sec == NULL || ent.sec->output_section == NULL)
7576     {
7577       (*_bfd_error_handler)
7578         (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"));
7579       return NULL;
7580     }
7581
7582   if (h != NULL)
7583     ent.offset = h->root.u.def.value;
7584   else
7585     ent.offset = sym->st_value;
7586   ent.offset += irela->r_addend;
7587
7588   hash = tocsave_htab_hash (&ent);
7589   slot = ((struct tocsave_entry **)
7590           htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7591   if (slot == NULL)
7592     return NULL;
7593
7594   if (*slot == NULL)
7595     {
7596       p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7597       if (p == NULL)
7598         return NULL;
7599       *p = ent;
7600       *slot = p;
7601     }
7602   return *slot;
7603 }
7604
7605 /* Adjust all global syms defined in opd sections.  In gcc generated
7606    code for the old ABI, these will already have been done.  */
7607
7608 static bfd_boolean
7609 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7610 {
7611   struct ppc_link_hash_entry *eh;
7612   asection *sym_sec;
7613   struct _opd_sec_data *opd;
7614
7615   if (h->root.type == bfd_link_hash_indirect)
7616     return TRUE;
7617
7618   if (h->root.type != bfd_link_hash_defined
7619       && h->root.type != bfd_link_hash_defweak)
7620     return TRUE;
7621
7622   eh = (struct ppc_link_hash_entry *) h;
7623   if (eh->adjust_done)
7624     return TRUE;
7625
7626   sym_sec = eh->elf.root.u.def.section;
7627   opd = get_opd_info (sym_sec);
7628   if (opd != NULL && opd->adjust != NULL)
7629     {
7630       long adjust = opd->adjust[OPD_NDX (eh->elf.root.u.def.value)];
7631       if (adjust == -1)
7632         {
7633           /* This entry has been deleted.  */
7634           asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7635           if (dsec == NULL)
7636             {
7637               for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7638                 if (discarded_section (dsec))
7639                   {
7640                     ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7641                     break;
7642                   }
7643             }
7644           eh->elf.root.u.def.value = 0;
7645           eh->elf.root.u.def.section = dsec;
7646         }
7647       else
7648         eh->elf.root.u.def.value += adjust;
7649       eh->adjust_done = 1;
7650     }
7651   return TRUE;
7652 }
7653
7654 /* Handles decrementing dynamic reloc counts for the reloc specified by
7655    R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM
7656    have already been determined.  */
7657
7658 static bfd_boolean
7659 dec_dynrel_count (bfd_vma r_info,
7660                   asection *sec,
7661                   struct bfd_link_info *info,
7662                   Elf_Internal_Sym **local_syms,
7663                   struct elf_link_hash_entry *h,
7664                   Elf_Internal_Sym *sym)
7665 {
7666   enum elf_ppc64_reloc_type r_type;
7667   asection *sym_sec = NULL;
7668
7669   /* Can this reloc be dynamic?  This switch, and later tests here
7670      should be kept in sync with the code in check_relocs.  */
7671   r_type = ELF64_R_TYPE (r_info);
7672   switch (r_type)
7673     {
7674     default:
7675       return TRUE;
7676
7677     case R_PPC64_TPREL16:
7678     case R_PPC64_TPREL16_LO:
7679     case R_PPC64_TPREL16_HI:
7680     case R_PPC64_TPREL16_HA:
7681     case R_PPC64_TPREL16_DS:
7682     case R_PPC64_TPREL16_LO_DS:
7683     case R_PPC64_TPREL16_HIGH:
7684     case R_PPC64_TPREL16_HIGHA:
7685     case R_PPC64_TPREL16_HIGHER:
7686     case R_PPC64_TPREL16_HIGHERA:
7687     case R_PPC64_TPREL16_HIGHEST:
7688     case R_PPC64_TPREL16_HIGHESTA:
7689       if (!bfd_link_pic (info))
7690         return TRUE;
7691
7692     case R_PPC64_TPREL64:
7693     case R_PPC64_DTPMOD64:
7694     case R_PPC64_DTPREL64:
7695     case R_PPC64_ADDR64:
7696     case R_PPC64_REL30:
7697     case R_PPC64_REL32:
7698     case R_PPC64_REL64:
7699     case R_PPC64_ADDR14:
7700     case R_PPC64_ADDR14_BRNTAKEN:
7701     case R_PPC64_ADDR14_BRTAKEN:
7702     case R_PPC64_ADDR16:
7703     case R_PPC64_ADDR16_DS:
7704     case R_PPC64_ADDR16_HA:
7705     case R_PPC64_ADDR16_HI:
7706     case R_PPC64_ADDR16_HIGH:
7707     case R_PPC64_ADDR16_HIGHA:
7708     case R_PPC64_ADDR16_HIGHER:
7709     case R_PPC64_ADDR16_HIGHERA:
7710     case R_PPC64_ADDR16_HIGHEST:
7711     case R_PPC64_ADDR16_HIGHESTA:
7712     case R_PPC64_ADDR16_LO:
7713     case R_PPC64_ADDR16_LO_DS:
7714     case R_PPC64_ADDR24:
7715     case R_PPC64_ADDR32:
7716     case R_PPC64_UADDR16:
7717     case R_PPC64_UADDR32:
7718     case R_PPC64_UADDR64:
7719     case R_PPC64_TOC:
7720       break;
7721     }
7722
7723   if (local_syms != NULL)
7724     {
7725       unsigned long r_symndx;
7726       bfd *ibfd = sec->owner;
7727
7728       r_symndx = ELF64_R_SYM (r_info);
7729       if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7730         return FALSE;
7731     }
7732
7733   if ((bfd_link_pic (info)
7734        && (must_be_dyn_reloc (info, r_type)
7735            || (h != NULL
7736                && (!SYMBOLIC_BIND (info, h)
7737                    || h->root.type == bfd_link_hash_defweak
7738                    || !h->def_regular))))
7739       || (ELIMINATE_COPY_RELOCS
7740           && !bfd_link_pic (info)
7741           && h != NULL
7742           && (h->root.type == bfd_link_hash_defweak
7743               || !h->def_regular)))
7744     ;
7745   else
7746     return TRUE;
7747
7748   if (h != NULL)
7749     {
7750       struct elf_dyn_relocs *p;
7751       struct elf_dyn_relocs **pp;
7752       pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7753
7754       /* elf_gc_sweep may have already removed all dyn relocs associated
7755          with local syms for a given section.  Also, symbol flags are
7756          changed by elf_gc_sweep_symbol, confusing the test above.  Don't
7757          report a dynreloc miscount.  */
7758       if (*pp == NULL && info->gc_sections)
7759         return TRUE;
7760
7761       while ((p = *pp) != NULL)
7762         {
7763           if (p->sec == sec)
7764             {
7765               if (!must_be_dyn_reloc (info, r_type))
7766                 p->pc_count -= 1;
7767               p->count -= 1;
7768               if (p->count == 0)
7769                 *pp = p->next;
7770               return TRUE;
7771             }
7772           pp = &p->next;
7773         }
7774     }
7775   else
7776     {
7777       struct ppc_dyn_relocs *p;
7778       struct ppc_dyn_relocs **pp;
7779       void *vpp;
7780       bfd_boolean is_ifunc;
7781
7782       if (local_syms == NULL)
7783         sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7784       if (sym_sec == NULL)
7785         sym_sec = sec;
7786
7787       vpp = &elf_section_data (sym_sec)->local_dynrel;
7788       pp = (struct ppc_dyn_relocs **) vpp;
7789
7790       if (*pp == NULL && info->gc_sections)
7791         return TRUE;
7792
7793       is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7794       while ((p = *pp) != NULL)
7795         {
7796           if (p->sec == sec && p->ifunc == is_ifunc)
7797             {
7798               p->count -= 1;
7799               if (p->count == 0)
7800                 *pp = p->next;
7801               return TRUE;
7802             }
7803           pp = &p->next;
7804         }
7805     }
7806
7807   info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7808                           sec->owner, sec);
7809   bfd_set_error (bfd_error_bad_value);
7810   return FALSE;
7811 }
7812
7813 /* Remove unused Official Procedure Descriptor entries.  Currently we
7814    only remove those associated with functions in discarded link-once
7815    sections, or weakly defined functions that have been overridden.  It
7816    would be possible to remove many more entries for statically linked
7817    applications.  */
7818
7819 bfd_boolean
7820 ppc64_elf_edit_opd (struct bfd_link_info *info)
7821 {
7822   bfd *ibfd;
7823   bfd_boolean some_edited = FALSE;
7824   asection *need_pad = NULL;
7825   struct ppc_link_hash_table *htab;
7826
7827   htab = ppc_hash_table (info);
7828   if (htab == NULL)
7829     return FALSE;
7830
7831   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
7832     {
7833       asection *sec;
7834       Elf_Internal_Rela *relstart, *rel, *relend;
7835       Elf_Internal_Shdr *symtab_hdr;
7836       Elf_Internal_Sym *local_syms;
7837       struct _opd_sec_data *opd;
7838       bfd_boolean need_edit, add_aux_fields, broken;
7839       bfd_size_type cnt_16b = 0;
7840
7841       if (!is_ppc64_elf (ibfd))
7842         continue;
7843
7844       sec = bfd_get_section_by_name (ibfd, ".opd");
7845       if (sec == NULL || sec->size == 0)
7846         continue;
7847
7848       if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7849         continue;
7850
7851       if (sec->output_section == bfd_abs_section_ptr)
7852         continue;
7853
7854       /* Look through the section relocs.  */
7855       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7856         continue;
7857
7858       local_syms = NULL;
7859       symtab_hdr = &elf_symtab_hdr (ibfd);
7860
7861       /* Read the relocations.  */
7862       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7863                                             info->keep_memory);
7864       if (relstart == NULL)
7865         return FALSE;
7866
7867       /* First run through the relocs to check they are sane, and to
7868          determine whether we need to edit this opd section.  */
7869       need_edit = FALSE;
7870       broken = FALSE;
7871       need_pad = sec;
7872       relend = relstart + sec->reloc_count;
7873       for (rel = relstart; rel < relend; )
7874         {
7875           enum elf_ppc64_reloc_type r_type;
7876           unsigned long r_symndx;
7877           asection *sym_sec;
7878           struct elf_link_hash_entry *h;
7879           Elf_Internal_Sym *sym;
7880           bfd_vma offset;
7881
7882           /* .opd contains an array of 16 or 24 byte entries.  We're
7883              only interested in the reloc pointing to a function entry
7884              point.  */
7885           offset = rel->r_offset;
7886           if (rel + 1 == relend
7887               || rel[1].r_offset != offset + 8)
7888             {
7889               /* If someone messes with .opd alignment then after a
7890                  "ld -r" we might have padding in the middle of .opd.
7891                  Also, there's nothing to prevent someone putting
7892                  something silly in .opd with the assembler.  No .opd
7893                  optimization for them!  */
7894             broken_opd:
7895               (*_bfd_error_handler)
7896                 (_("%B: .opd is not a regular array of opd entries"), ibfd);
7897               broken = TRUE;
7898               break;
7899             }
7900
7901           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7902               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7903             {
7904               (*_bfd_error_handler)
7905                 (_("%B: unexpected reloc type %u in .opd section"),
7906                  ibfd, r_type);
7907               broken = TRUE;
7908               break;
7909             }
7910
7911           r_symndx = ELF64_R_SYM (rel->r_info);
7912           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7913                           r_symndx, ibfd))
7914             goto error_ret;
7915
7916           if (sym_sec == NULL || sym_sec->owner == NULL)
7917             {
7918               const char *sym_name;
7919               if (h != NULL)
7920                 sym_name = h->root.root.string;
7921               else
7922                 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7923                                              sym_sec);
7924
7925               (*_bfd_error_handler)
7926                 (_("%B: undefined sym `%s' in .opd section"),
7927                  ibfd, sym_name);
7928               broken = TRUE;
7929               break;
7930             }
7931
7932           /* opd entries are always for functions defined in the
7933              current input bfd.  If the symbol isn't defined in the
7934              input bfd, then we won't be using the function in this
7935              bfd;  It must be defined in a linkonce section in another
7936              bfd, or is weak.  It's also possible that we are
7937              discarding the function due to a linker script /DISCARD/,
7938              which we test for via the output_section.  */
7939           if (sym_sec->owner != ibfd
7940               || sym_sec->output_section == bfd_abs_section_ptr)
7941             need_edit = TRUE;
7942
7943           rel += 2;
7944           if (rel + 1 == relend
7945               || (rel + 2 < relend
7946                   && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC))
7947             ++rel;
7948
7949           if (rel == relend)
7950             {
7951               if (sec->size == offset + 24)
7952                 {
7953                   need_pad = NULL;
7954                   break;
7955                 }
7956               if (sec->size == offset + 16)
7957                 {
7958                   cnt_16b++;
7959                   break;
7960                 }
7961               goto broken_opd;
7962             }
7963           else if (rel + 1 < relend
7964                    && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7965                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7966             {
7967               if (rel[0].r_offset == offset + 16)
7968                 cnt_16b++;
7969               else if (rel[0].r_offset != offset + 24)
7970                 goto broken_opd;
7971             }
7972           else
7973             goto broken_opd;
7974         }
7975
7976       add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
7977
7978       if (!broken && (need_edit || add_aux_fields))
7979         {
7980           Elf_Internal_Rela *write_rel;
7981           Elf_Internal_Shdr *rel_hdr;
7982           bfd_byte *rptr, *wptr;
7983           bfd_byte *new_contents;
7984           bfd_size_type amt;
7985
7986           new_contents = NULL;
7987           amt = OPD_NDX (sec->size) * sizeof (long);
7988           opd = &ppc64_elf_section_data (sec)->u.opd;
7989           opd->adjust = bfd_zalloc (sec->owner, amt);
7990           if (opd->adjust == NULL)
7991             return FALSE;
7992           ppc64_elf_section_data (sec)->sec_type = sec_opd;
7993
7994           /* This seems a waste of time as input .opd sections are all
7995              zeros as generated by gcc, but I suppose there's no reason
7996              this will always be so.  We might start putting something in
7997              the third word of .opd entries.  */
7998           if ((sec->flags & SEC_IN_MEMORY) == 0)
7999             {
8000               bfd_byte *loc;
8001               if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
8002                 {
8003                   if (loc != NULL)
8004                     free (loc);
8005                 error_ret:
8006                   if (local_syms != NULL
8007                       && symtab_hdr->contents != (unsigned char *) local_syms)
8008                     free (local_syms);
8009                   if (elf_section_data (sec)->relocs != relstart)
8010                     free (relstart);
8011                   return FALSE;
8012                 }
8013               sec->contents = loc;
8014               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8015             }
8016
8017           elf_section_data (sec)->relocs = relstart;
8018
8019           new_contents = sec->contents;
8020           if (add_aux_fields)
8021             {
8022               new_contents = bfd_malloc (sec->size + cnt_16b * 8);
8023               if (new_contents == NULL)
8024                 return FALSE;
8025               need_pad = NULL;
8026             }
8027           wptr = new_contents;
8028           rptr = sec->contents;
8029           write_rel = relstart;
8030           for (rel = relstart; rel < relend; )
8031             {
8032               unsigned long r_symndx;
8033               asection *sym_sec;
8034               struct elf_link_hash_entry *h;
8035               struct ppc_link_hash_entry *fdh = NULL;
8036               Elf_Internal_Sym *sym;
8037               long opd_ent_size;
8038               Elf_Internal_Rela *next_rel;
8039               bfd_boolean skip;
8040
8041               r_symndx = ELF64_R_SYM (rel->r_info);
8042               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8043                               r_symndx, ibfd))
8044                 goto error_ret;
8045
8046               next_rel = rel + 2;
8047               if (next_rel + 1 == relend
8048                   || (next_rel + 2 < relend
8049                       && ELF64_R_TYPE (next_rel[2].r_info) == R_PPC64_TOC))
8050                 ++next_rel;
8051
8052               /* See if the .opd entry is full 24 byte or
8053                  16 byte (with fd_aux entry overlapped with next
8054                  fd_func).  */
8055               opd_ent_size = 24;
8056               if (next_rel == relend)
8057                 {
8058                   if (sec->size == rel->r_offset + 16)
8059                     opd_ent_size = 16;
8060                 }
8061               else if (next_rel->r_offset == rel->r_offset + 16)
8062                 opd_ent_size = 16;
8063
8064               if (h != NULL
8065                   && h->root.root.string[0] == '.')
8066                 {
8067                   fdh = lookup_fdh ((struct ppc_link_hash_entry *) h, htab);
8068                   if (fdh != NULL
8069                       && fdh->elf.root.type != bfd_link_hash_defined
8070                       && fdh->elf.root.type != bfd_link_hash_defweak)
8071                     fdh = NULL;
8072                 }
8073
8074               skip = (sym_sec->owner != ibfd
8075                       || sym_sec->output_section == bfd_abs_section_ptr);
8076               if (skip)
8077                 {
8078                   if (fdh != NULL && sym_sec->owner == ibfd)
8079                     {
8080                       /* Arrange for the function descriptor sym
8081                          to be dropped.  */
8082                       fdh->elf.root.u.def.value = 0;
8083                       fdh->elf.root.u.def.section = sym_sec;
8084                     }
8085                   opd->adjust[OPD_NDX (rel->r_offset)] = -1;
8086
8087                   if (NO_OPD_RELOCS || bfd_link_relocatable (info))
8088                     rel = next_rel;
8089                   else
8090                     while (1)
8091                       {
8092                         if (!dec_dynrel_count (rel->r_info, sec, info,
8093                                                NULL, h, sym))
8094                           goto error_ret;
8095
8096                         if (++rel == next_rel)
8097                           break;
8098
8099                         r_symndx = ELF64_R_SYM (rel->r_info);
8100                         if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8101                                         r_symndx, ibfd))
8102                           goto error_ret;
8103                       }
8104                 }
8105               else
8106                 {
8107                   /* We'll be keeping this opd entry.  */
8108                   long adjust;
8109
8110                   if (fdh != NULL)
8111                     {
8112                       /* Redefine the function descriptor symbol to
8113                          this location in the opd section.  It is
8114                          necessary to update the value here rather
8115                          than using an array of adjustments as we do
8116                          for local symbols, because various places
8117                          in the generic ELF code use the value
8118                          stored in u.def.value.  */
8119                       fdh->elf.root.u.def.value = wptr - new_contents;
8120                       fdh->adjust_done = 1;
8121                     }
8122
8123                   /* Local syms are a bit tricky.  We could
8124                      tweak them as they can be cached, but
8125                      we'd need to look through the local syms
8126                      for the function descriptor sym which we
8127                      don't have at the moment.  So keep an
8128                      array of adjustments.  */
8129                   adjust = (wptr - new_contents) - (rptr - sec->contents);
8130                   opd->adjust[OPD_NDX (rel->r_offset)] = adjust;
8131
8132                   if (wptr != rptr)
8133                     memcpy (wptr, rptr, opd_ent_size);
8134                   wptr += opd_ent_size;
8135                   if (add_aux_fields && opd_ent_size == 16)
8136                     {
8137                       memset (wptr, '\0', 8);
8138                       wptr += 8;
8139                     }
8140
8141                   /* We need to adjust any reloc offsets to point to the
8142                      new opd entries.  */
8143                   for ( ; rel != next_rel; ++rel)
8144                     {
8145                       rel->r_offset += adjust;
8146                       if (write_rel != rel)
8147                         memcpy (write_rel, rel, sizeof (*rel));
8148                       ++write_rel;
8149                     }
8150                 }
8151
8152               rptr += opd_ent_size;
8153             }
8154
8155           sec->size = wptr - new_contents;
8156           sec->reloc_count = write_rel - relstart;
8157           if (add_aux_fields)
8158             {
8159               free (sec->contents);
8160               sec->contents = new_contents;
8161             }
8162
8163           /* Fudge the header size too, as this is used later in
8164              elf_bfd_final_link if we are emitting relocs.  */
8165           rel_hdr = _bfd_elf_single_rel_hdr (sec);
8166           rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
8167           some_edited = TRUE;
8168         }
8169       else if (elf_section_data (sec)->relocs != relstart)
8170         free (relstart);
8171
8172       if (local_syms != NULL
8173           && symtab_hdr->contents != (unsigned char *) local_syms)
8174         {
8175           if (!info->keep_memory)
8176             free (local_syms);
8177           else
8178             symtab_hdr->contents = (unsigned char *) local_syms;
8179         }
8180     }
8181
8182   if (some_edited)
8183     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
8184
8185   /* If we are doing a final link and the last .opd entry is just 16 byte
8186      long, add a 8 byte padding after it.  */
8187   if (need_pad != NULL && !bfd_link_relocatable (info))
8188     {
8189       bfd_byte *p;
8190
8191       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
8192         {
8193           BFD_ASSERT (need_pad->size > 0);
8194
8195           p = bfd_malloc (need_pad->size + 8);
8196           if (p == NULL)
8197             return FALSE;
8198
8199           if (! bfd_get_section_contents (need_pad->owner, need_pad,
8200                                           p, 0, need_pad->size))
8201             return FALSE;
8202
8203           need_pad->contents = p;
8204           need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8205         }
8206       else
8207         {
8208           p = bfd_realloc (need_pad->contents, need_pad->size + 8);
8209           if (p == NULL)
8210             return FALSE;
8211
8212           need_pad->contents = p;
8213         }
8214
8215       memset (need_pad->contents + need_pad->size, 0, 8);
8216       need_pad->size += 8;
8217     }
8218
8219   return TRUE;
8220 }
8221
8222 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
8223
8224 asection *
8225 ppc64_elf_tls_setup (struct bfd_link_info *info)
8226 {
8227   struct ppc_link_hash_table *htab;
8228
8229   htab = ppc_hash_table (info);
8230   if (htab == NULL)
8231     return NULL;
8232
8233   if (abiversion (info->output_bfd) == 1)
8234     htab->opd_abi = 1;
8235
8236   if (htab->params->no_multi_toc)
8237     htab->do_multi_toc = 0;
8238   else if (!htab->do_multi_toc)
8239     htab->params->no_multi_toc = 1;
8240
8241   htab->tls_get_addr = ((struct ppc_link_hash_entry *)
8242                         elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
8243                                               FALSE, FALSE, TRUE));
8244   /* Move dynamic linking info to the function descriptor sym.  */
8245   if (htab->tls_get_addr != NULL)
8246     func_desc_adjust (&htab->tls_get_addr->elf, info);
8247   htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
8248                            elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
8249                                                  FALSE, FALSE, TRUE));
8250   if (htab->params->tls_get_addr_opt)
8251     {
8252       struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
8253
8254       opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
8255                                   FALSE, FALSE, TRUE);
8256       if (opt != NULL)
8257         func_desc_adjust (opt, info);
8258       opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
8259                                      FALSE, FALSE, TRUE);
8260       if (opt_fd != NULL
8261           && (opt_fd->root.type == bfd_link_hash_defined
8262               || opt_fd->root.type == bfd_link_hash_defweak))
8263         {
8264           /* If glibc supports an optimized __tls_get_addr call stub,
8265              signalled by the presence of __tls_get_addr_opt, and we'll
8266              be calling __tls_get_addr via a plt call stub, then
8267              make __tls_get_addr point to __tls_get_addr_opt.  */
8268           tga_fd = &htab->tls_get_addr_fd->elf;
8269           if (htab->elf.dynamic_sections_created
8270               && tga_fd != NULL
8271               && (tga_fd->type == STT_FUNC
8272                   || tga_fd->needs_plt)
8273               && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
8274                    || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
8275                        && tga_fd->root.type == bfd_link_hash_undefweak)))
8276             {
8277               struct plt_entry *ent;
8278
8279               for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
8280                 if (ent->plt.refcount > 0)
8281                   break;
8282               if (ent != NULL)
8283                 {
8284                   tga_fd->root.type = bfd_link_hash_indirect;
8285                   tga_fd->root.u.i.link = &opt_fd->root;
8286                   ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
8287                   opt_fd->forced_local = 0;
8288                   if (opt_fd->dynindx != -1)
8289                     {
8290                       /* Use __tls_get_addr_opt in dynamic relocations.  */
8291                       opt_fd->dynindx = -1;
8292                       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8293                                               opt_fd->dynstr_index);
8294                       if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8295                         return NULL;
8296                     }
8297                   htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8298                   tga = &htab->tls_get_addr->elf;
8299                   if (opt != NULL && tga != NULL)
8300                     {
8301                       tga->root.type = bfd_link_hash_indirect;
8302                       tga->root.u.i.link = &opt->root;
8303                       ppc64_elf_copy_indirect_symbol (info, opt, tga);
8304                       opt->forced_local = 0;
8305                       _bfd_elf_link_hash_hide_symbol (info, opt,
8306                                                       tga->forced_local);
8307                       htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8308                     }
8309                   htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8310                   htab->tls_get_addr_fd->is_func_descriptor = 1;
8311                   if (htab->tls_get_addr != NULL)
8312                     {
8313                       htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8314                       htab->tls_get_addr->is_func = 1;
8315                     }
8316                 }
8317             }
8318         }
8319       else if (htab->params->tls_get_addr_opt < 0)
8320         htab->params->tls_get_addr_opt = 0;
8321     }
8322   return _bfd_elf_tls_setup (info->output_bfd, info);
8323 }
8324
8325 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8326    HASH1 or HASH2.  */
8327
8328 static bfd_boolean
8329 branch_reloc_hash_match (const bfd *ibfd,
8330                          const Elf_Internal_Rela *rel,
8331                          const struct ppc_link_hash_entry *hash1,
8332                          const struct ppc_link_hash_entry *hash2)
8333 {
8334   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8335   enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8336   unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8337
8338   if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8339     {
8340       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8341       struct elf_link_hash_entry *h;
8342
8343       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8344       h = elf_follow_link (h);
8345       if (h == &hash1->elf || h == &hash2->elf)
8346         return TRUE;
8347     }
8348   return FALSE;
8349 }
8350
8351 /* Run through all the TLS relocs looking for optimization
8352    opportunities.  The linker has been hacked (see ppc64elf.em) to do
8353    a preliminary section layout so that we know the TLS segment
8354    offsets.  We can't optimize earlier because some optimizations need
8355    to know the tp offset, and we need to optimize before allocating
8356    dynamic relocations.  */
8357
8358 bfd_boolean
8359 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8360 {
8361   bfd *ibfd;
8362   asection *sec;
8363   struct ppc_link_hash_table *htab;
8364   unsigned char *toc_ref;
8365   int pass;
8366
8367   if (!bfd_link_executable (info))
8368     return TRUE;
8369
8370   htab = ppc_hash_table (info);
8371   if (htab == NULL)
8372     return FALSE;
8373
8374   /* Make two passes over the relocs.  On the first pass, mark toc
8375      entries involved with tls relocs, and check that tls relocs
8376      involved in setting up a tls_get_addr call are indeed followed by
8377      such a call.  If they are not, we can't do any tls optimization.
8378      On the second pass twiddle tls_mask flags to notify
8379      relocate_section that optimization can be done, and adjust got
8380      and plt refcounts.  */
8381   toc_ref = NULL;
8382   for (pass = 0; pass < 2; ++pass)
8383     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8384       {
8385         Elf_Internal_Sym *locsyms = NULL;
8386         asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8387
8388         for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8389           if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8390             {
8391               Elf_Internal_Rela *relstart, *rel, *relend;
8392               bfd_boolean found_tls_get_addr_arg = 0;
8393
8394               /* Read the relocations.  */
8395               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8396                                                     info->keep_memory);
8397               if (relstart == NULL)
8398                 {
8399                   free (toc_ref);
8400                   return FALSE;
8401                 }
8402
8403               relend = relstart + sec->reloc_count;
8404               for (rel = relstart; rel < relend; rel++)
8405                 {
8406                   enum elf_ppc64_reloc_type r_type;
8407                   unsigned long r_symndx;
8408                   struct elf_link_hash_entry *h;
8409                   Elf_Internal_Sym *sym;
8410                   asection *sym_sec;
8411                   unsigned char *tls_mask;
8412                   unsigned char tls_set, tls_clear, tls_type = 0;
8413                   bfd_vma value;
8414                   bfd_boolean ok_tprel, is_local;
8415                   long toc_ref_index = 0;
8416                   int expecting_tls_get_addr = 0;
8417                   bfd_boolean ret = FALSE;
8418
8419                   r_symndx = ELF64_R_SYM (rel->r_info);
8420                   if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8421                                   r_symndx, ibfd))
8422                     {
8423                     err_free_rel:
8424                       if (elf_section_data (sec)->relocs != relstart)
8425                         free (relstart);
8426                       if (toc_ref != NULL)
8427                         free (toc_ref);
8428                       if (locsyms != NULL
8429                           && (elf_symtab_hdr (ibfd).contents
8430                               != (unsigned char *) locsyms))
8431                         free (locsyms);
8432                       return ret;
8433                     }
8434
8435                   if (h != NULL)
8436                     {
8437                       if (h->root.type == bfd_link_hash_defined
8438                           || h->root.type == bfd_link_hash_defweak)
8439                         value = h->root.u.def.value;
8440                       else if (h->root.type == bfd_link_hash_undefweak)
8441                         value = 0;
8442                       else
8443                         {
8444                           found_tls_get_addr_arg = 0;
8445                           continue;
8446                         }
8447                     }
8448                   else
8449                     /* Symbols referenced by TLS relocs must be of type
8450                        STT_TLS.  So no need for .opd local sym adjust.  */
8451                     value = sym->st_value;
8452
8453                   ok_tprel = FALSE;
8454                   is_local = FALSE;
8455                   if (h == NULL
8456                       || !h->def_dynamic)
8457                     {
8458                       is_local = TRUE;
8459                       if (h != NULL
8460                           && h->root.type == bfd_link_hash_undefweak)
8461                         ok_tprel = TRUE;
8462                       else if (sym_sec != NULL
8463                                && sym_sec->output_section != NULL)
8464                         {
8465                           value += sym_sec->output_offset;
8466                           value += sym_sec->output_section->vma;
8467                           value -= htab->elf.tls_sec->vma;
8468                           ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8469                                       < (bfd_vma) 1 << 32);
8470                         }
8471                     }
8472
8473                   r_type = ELF64_R_TYPE (rel->r_info);
8474                   /* If this section has old-style __tls_get_addr calls
8475                      without marker relocs, then check that each
8476                      __tls_get_addr call reloc is preceded by a reloc
8477                      that conceivably belongs to the __tls_get_addr arg
8478                      setup insn.  If we don't find matching arg setup
8479                      relocs, don't do any tls optimization.  */
8480                   if (pass == 0
8481                       && sec->has_tls_get_addr_call
8482                       && h != NULL
8483                       && (h == &htab->tls_get_addr->elf
8484                           || h == &htab->tls_get_addr_fd->elf)
8485                       && !found_tls_get_addr_arg
8486                       && is_branch_reloc (r_type))
8487                     {
8488                       info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8489                                                 "TLS optimization disabled\n"),
8490                                               ibfd, sec, rel->r_offset);
8491                       ret = TRUE;
8492                       goto err_free_rel;
8493                     }
8494
8495                   found_tls_get_addr_arg = 0;
8496                   switch (r_type)
8497                     {
8498                     case R_PPC64_GOT_TLSLD16:
8499                     case R_PPC64_GOT_TLSLD16_LO:
8500                       expecting_tls_get_addr = 1;
8501                       found_tls_get_addr_arg = 1;
8502                       /* Fall thru */
8503
8504                     case R_PPC64_GOT_TLSLD16_HI:
8505                     case R_PPC64_GOT_TLSLD16_HA:
8506                       /* These relocs should never be against a symbol
8507                          defined in a shared lib.  Leave them alone if
8508                          that turns out to be the case.  */
8509                       if (!is_local)
8510                         continue;
8511
8512                       /* LD -> LE */
8513                       tls_set = 0;
8514                       tls_clear = TLS_LD;
8515                       tls_type = TLS_TLS | TLS_LD;
8516                       break;
8517
8518                     case R_PPC64_GOT_TLSGD16:
8519                     case R_PPC64_GOT_TLSGD16_LO:
8520                       expecting_tls_get_addr = 1;
8521                       found_tls_get_addr_arg = 1;
8522                       /* Fall thru */
8523
8524                     case R_PPC64_GOT_TLSGD16_HI:
8525                     case R_PPC64_GOT_TLSGD16_HA:
8526                       if (ok_tprel)
8527                         /* GD -> LE */
8528                         tls_set = 0;
8529                       else
8530                         /* GD -> IE */
8531                         tls_set = TLS_TLS | TLS_TPRELGD;
8532                       tls_clear = TLS_GD;
8533                       tls_type = TLS_TLS | TLS_GD;
8534                       break;
8535
8536                     case R_PPC64_GOT_TPREL16_DS:
8537                     case R_PPC64_GOT_TPREL16_LO_DS:
8538                     case R_PPC64_GOT_TPREL16_HI:
8539                     case R_PPC64_GOT_TPREL16_HA:
8540                       if (ok_tprel)
8541                         {
8542                           /* IE -> LE */
8543                           tls_set = 0;
8544                           tls_clear = TLS_TPREL;
8545                           tls_type = TLS_TLS | TLS_TPREL;
8546                           break;
8547                         }
8548                       continue;
8549
8550                     case R_PPC64_TLSGD:
8551                     case R_PPC64_TLSLD:
8552                       found_tls_get_addr_arg = 1;
8553                       /* Fall thru */
8554
8555                     case R_PPC64_TLS:
8556                     case R_PPC64_TOC16:
8557                     case R_PPC64_TOC16_LO:
8558                       if (sym_sec == NULL || sym_sec != toc)
8559                         continue;
8560
8561                       /* Mark this toc entry as referenced by a TLS
8562                          code sequence.  We can do that now in the
8563                          case of R_PPC64_TLS, and after checking for
8564                          tls_get_addr for the TOC16 relocs.  */
8565                       if (toc_ref == NULL)
8566                         toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8567                       if (toc_ref == NULL)
8568                         goto err_free_rel;
8569
8570                       if (h != NULL)
8571                         value = h->root.u.def.value;
8572                       else
8573                         value = sym->st_value;
8574                       value += rel->r_addend;
8575                       if (value % 8 != 0)
8576                         continue;
8577                       BFD_ASSERT (value < toc->size
8578                                   && toc->output_offset % 8 == 0);
8579                       toc_ref_index = (value + toc->output_offset) / 8;
8580                       if (r_type == R_PPC64_TLS
8581                           || r_type == R_PPC64_TLSGD
8582                           || r_type == R_PPC64_TLSLD)
8583                         {
8584                           toc_ref[toc_ref_index] = 1;
8585                           continue;
8586                         }
8587
8588                       if (pass != 0 && toc_ref[toc_ref_index] == 0)
8589                         continue;
8590
8591                       tls_set = 0;
8592                       tls_clear = 0;
8593                       expecting_tls_get_addr = 2;
8594                       break;
8595
8596                     case R_PPC64_TPREL64:
8597                       if (pass == 0
8598                           || sec != toc
8599                           || toc_ref == NULL
8600                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8601                         continue;
8602                       if (ok_tprel)
8603                         {
8604                           /* IE -> LE */
8605                           tls_set = TLS_EXPLICIT;
8606                           tls_clear = TLS_TPREL;
8607                           break;
8608                         }
8609                       continue;
8610
8611                     case R_PPC64_DTPMOD64:
8612                       if (pass == 0
8613                           || sec != toc
8614                           || toc_ref == NULL
8615                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8616                         continue;
8617                       if (rel + 1 < relend
8618                           && (rel[1].r_info
8619                               == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8620                           && rel[1].r_offset == rel->r_offset + 8)
8621                         {
8622                           if (ok_tprel)
8623                             /* GD -> LE */
8624                             tls_set = TLS_EXPLICIT | TLS_GD;
8625                           else
8626                             /* GD -> IE */
8627                             tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8628                           tls_clear = TLS_GD;
8629                         }
8630                       else
8631                         {
8632                           if (!is_local)
8633                             continue;
8634
8635                           /* LD -> LE */
8636                           tls_set = TLS_EXPLICIT;
8637                           tls_clear = TLS_LD;
8638                         }
8639                       break;
8640
8641                     default:
8642                       continue;
8643                     }
8644
8645                   if (pass == 0)
8646                     {
8647                       if (!expecting_tls_get_addr
8648                           || !sec->has_tls_get_addr_call)
8649                         continue;
8650
8651                       if (rel + 1 < relend
8652                           && branch_reloc_hash_match (ibfd, rel + 1,
8653                                                       htab->tls_get_addr,
8654                                                       htab->tls_get_addr_fd))
8655                         {
8656                           if (expecting_tls_get_addr == 2)
8657                             {
8658                               /* Check for toc tls entries.  */
8659                               unsigned char *toc_tls;
8660                               int retval;
8661
8662                               retval = get_tls_mask (&toc_tls, NULL, NULL,
8663                                                      &locsyms,
8664                                                      rel, ibfd);
8665                               if (retval == 0)
8666                                 goto err_free_rel;
8667                               if (toc_tls != NULL)
8668                                 {
8669                                   if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8670                                     found_tls_get_addr_arg = 1;
8671                                   if (retval > 1)
8672                                     toc_ref[toc_ref_index] = 1;
8673                                 }
8674                             }
8675                           continue;
8676                         }
8677
8678                       if (expecting_tls_get_addr != 1)
8679                         continue;
8680
8681                       /* Uh oh, we didn't find the expected call.  We
8682                          could just mark this symbol to exclude it
8683                          from tls optimization but it's safer to skip
8684                          the entire optimization.  */
8685                       info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8686                                                 "TLS optimization disabled\n"),
8687                                               ibfd, sec, rel->r_offset);
8688                       ret = TRUE;
8689                       goto err_free_rel;
8690                     }
8691
8692                   if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8693                     {
8694                       struct plt_entry *ent;
8695                       for (ent = htab->tls_get_addr->elf.plt.plist;
8696                            ent != NULL;
8697                            ent = ent->next)
8698                         if (ent->addend == 0)
8699                           {
8700                             if (ent->plt.refcount > 0)
8701                               {
8702                                 ent->plt.refcount -= 1;
8703                                 expecting_tls_get_addr = 0;
8704                               }
8705                             break;
8706                           }
8707                     }
8708
8709                   if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8710                     {
8711                       struct plt_entry *ent;
8712                       for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8713                            ent != NULL;
8714                            ent = ent->next)
8715                         if (ent->addend == 0)
8716                           {
8717                             if (ent->plt.refcount > 0)
8718                               ent->plt.refcount -= 1;
8719                             break;
8720                           }
8721                     }
8722
8723                   if (tls_clear == 0)
8724                     continue;
8725
8726                   if ((tls_set & TLS_EXPLICIT) == 0)
8727                     {
8728                       struct got_entry *ent;
8729
8730                       /* Adjust got entry for this reloc.  */
8731                       if (h != NULL)
8732                         ent = h->got.glist;
8733                       else
8734                         ent = elf_local_got_ents (ibfd)[r_symndx];
8735
8736                       for (; ent != NULL; ent = ent->next)
8737                         if (ent->addend == rel->r_addend
8738                             && ent->owner == ibfd
8739                             && ent->tls_type == tls_type)
8740                           break;
8741                       if (ent == NULL)
8742                         abort ();
8743
8744                       if (tls_set == 0)
8745                         {
8746                           /* We managed to get rid of a got entry.  */
8747                           if (ent->got.refcount > 0)
8748                             ent->got.refcount -= 1;
8749                         }
8750                     }
8751                   else
8752                     {
8753                       /* If we got rid of a DTPMOD/DTPREL reloc pair then
8754                          we'll lose one or two dyn relocs.  */
8755                       if (!dec_dynrel_count (rel->r_info, sec, info,
8756                                              NULL, h, sym))
8757                         return FALSE;
8758
8759                       if (tls_set == (TLS_EXPLICIT | TLS_GD))
8760                         {
8761                           if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8762                                                  NULL, h, sym))
8763                             return FALSE;
8764                         }
8765                     }
8766
8767                   *tls_mask |= tls_set;
8768                   *tls_mask &= ~tls_clear;
8769                 }
8770
8771               if (elf_section_data (sec)->relocs != relstart)
8772                 free (relstart);
8773             }
8774
8775         if (locsyms != NULL
8776             && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8777           {
8778             if (!info->keep_memory)
8779               free (locsyms);
8780             else
8781               elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8782           }
8783       }
8784
8785   if (toc_ref != NULL)
8786     free (toc_ref);
8787   return TRUE;
8788 }
8789
8790 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8791    the values of any global symbols in a toc section that has been
8792    edited.  Globals in toc sections should be a rarity, so this function
8793    sets a flag if any are found in toc sections other than the one just
8794    edited, so that futher hash table traversals can be avoided.  */
8795
8796 struct adjust_toc_info
8797 {
8798   asection *toc;
8799   unsigned long *skip;
8800   bfd_boolean global_toc_syms;
8801 };
8802
8803 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8804
8805 static bfd_boolean
8806 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8807 {
8808   struct ppc_link_hash_entry *eh;
8809   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8810   unsigned long i;
8811
8812   if (h->root.type != bfd_link_hash_defined
8813       && h->root.type != bfd_link_hash_defweak)
8814     return TRUE;
8815
8816   eh = (struct ppc_link_hash_entry *) h;
8817   if (eh->adjust_done)
8818     return TRUE;
8819
8820   if (eh->elf.root.u.def.section == toc_inf->toc)
8821     {
8822       if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8823         i = toc_inf->toc->rawsize >> 3;
8824       else
8825         i = eh->elf.root.u.def.value >> 3;
8826
8827       if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8828         {
8829           (*_bfd_error_handler)
8830             (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8831           do
8832             ++i;
8833           while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8834           eh->elf.root.u.def.value = (bfd_vma) i << 3;
8835         }
8836
8837       eh->elf.root.u.def.value -= toc_inf->skip[i];
8838       eh->adjust_done = 1;
8839     }
8840   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8841     toc_inf->global_toc_syms = TRUE;
8842
8843   return TRUE;
8844 }
8845
8846 /* Return TRUE iff INSN is one we expect on a _LO variety toc/got reloc.  */
8847
8848 static bfd_boolean
8849 ok_lo_toc_insn (unsigned int insn)
8850 {
8851   return ((insn & (0x3f << 26)) == 14u << 26 /* addi */
8852           || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8853           || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8854           || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8855           || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8856           || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8857           || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8858           || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8859           || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8860           || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8861           || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8862           || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8863           || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8864           || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8865           || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
8866               && (insn & 3) != 1)
8867           || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
8868               && ((insn & 3) == 0 || (insn & 3) == 3))
8869           || (insn & (0x3f << 26)) == 12u << 26 /* addic */);
8870 }
8871
8872 /* Examine all relocs referencing .toc sections in order to remove
8873    unused .toc entries.  */
8874
8875 bfd_boolean
8876 ppc64_elf_edit_toc (struct bfd_link_info *info)
8877 {
8878   bfd *ibfd;
8879   struct adjust_toc_info toc_inf;
8880   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8881
8882   htab->do_toc_opt = 1;
8883   toc_inf.global_toc_syms = TRUE;
8884   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8885     {
8886       asection *toc, *sec;
8887       Elf_Internal_Shdr *symtab_hdr;
8888       Elf_Internal_Sym *local_syms;
8889       Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8890       unsigned long *skip, *drop;
8891       unsigned char *used;
8892       unsigned char *keep, last, some_unused;
8893
8894       if (!is_ppc64_elf (ibfd))
8895         continue;
8896
8897       toc = bfd_get_section_by_name (ibfd, ".toc");
8898       if (toc == NULL
8899           || toc->size == 0
8900           || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8901           || discarded_section (toc))
8902         continue;
8903
8904       toc_relocs = NULL;
8905       local_syms = NULL;
8906       symtab_hdr = &elf_symtab_hdr (ibfd);
8907
8908       /* Look at sections dropped from the final link.  */
8909       skip = NULL;
8910       relstart = NULL;
8911       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8912         {
8913           if (sec->reloc_count == 0
8914               || !discarded_section (sec)
8915               || get_opd_info (sec)
8916               || (sec->flags & SEC_ALLOC) == 0
8917               || (sec->flags & SEC_DEBUGGING) != 0)
8918             continue;
8919
8920           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8921           if (relstart == NULL)
8922             goto error_ret;
8923
8924           /* Run through the relocs to see which toc entries might be
8925              unused.  */
8926           for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8927             {
8928               enum elf_ppc64_reloc_type r_type;
8929               unsigned long r_symndx;
8930               asection *sym_sec;
8931               struct elf_link_hash_entry *h;
8932               Elf_Internal_Sym *sym;
8933               bfd_vma val;
8934
8935               r_type = ELF64_R_TYPE (rel->r_info);
8936               switch (r_type)
8937                 {
8938                 default:
8939                   continue;
8940
8941                 case R_PPC64_TOC16:
8942                 case R_PPC64_TOC16_LO:
8943                 case R_PPC64_TOC16_HI:
8944                 case R_PPC64_TOC16_HA:
8945                 case R_PPC64_TOC16_DS:
8946                 case R_PPC64_TOC16_LO_DS:
8947                   break;
8948                 }
8949
8950               r_symndx = ELF64_R_SYM (rel->r_info);
8951               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8952                               r_symndx, ibfd))
8953                 goto error_ret;
8954
8955               if (sym_sec != toc)
8956                 continue;
8957
8958               if (h != NULL)
8959                 val = h->root.u.def.value;
8960               else
8961                 val = sym->st_value;
8962               val += rel->r_addend;
8963
8964               if (val >= toc->size)
8965                 continue;
8966
8967               /* Anything in the toc ought to be aligned to 8 bytes.
8968                  If not, don't mark as unused.  */
8969               if (val & 7)
8970                 continue;
8971
8972               if (skip == NULL)
8973                 {
8974                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8975                   if (skip == NULL)
8976                     goto error_ret;
8977                 }
8978
8979               skip[val >> 3] = ref_from_discarded;
8980             }
8981
8982           if (elf_section_data (sec)->relocs != relstart)
8983             free (relstart);
8984         }
8985
8986       /* For largetoc loads of address constants, we can convert
8987          .  addis rx,2,addr@got@ha
8988          .  ld ry,addr@got@l(rx)
8989          to
8990          .  addis rx,2,addr@toc@ha
8991          .  addi ry,rx,addr@toc@l
8992          when addr is within 2G of the toc pointer.  This then means
8993          that the word storing "addr" in the toc is no longer needed.  */
8994
8995       if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
8996           && toc->output_section->rawsize < (bfd_vma) 1 << 31
8997           && toc->reloc_count != 0)
8998         {
8999           /* Read toc relocs.  */
9000           toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9001                                                   info->keep_memory);
9002           if (toc_relocs == NULL)
9003             goto error_ret;
9004
9005           for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9006             {
9007               enum elf_ppc64_reloc_type r_type;
9008               unsigned long r_symndx;
9009               asection *sym_sec;
9010               struct elf_link_hash_entry *h;
9011               Elf_Internal_Sym *sym;
9012               bfd_vma val, addr;
9013
9014               r_type = ELF64_R_TYPE (rel->r_info);
9015               if (r_type != R_PPC64_ADDR64)
9016                 continue;
9017
9018               r_symndx = ELF64_R_SYM (rel->r_info);
9019               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9020                               r_symndx, ibfd))
9021                 goto error_ret;
9022
9023               if (sym_sec == NULL
9024                   || sym_sec->output_section == NULL
9025                   || discarded_section (sym_sec))
9026                 continue;
9027
9028               if (!SYMBOL_REFERENCES_LOCAL (info, h))
9029                 continue;
9030
9031               if (h != NULL)
9032                 {
9033                   if (h->type == STT_GNU_IFUNC)
9034                     continue;
9035                   val = h->root.u.def.value;
9036                 }
9037               else
9038                 {
9039                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
9040                     continue;
9041                   val = sym->st_value;
9042                 }
9043               val += rel->r_addend;
9044               val += sym_sec->output_section->vma + sym_sec->output_offset;
9045
9046               /* We don't yet know the exact toc pointer value, but we
9047                  know it will be somewhere in the toc section.  Don't
9048                  optimize if the difference from any possible toc
9049                  pointer is outside [ff..f80008000, 7fff7fff].  */
9050               addr = toc->output_section->vma + TOC_BASE_OFF;
9051               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9052                 continue;
9053
9054               addr = toc->output_section->vma + toc->output_section->rawsize;
9055               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9056                 continue;
9057
9058               if (skip == NULL)
9059                 {
9060                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9061                   if (skip == NULL)
9062                     goto error_ret;
9063                 }
9064
9065               skip[rel->r_offset >> 3]
9066                 |= can_optimize | ((rel - toc_relocs) << 2);
9067             }
9068         }
9069
9070       if (skip == NULL)
9071         continue;
9072
9073       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
9074       if (used == NULL)
9075         {
9076         error_ret:
9077           if (local_syms != NULL
9078               && symtab_hdr->contents != (unsigned char *) local_syms)
9079             free (local_syms);
9080           if (sec != NULL
9081               && relstart != NULL
9082               && elf_section_data (sec)->relocs != relstart)
9083             free (relstart);
9084           if (toc_relocs != NULL
9085               && elf_section_data (toc)->relocs != toc_relocs)
9086             free (toc_relocs);
9087           if (skip != NULL)
9088             free (skip);
9089           return FALSE;
9090         }
9091
9092       /* Now check all kept sections that might reference the toc.
9093          Check the toc itself last.  */
9094       for (sec = (ibfd->sections == toc && toc->next ? toc->next
9095                   : ibfd->sections);
9096            sec != NULL;
9097            sec = (sec == toc ? NULL
9098                   : sec->next == NULL ? toc
9099                   : sec->next == toc && toc->next ? toc->next
9100                   : sec->next))
9101         {
9102           int repeat;
9103
9104           if (sec->reloc_count == 0
9105               || discarded_section (sec)
9106               || get_opd_info (sec)
9107               || (sec->flags & SEC_ALLOC) == 0
9108               || (sec->flags & SEC_DEBUGGING) != 0)
9109             continue;
9110
9111           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9112                                                 info->keep_memory);
9113           if (relstart == NULL)
9114             {
9115               free (used);
9116               goto error_ret;
9117             }
9118
9119           /* Mark toc entries referenced as used.  */
9120           do
9121             {
9122               repeat = 0;
9123               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9124                 {
9125                   enum elf_ppc64_reloc_type r_type;
9126                   unsigned long r_symndx;
9127                   asection *sym_sec;
9128                   struct elf_link_hash_entry *h;
9129                   Elf_Internal_Sym *sym;
9130                   bfd_vma val;
9131                   enum {no_check, check_lo, check_ha} insn_check;
9132
9133                   r_type = ELF64_R_TYPE (rel->r_info);
9134                   switch (r_type)
9135                     {
9136                     default:
9137                       insn_check = no_check;
9138                       break;
9139
9140                     case R_PPC64_GOT_TLSLD16_HA:
9141                     case R_PPC64_GOT_TLSGD16_HA:
9142                     case R_PPC64_GOT_TPREL16_HA:
9143                     case R_PPC64_GOT_DTPREL16_HA:
9144                     case R_PPC64_GOT16_HA:
9145                     case R_PPC64_TOC16_HA:
9146                       insn_check = check_ha;
9147                       break;
9148
9149                     case R_PPC64_GOT_TLSLD16_LO:
9150                     case R_PPC64_GOT_TLSGD16_LO:
9151                     case R_PPC64_GOT_TPREL16_LO_DS:
9152                     case R_PPC64_GOT_DTPREL16_LO_DS:
9153                     case R_PPC64_GOT16_LO:
9154                     case R_PPC64_GOT16_LO_DS:
9155                     case R_PPC64_TOC16_LO:
9156                     case R_PPC64_TOC16_LO_DS:
9157                       insn_check = check_lo;
9158                       break;
9159                     }
9160
9161                   if (insn_check != no_check)
9162                     {
9163                       bfd_vma off = rel->r_offset & ~3;
9164                       unsigned char buf[4];
9165                       unsigned int insn;
9166
9167                       if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
9168                         {
9169                           free (used);
9170                           goto error_ret;
9171                         }
9172                       insn = bfd_get_32 (ibfd, buf);
9173                       if (insn_check == check_lo
9174                           ? !ok_lo_toc_insn (insn)
9175                           : ((insn & ((0x3f << 26) | 0x1f << 16))
9176                              != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9177                         {
9178                           char str[12];
9179
9180                           ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
9181                           sprintf (str, "%#08x", insn);
9182                           info->callbacks->einfo
9183                             (_("%P: %H: toc optimization is not supported for"
9184                                " %s instruction.\n"),
9185                              ibfd, sec, rel->r_offset & ~3, str);
9186                         }
9187                     }
9188
9189                   switch (r_type)
9190                     {
9191                     case R_PPC64_TOC16:
9192                     case R_PPC64_TOC16_LO:
9193                     case R_PPC64_TOC16_HI:
9194                     case R_PPC64_TOC16_HA:
9195                     case R_PPC64_TOC16_DS:
9196                     case R_PPC64_TOC16_LO_DS:
9197                       /* In case we're taking addresses of toc entries.  */
9198                     case R_PPC64_ADDR64:
9199                       break;
9200
9201                     default:
9202                       continue;
9203                     }
9204
9205                   r_symndx = ELF64_R_SYM (rel->r_info);
9206                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9207                                   r_symndx, ibfd))
9208                     {
9209                       free (used);
9210                       goto error_ret;
9211                     }
9212
9213                   if (sym_sec != toc)
9214                     continue;
9215
9216                   if (h != NULL)
9217                     val = h->root.u.def.value;
9218                   else
9219                     val = sym->st_value;
9220                   val += rel->r_addend;
9221
9222                   if (val >= toc->size)
9223                     continue;
9224
9225                   if ((skip[val >> 3] & can_optimize) != 0)
9226                     {
9227                       bfd_vma off;
9228                       unsigned char opc;
9229
9230                       switch (r_type)
9231                         {
9232                         case R_PPC64_TOC16_HA:
9233                           break;
9234
9235                         case R_PPC64_TOC16_LO_DS:
9236                           off = rel->r_offset;
9237                           off += (bfd_big_endian (ibfd) ? -2 : 3);
9238                           if (!bfd_get_section_contents (ibfd, sec, &opc,
9239                                                          off, 1))
9240                             {
9241                               free (used);
9242                               goto error_ret;
9243                             }
9244                           if ((opc & (0x3f << 2)) == (58u << 2))
9245                             break;
9246                           /* Fall thru */
9247
9248                         default:
9249                           /* Wrong sort of reloc, or not a ld.  We may
9250                              as well clear ref_from_discarded too.  */
9251                           skip[val >> 3] = 0;
9252                         }
9253                     }
9254
9255                   if (sec != toc)
9256                     used[val >> 3] = 1;
9257                   /* For the toc section, we only mark as used if this
9258                      entry itself isn't unused.  */
9259                   else if ((used[rel->r_offset >> 3]
9260                             || !(skip[rel->r_offset >> 3] & ref_from_discarded))
9261                            && !used[val >> 3])
9262                     {
9263                       /* Do all the relocs again, to catch reference
9264                          chains.  */
9265                       repeat = 1;
9266                       used[val >> 3] = 1;
9267                     }
9268                 }
9269             }
9270           while (repeat);
9271
9272           if (elf_section_data (sec)->relocs != relstart)
9273             free (relstart);
9274         }
9275
9276       /* Merge the used and skip arrays.  Assume that TOC
9277          doublewords not appearing as either used or unused belong
9278          to to an entry more than one doubleword in size.  */
9279       for (drop = skip, keep = used, last = 0, some_unused = 0;
9280            drop < skip + (toc->size + 7) / 8;
9281            ++drop, ++keep)
9282         {
9283           if (*keep)
9284             {
9285               *drop &= ~ref_from_discarded;
9286               if ((*drop & can_optimize) != 0)
9287                 some_unused = 1;
9288               last = 0;
9289             }
9290           else if ((*drop & ref_from_discarded) != 0)
9291             {
9292               some_unused = 1;
9293               last = ref_from_discarded;
9294             }
9295           else
9296             *drop = last;
9297         }
9298
9299       free (used);
9300
9301       if (some_unused)
9302         {
9303           bfd_byte *contents, *src;
9304           unsigned long off;
9305           Elf_Internal_Sym *sym;
9306           bfd_boolean local_toc_syms = FALSE;
9307
9308           /* Shuffle the toc contents, and at the same time convert the
9309              skip array from booleans into offsets.  */
9310           if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9311             goto error_ret;
9312
9313           elf_section_data (toc)->this_hdr.contents = contents;
9314
9315           for (src = contents, off = 0, drop = skip;
9316                src < contents + toc->size;
9317                src += 8, ++drop)
9318             {
9319               if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9320                 off += 8;
9321               else if (off != 0)
9322                 {
9323                   *drop = off;
9324                   memcpy (src - off, src, 8);
9325                 }
9326             }
9327           *drop = off;
9328           toc->rawsize = toc->size;
9329           toc->size = src - contents - off;
9330
9331           /* Adjust addends for relocs against the toc section sym,
9332              and optimize any accesses we can.  */
9333           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9334             {
9335               if (sec->reloc_count == 0
9336                   || discarded_section (sec))
9337                 continue;
9338
9339               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9340                                                     info->keep_memory);
9341               if (relstart == NULL)
9342                 goto error_ret;
9343
9344               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9345                 {
9346                   enum elf_ppc64_reloc_type r_type;
9347                   unsigned long r_symndx;
9348                   asection *sym_sec;
9349                   struct elf_link_hash_entry *h;
9350                   bfd_vma val;
9351
9352                   r_type = ELF64_R_TYPE (rel->r_info);
9353                   switch (r_type)
9354                     {
9355                     default:
9356                       continue;
9357
9358                     case R_PPC64_TOC16:
9359                     case R_PPC64_TOC16_LO:
9360                     case R_PPC64_TOC16_HI:
9361                     case R_PPC64_TOC16_HA:
9362                     case R_PPC64_TOC16_DS:
9363                     case R_PPC64_TOC16_LO_DS:
9364                     case R_PPC64_ADDR64:
9365                       break;
9366                     }
9367
9368                   r_symndx = ELF64_R_SYM (rel->r_info);
9369                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9370                                   r_symndx, ibfd))
9371                     goto error_ret;
9372
9373                   if (sym_sec != toc)
9374                     continue;
9375
9376                   if (h != NULL)
9377                     val = h->root.u.def.value;
9378                   else
9379                     {
9380                       val = sym->st_value;
9381                       if (val != 0)
9382                         local_toc_syms = TRUE;
9383                     }
9384
9385                   val += rel->r_addend;
9386
9387                   if (val > toc->rawsize)
9388                     val = toc->rawsize;
9389                   else if ((skip[val >> 3] & ref_from_discarded) != 0)
9390                     continue;
9391                   else if ((skip[val >> 3] & can_optimize) != 0)
9392                     {
9393                       Elf_Internal_Rela *tocrel
9394                         = toc_relocs + (skip[val >> 3] >> 2);
9395                       unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9396
9397                       switch (r_type)
9398                         {
9399                         case R_PPC64_TOC16_HA:
9400                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9401                           break;
9402
9403                         case R_PPC64_TOC16_LO_DS:
9404                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9405                           break;
9406
9407                         default:
9408                           if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9409                             ppc_howto_init ();
9410                           info->callbacks->einfo
9411                             (_("%P: %H: %s references "
9412                                "optimized away TOC entry\n"),
9413                              ibfd, sec, rel->r_offset,
9414                              ppc64_elf_howto_table[r_type]->name);
9415                           bfd_set_error (bfd_error_bad_value);
9416                           goto error_ret;
9417                         }
9418                       rel->r_addend = tocrel->r_addend;
9419                       elf_section_data (sec)->relocs = relstart;
9420                       continue;
9421                     }
9422
9423                   if (h != NULL || sym->st_value != 0)
9424                     continue;
9425
9426                   rel->r_addend -= skip[val >> 3];
9427                   elf_section_data (sec)->relocs = relstart;
9428                 }
9429
9430               if (elf_section_data (sec)->relocs != relstart)
9431                 free (relstart);
9432             }
9433
9434           /* We shouldn't have local or global symbols defined in the TOC,
9435              but handle them anyway.  */
9436           if (local_syms != NULL)
9437             for (sym = local_syms;
9438                  sym < local_syms + symtab_hdr->sh_info;
9439                  ++sym)
9440               if (sym->st_value != 0
9441                   && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9442                 {
9443                   unsigned long i;
9444
9445                   if (sym->st_value > toc->rawsize)
9446                     i = toc->rawsize >> 3;
9447                   else
9448                     i = sym->st_value >> 3;
9449
9450                   if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9451                     {
9452                       if (local_toc_syms)
9453                         (*_bfd_error_handler)
9454                           (_("%s defined on removed toc entry"),
9455                            bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9456                       do
9457                         ++i;
9458                       while ((skip[i] & (ref_from_discarded | can_optimize)));
9459                       sym->st_value = (bfd_vma) i << 3;
9460                     }
9461
9462                   sym->st_value -= skip[i];
9463                   symtab_hdr->contents = (unsigned char *) local_syms;
9464                 }
9465
9466           /* Adjust any global syms defined in this toc input section.  */
9467           if (toc_inf.global_toc_syms)
9468             {
9469               toc_inf.toc = toc;
9470               toc_inf.skip = skip;
9471               toc_inf.global_toc_syms = FALSE;
9472               elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9473                                       &toc_inf);
9474             }
9475
9476           if (toc->reloc_count != 0)
9477             {
9478               Elf_Internal_Shdr *rel_hdr;
9479               Elf_Internal_Rela *wrel;
9480               bfd_size_type sz;
9481
9482               /* Remove unused toc relocs, and adjust those we keep.  */
9483               if (toc_relocs == NULL)
9484                 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9485                                                         info->keep_memory);
9486               if (toc_relocs == NULL)
9487                 goto error_ret;
9488
9489               wrel = toc_relocs;
9490               for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9491                 if ((skip[rel->r_offset >> 3]
9492                      & (ref_from_discarded | can_optimize)) == 0)
9493                   {
9494                     wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9495                     wrel->r_info = rel->r_info;
9496                     wrel->r_addend = rel->r_addend;
9497                     ++wrel;
9498                   }
9499                 else if (!dec_dynrel_count (rel->r_info, toc, info,
9500                                             &local_syms, NULL, NULL))
9501                   goto error_ret;
9502
9503               elf_section_data (toc)->relocs = toc_relocs;
9504               toc->reloc_count = wrel - toc_relocs;
9505               rel_hdr = _bfd_elf_single_rel_hdr (toc);
9506               sz = rel_hdr->sh_entsize;
9507               rel_hdr->sh_size = toc->reloc_count * sz;
9508             }
9509         }
9510       else if (toc_relocs != NULL
9511                && elf_section_data (toc)->relocs != toc_relocs)
9512         free (toc_relocs);
9513
9514       if (local_syms != NULL
9515           && symtab_hdr->contents != (unsigned char *) local_syms)
9516         {
9517           if (!info->keep_memory)
9518             free (local_syms);
9519           else
9520             symtab_hdr->contents = (unsigned char *) local_syms;
9521         }
9522       free (skip);
9523     }
9524
9525   return TRUE;
9526 }
9527
9528 /* Return true iff input section I references the TOC using
9529    instructions limited to +/-32k offsets.  */
9530
9531 bfd_boolean
9532 ppc64_elf_has_small_toc_reloc (asection *i)
9533 {
9534   return (is_ppc64_elf (i->owner)
9535           && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9536 }
9537
9538 /* Allocate space for one GOT entry.  */
9539
9540 static void
9541 allocate_got (struct elf_link_hash_entry *h,
9542               struct bfd_link_info *info,
9543               struct got_entry *gent)
9544 {
9545   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9546   bfd_boolean dyn;
9547   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9548   int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9549                  ? 16 : 8);
9550   int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9551                   ? 2 : 1) * sizeof (Elf64_External_Rela);
9552   asection *got = ppc64_elf_tdata (gent->owner)->got;
9553
9554   gent->got.offset = got->size;
9555   got->size += entsize;
9556
9557   dyn = htab->elf.dynamic_sections_created;
9558   if (h->type == STT_GNU_IFUNC)
9559     {
9560       htab->elf.irelplt->size += rentsize;
9561       htab->got_reli_size += rentsize;
9562     }
9563   else if ((bfd_link_pic (info)
9564             || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
9565            && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9566                || h->root.type != bfd_link_hash_undefweak))
9567     {
9568       asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9569       relgot->size += rentsize;
9570     }
9571 }
9572
9573 /* This function merges got entries in the same toc group.  */
9574
9575 static void
9576 merge_got_entries (struct got_entry **pent)
9577 {
9578   struct got_entry *ent, *ent2;
9579
9580   for (ent = *pent; ent != NULL; ent = ent->next)
9581     if (!ent->is_indirect)
9582       for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9583         if (!ent2->is_indirect
9584             && ent2->addend == ent->addend
9585             && ent2->tls_type == ent->tls_type
9586             && elf_gp (ent2->owner) == elf_gp (ent->owner))
9587           {
9588             ent2->is_indirect = TRUE;
9589             ent2->got.ent = ent;
9590           }
9591 }
9592
9593 /* Allocate space in .plt, .got and associated reloc sections for
9594    dynamic relocs.  */
9595
9596 static bfd_boolean
9597 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9598 {
9599   struct bfd_link_info *info;
9600   struct ppc_link_hash_table *htab;
9601   asection *s;
9602   struct ppc_link_hash_entry *eh;
9603   struct got_entry **pgent, *gent;
9604
9605   if (h->root.type == bfd_link_hash_indirect)
9606     return TRUE;
9607
9608   info = (struct bfd_link_info *) inf;
9609   htab = ppc_hash_table (info);
9610   if (htab == NULL)
9611     return FALSE;
9612
9613   eh = (struct ppc_link_hash_entry *) h;
9614   /* Run through the TLS GD got entries first if we're changing them
9615      to TPREL.  */
9616   if ((eh->tls_mask & TLS_TPRELGD) != 0)
9617     for (gent = h->got.glist; gent != NULL; gent = gent->next)
9618       if (gent->got.refcount > 0
9619           && (gent->tls_type & TLS_GD) != 0)
9620         {
9621           /* This was a GD entry that has been converted to TPREL.  If
9622              there happens to be a TPREL entry we can use that one.  */
9623           struct got_entry *ent;
9624           for (ent = h->got.glist; ent != NULL; ent = ent->next)
9625             if (ent->got.refcount > 0
9626                 && (ent->tls_type & TLS_TPREL) != 0
9627                 && ent->addend == gent->addend
9628                 && ent->owner == gent->owner)
9629               {
9630                 gent->got.refcount = 0;
9631                 break;
9632               }
9633
9634           /* If not, then we'll be using our own TPREL entry.  */
9635           if (gent->got.refcount != 0)
9636             gent->tls_type = TLS_TLS | TLS_TPREL;
9637         }
9638
9639   /* Remove any list entry that won't generate a word in the GOT before
9640      we call merge_got_entries.  Otherwise we risk merging to empty
9641      entries.  */
9642   pgent = &h->got.glist;
9643   while ((gent = *pgent) != NULL)
9644     if (gent->got.refcount > 0)
9645       {
9646         if ((gent->tls_type & TLS_LD) != 0
9647             && !h->def_dynamic)
9648           {
9649             ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9650             *pgent = gent->next;
9651           }
9652         else
9653           pgent = &gent->next;
9654       }
9655     else
9656       *pgent = gent->next;
9657
9658   if (!htab->do_multi_toc)
9659     merge_got_entries (&h->got.glist);
9660
9661   for (gent = h->got.glist; gent != NULL; gent = gent->next)
9662     if (!gent->is_indirect)
9663       {
9664         /* Make sure this symbol is output as a dynamic symbol.
9665            Undefined weak syms won't yet be marked as dynamic,
9666            nor will all TLS symbols.  */
9667         if (h->dynindx == -1
9668             && !h->forced_local
9669             && h->type != STT_GNU_IFUNC
9670             && htab->elf.dynamic_sections_created)
9671           {
9672             if (! bfd_elf_link_record_dynamic_symbol (info, h))
9673               return FALSE;
9674           }
9675
9676         if (!is_ppc64_elf (gent->owner))
9677           abort ();
9678
9679         allocate_got (h, info, gent);
9680       }
9681
9682   if (!htab->elf.dynamic_sections_created
9683       && h->type != STT_GNU_IFUNC)
9684     eh->dyn_relocs = NULL;
9685
9686   if (eh->dyn_relocs != NULL)
9687     {
9688       struct elf_dyn_relocs *p, **pp;
9689
9690       /* In the shared -Bsymbolic case, discard space allocated for
9691          dynamic pc-relative relocs against symbols which turn out to
9692          be defined in regular objects.  For the normal shared case,
9693          discard space for relocs that have become local due to symbol
9694          visibility changes.  */
9695
9696       if (bfd_link_pic (info))
9697         {
9698           /* Relocs that use pc_count are those that appear on a call
9699              insn, or certain REL relocs (see must_be_dyn_reloc) that
9700              can be generated via assembly.  We want calls to
9701              protected symbols to resolve directly to the function
9702              rather than going via the plt.  If people want function
9703              pointer comparisons to work as expected then they should
9704              avoid writing weird assembly.  */
9705           if (SYMBOL_CALLS_LOCAL (info, h))
9706             {
9707               for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9708                 {
9709                   p->count -= p->pc_count;
9710                   p->pc_count = 0;
9711                   if (p->count == 0)
9712                     *pp = p->next;
9713                   else
9714                     pp = &p->next;
9715                 }
9716             }
9717
9718           /* Also discard relocs on undefined weak syms with
9719              non-default visibility.  */
9720           if (eh->dyn_relocs != NULL
9721               && h->root.type == bfd_link_hash_undefweak)
9722             {
9723               if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9724                 eh->dyn_relocs = NULL;
9725
9726               /* Make sure this symbol is output as a dynamic symbol.
9727                  Undefined weak syms won't yet be marked as dynamic.  */
9728               else if (h->dynindx == -1
9729                        && !h->forced_local)
9730                 {
9731                   if (! bfd_elf_link_record_dynamic_symbol (info, h))
9732                     return FALSE;
9733                 }
9734             }
9735         }
9736       else if (h->type == STT_GNU_IFUNC)
9737         {
9738           /* A plt entry is always created when making direct calls to
9739              an ifunc, even when building a static executable, but
9740              that doesn't cover all cases.  We may have only an ifunc
9741              initialised function pointer for a given ifunc symbol.
9742
9743              For ELFv2, dynamic relocations are not required when
9744              generating a global entry PLT stub.  */
9745           if (abiversion (info->output_bfd) >= 2)
9746             {
9747               if (global_entry_stub (h))
9748                 eh->dyn_relocs = NULL;
9749             }
9750
9751           /* For ELFv1 we have function descriptors.  Descriptors need
9752              to be treated like PLT entries and thus have dynamic
9753              relocations.  One exception is when the function
9754              descriptor is copied into .dynbss (which should only
9755              happen with ancient versions of gcc).  */
9756           else if (h->needs_copy)
9757             eh->dyn_relocs = NULL;
9758         }
9759       else if (ELIMINATE_COPY_RELOCS)
9760         {
9761           /* For the non-pic case, discard space for relocs against
9762              symbols which turn out to need copy relocs or are not
9763              dynamic.  */
9764
9765           /* First make sure this symbol is output as a dynamic symbol.
9766              Undefined weak syms won't yet be marked as dynamic.  */
9767           if (h->root.type == bfd_link_hash_undefweak
9768               && !h->non_got_ref
9769               && !h->def_regular
9770               && h->dynindx == -1
9771               && !h->forced_local
9772               && !bfd_elf_link_record_dynamic_symbol (info, h))
9773             return FALSE;
9774
9775           if (h->non_got_ref
9776               || h->def_regular
9777               || h->dynindx == -1)
9778             eh->dyn_relocs = NULL;
9779         }
9780
9781       /* Finally, allocate space.  */
9782       for (p = eh->dyn_relocs; p != NULL; p = p->next)
9783         {
9784           asection *sreloc = elf_section_data (p->sec)->sreloc;
9785           if (eh->elf.type == STT_GNU_IFUNC)
9786             sreloc = htab->elf.irelplt;
9787           sreloc->size += p->count * sizeof (Elf64_External_Rela);
9788         }
9789     }
9790
9791   if ((htab->elf.dynamic_sections_created
9792        && h->dynindx != -1
9793        && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
9794       || h->type == STT_GNU_IFUNC)
9795     {
9796       struct plt_entry *pent;
9797       bfd_boolean doneone = FALSE;
9798       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9799         if (pent->plt.refcount > 0)
9800           {
9801             if (!htab->elf.dynamic_sections_created
9802                 || h->dynindx == -1)
9803               {
9804                 s = htab->elf.iplt;
9805                 pent->plt.offset = s->size;
9806                 s->size += PLT_ENTRY_SIZE (htab);
9807                 s = htab->elf.irelplt;
9808               }
9809             else
9810               {
9811                 /* If this is the first .plt entry, make room for the special
9812                    first entry.  */
9813                 s = htab->elf.splt;
9814                 if (s->size == 0)
9815                   s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9816
9817                 pent->plt.offset = s->size;
9818
9819                 /* Make room for this entry.  */
9820                 s->size += PLT_ENTRY_SIZE (htab);
9821
9822                 /* Make room for the .glink code.  */
9823                 s = htab->glink;
9824                 if (s->size == 0)
9825                   s->size += GLINK_CALL_STUB_SIZE;
9826                 if (htab->opd_abi)
9827                   {
9828                     /* We need bigger stubs past index 32767.  */
9829                     if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9830                       s->size += 4;
9831                     s->size += 2*4;
9832                   }
9833                 else
9834                   s->size += 4;
9835
9836                 /* We also need to make an entry in the .rela.plt section.  */
9837                 s = htab->elf.srelplt;
9838               }
9839             s->size += sizeof (Elf64_External_Rela);
9840             doneone = TRUE;
9841           }
9842         else
9843           pent->plt.offset = (bfd_vma) -1;
9844       if (!doneone)
9845         {
9846           h->plt.plist = NULL;
9847           h->needs_plt = 0;
9848         }
9849     }
9850   else
9851     {
9852       h->plt.plist = NULL;
9853       h->needs_plt = 0;
9854     }
9855
9856   return TRUE;
9857 }
9858
9859 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9860    to set up space for global entry stubs.  These are put in glink,
9861    after the branch table.  */
9862
9863 static bfd_boolean
9864 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
9865 {
9866   struct bfd_link_info *info;
9867   struct ppc_link_hash_table *htab;
9868   struct plt_entry *pent;
9869   asection *s;
9870
9871   if (h->root.type == bfd_link_hash_indirect)
9872     return TRUE;
9873
9874   if (!h->pointer_equality_needed)
9875     return TRUE;
9876
9877   if (h->def_regular)
9878     return TRUE;
9879
9880   info = inf;
9881   htab = ppc_hash_table (info);
9882   if (htab == NULL)
9883     return FALSE;
9884
9885   s = htab->glink;
9886   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9887     if (pent->plt.offset != (bfd_vma) -1
9888         && pent->addend == 0)
9889       {
9890         /* For ELFv2, if this symbol is not defined in a regular file
9891            and we are not generating a shared library or pie, then we
9892            need to define the symbol in the executable on a call stub.
9893            This is to avoid text relocations.  */
9894         s->size = (s->size + 15) & -16;
9895         h->root.type = bfd_link_hash_defined;
9896         h->root.u.def.section = s;
9897         h->root.u.def.value = s->size;
9898         s->size += 16;
9899         break;
9900       }
9901   return TRUE;
9902 }
9903
9904 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9905    read-only sections.  */
9906
9907 static bfd_boolean
9908 maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
9909 {
9910   if (h->root.type == bfd_link_hash_indirect)
9911     return TRUE;
9912
9913   if (readonly_dynrelocs (h))
9914     {
9915       ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
9916
9917       /* Not an error, just cut short the traversal.  */
9918       return FALSE;
9919     }
9920   return TRUE;
9921 }
9922
9923 /* Set the sizes of the dynamic sections.  */
9924
9925 static bfd_boolean
9926 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
9927                                  struct bfd_link_info *info)
9928 {
9929   struct ppc_link_hash_table *htab;
9930   bfd *dynobj;
9931   asection *s;
9932   bfd_boolean relocs;
9933   bfd *ibfd;
9934   struct got_entry *first_tlsld;
9935
9936   htab = ppc_hash_table (info);
9937   if (htab == NULL)
9938     return FALSE;
9939
9940   dynobj = htab->elf.dynobj;
9941   if (dynobj == NULL)
9942     abort ();
9943
9944   if (htab->elf.dynamic_sections_created)
9945     {
9946       /* Set the contents of the .interp section to the interpreter.  */
9947       if (bfd_link_executable (info) && !info->nointerp)
9948         {
9949           s = bfd_get_linker_section (dynobj, ".interp");
9950           if (s == NULL)
9951             abort ();
9952           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
9953           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
9954         }
9955     }
9956
9957   /* Set up .got offsets for local syms, and space for local dynamic
9958      relocs.  */
9959   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9960     {
9961       struct got_entry **lgot_ents;
9962       struct got_entry **end_lgot_ents;
9963       struct plt_entry **local_plt;
9964       struct plt_entry **end_local_plt;
9965       unsigned char *lgot_masks;
9966       bfd_size_type locsymcount;
9967       Elf_Internal_Shdr *symtab_hdr;
9968
9969       if (!is_ppc64_elf (ibfd))
9970         continue;
9971
9972       for (s = ibfd->sections; s != NULL; s = s->next)
9973         {
9974           struct ppc_dyn_relocs *p;
9975
9976           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
9977             {
9978               if (!bfd_is_abs_section (p->sec)
9979                   && bfd_is_abs_section (p->sec->output_section))
9980                 {
9981                   /* Input section has been discarded, either because
9982                      it is a copy of a linkonce section or due to
9983                      linker script /DISCARD/, so we'll be discarding
9984                      the relocs too.  */
9985                 }
9986               else if (p->count != 0)
9987                 {
9988                   asection *srel = elf_section_data (p->sec)->sreloc;
9989                   if (p->ifunc)
9990                     srel = htab->elf.irelplt;
9991                   srel->size += p->count * sizeof (Elf64_External_Rela);
9992                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
9993                     info->flags |= DF_TEXTREL;
9994                 }
9995             }
9996         }
9997
9998       lgot_ents = elf_local_got_ents (ibfd);
9999       if (!lgot_ents)
10000         continue;
10001
10002       symtab_hdr = &elf_symtab_hdr (ibfd);
10003       locsymcount = symtab_hdr->sh_info;
10004       end_lgot_ents = lgot_ents + locsymcount;
10005       local_plt = (struct plt_entry **) end_lgot_ents;
10006       end_local_plt = local_plt + locsymcount;
10007       lgot_masks = (unsigned char *) end_local_plt;
10008       s = ppc64_elf_tdata (ibfd)->got;
10009       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
10010         {
10011           struct got_entry **pent, *ent;
10012
10013           pent = lgot_ents;
10014           while ((ent = *pent) != NULL)
10015             if (ent->got.refcount > 0)
10016               {
10017                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
10018                   {
10019                     ppc64_tlsld_got (ibfd)->got.refcount += 1;
10020                     *pent = ent->next;
10021                   }
10022                 else
10023                   {
10024                     unsigned int ent_size = 8;
10025                     unsigned int rel_size = sizeof (Elf64_External_Rela);
10026
10027                     ent->got.offset = s->size;
10028                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
10029                       {
10030                         ent_size *= 2;
10031                         rel_size *= 2;
10032                       }
10033                     s->size += ent_size;
10034                     if ((*lgot_masks & PLT_IFUNC) != 0)
10035                       {
10036                         htab->elf.irelplt->size += rel_size;
10037                         htab->got_reli_size += rel_size;
10038                       }
10039                     else if (bfd_link_pic (info))
10040                       {
10041                         asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10042                         srel->size += rel_size;
10043                       }
10044                     pent = &ent->next;
10045                   }
10046               }
10047             else
10048               *pent = ent->next;
10049         }
10050
10051       /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt.  */
10052       for (; local_plt < end_local_plt; ++local_plt)
10053         {
10054           struct plt_entry *ent;
10055
10056           for (ent = *local_plt; ent != NULL; ent = ent->next)
10057             if (ent->plt.refcount > 0)
10058               {
10059                 s = htab->elf.iplt;
10060                 ent->plt.offset = s->size;
10061                 s->size += PLT_ENTRY_SIZE (htab);
10062
10063                 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
10064               }
10065             else
10066               ent->plt.offset = (bfd_vma) -1;
10067         }
10068     }
10069
10070   /* Allocate global sym .plt and .got entries, and space for global
10071      sym dynamic relocs.  */
10072   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
10073   /* Stash the end of glink branch table.  */
10074   if (htab->glink != NULL)
10075     htab->glink->rawsize = htab->glink->size;
10076
10077   if (!htab->opd_abi && !bfd_link_pic (info))
10078     elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
10079
10080   first_tlsld = NULL;
10081   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10082     {
10083       struct got_entry *ent;
10084
10085       if (!is_ppc64_elf (ibfd))
10086         continue;
10087
10088       ent = ppc64_tlsld_got (ibfd);
10089       if (ent->got.refcount > 0)
10090         {
10091           if (!htab->do_multi_toc && first_tlsld != NULL)
10092             {
10093               ent->is_indirect = TRUE;
10094               ent->got.ent = first_tlsld;
10095             }
10096           else
10097             {
10098               if (first_tlsld == NULL)
10099                 first_tlsld = ent;
10100               s = ppc64_elf_tdata (ibfd)->got;
10101               ent->got.offset = s->size;
10102               ent->owner = ibfd;
10103               s->size += 16;
10104               if (bfd_link_pic (info))
10105                 {
10106                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10107                   srel->size += sizeof (Elf64_External_Rela);
10108                 }
10109             }
10110         }
10111       else
10112         ent->got.offset = (bfd_vma) -1;
10113     }
10114
10115   /* We now have determined the sizes of the various dynamic sections.
10116      Allocate memory for them.  */
10117   relocs = FALSE;
10118   for (s = dynobj->sections; s != NULL; s = s->next)
10119     {
10120       if ((s->flags & SEC_LINKER_CREATED) == 0)
10121         continue;
10122
10123       if (s == htab->brlt || s == htab->relbrlt)
10124         /* These haven't been allocated yet;  don't strip.  */
10125         continue;
10126       else if (s == htab->elf.sgot
10127                || s == htab->elf.splt
10128                || s == htab->elf.iplt
10129                || s == htab->glink
10130                || s == htab->dynbss)
10131         {
10132           /* Strip this section if we don't need it; see the
10133              comment below.  */
10134         }
10135       else if (s == htab->glink_eh_frame)
10136         {
10137           if (!bfd_is_abs_section (s->output_section))
10138             /* Not sized yet.  */
10139             continue;
10140         }
10141       else if (CONST_STRNEQ (s->name, ".rela"))
10142         {
10143           if (s->size != 0)
10144             {
10145               if (s != htab->elf.srelplt)
10146                 relocs = TRUE;
10147
10148               /* We use the reloc_count field as a counter if we need
10149                  to copy relocs into the output file.  */
10150               s->reloc_count = 0;
10151             }
10152         }
10153       else
10154         {
10155           /* It's not one of our sections, so don't allocate space.  */
10156           continue;
10157         }
10158
10159       if (s->size == 0)
10160         {
10161           /* If we don't need this section, strip it from the
10162              output file.  This is mostly to handle .rela.bss and
10163              .rela.plt.  We must create both sections in
10164              create_dynamic_sections, because they must be created
10165              before the linker maps input sections to output
10166              sections.  The linker does that before
10167              adjust_dynamic_symbol is called, and it is that
10168              function which decides whether anything needs to go
10169              into these sections.  */
10170           s->flags |= SEC_EXCLUDE;
10171           continue;
10172         }
10173
10174       if ((s->flags & SEC_HAS_CONTENTS) == 0)
10175         continue;
10176
10177       /* Allocate memory for the section contents.  We use bfd_zalloc
10178          here in case unused entries are not reclaimed before the
10179          section's contents are written out.  This should not happen,
10180          but this way if it does we get a R_PPC64_NONE reloc in .rela
10181          sections instead of garbage.
10182          We also rely on the section contents being zero when writing
10183          the GOT.  */
10184       s->contents = bfd_zalloc (dynobj, s->size);
10185       if (s->contents == NULL)
10186         return FALSE;
10187     }
10188
10189   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10190     {
10191       if (!is_ppc64_elf (ibfd))
10192         continue;
10193
10194       s = ppc64_elf_tdata (ibfd)->got;
10195       if (s != NULL && s != htab->elf.sgot)
10196         {
10197           if (s->size == 0)
10198             s->flags |= SEC_EXCLUDE;
10199           else
10200             {
10201               s->contents = bfd_zalloc (ibfd, s->size);
10202               if (s->contents == NULL)
10203                 return FALSE;
10204             }
10205         }
10206       s = ppc64_elf_tdata (ibfd)->relgot;
10207       if (s != NULL)
10208         {
10209           if (s->size == 0)
10210             s->flags |= SEC_EXCLUDE;
10211           else
10212             {
10213               s->contents = bfd_zalloc (ibfd, s->size);
10214               if (s->contents == NULL)
10215                 return FALSE;
10216               relocs = TRUE;
10217               s->reloc_count = 0;
10218             }
10219         }
10220     }
10221
10222   if (htab->elf.dynamic_sections_created)
10223     {
10224       bfd_boolean tls_opt;
10225
10226       /* Add some entries to the .dynamic section.  We fill in the
10227          values later, in ppc64_elf_finish_dynamic_sections, but we
10228          must add the entries now so that we get the correct size for
10229          the .dynamic section.  The DT_DEBUG entry is filled in by the
10230          dynamic linker and used by the debugger.  */
10231 #define add_dynamic_entry(TAG, VAL) \
10232   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10233
10234       if (bfd_link_executable (info))
10235         {
10236           if (!add_dynamic_entry (DT_DEBUG, 0))
10237             return FALSE;
10238         }
10239
10240       if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
10241         {
10242           if (!add_dynamic_entry (DT_PLTGOT, 0)
10243               || !add_dynamic_entry (DT_PLTRELSZ, 0)
10244               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
10245               || !add_dynamic_entry (DT_JMPREL, 0)
10246               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
10247             return FALSE;
10248         }
10249
10250       if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
10251         {
10252           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
10253               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
10254             return FALSE;
10255         }
10256
10257       tls_opt = (htab->params->tls_get_addr_opt
10258                  && htab->tls_get_addr_fd != NULL
10259                  && htab->tls_get_addr_fd->elf.plt.plist != NULL);
10260       if (tls_opt || !htab->opd_abi)
10261         {
10262           if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
10263             return FALSE;
10264         }
10265
10266       if (relocs)
10267         {
10268           if (!add_dynamic_entry (DT_RELA, 0)
10269               || !add_dynamic_entry (DT_RELASZ, 0)
10270               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
10271             return FALSE;
10272
10273           /* If any dynamic relocs apply to a read-only section,
10274              then we need a DT_TEXTREL entry.  */
10275           if ((info->flags & DF_TEXTREL) == 0)
10276             elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
10277
10278           if ((info->flags & DF_TEXTREL) != 0)
10279             {
10280               if (!add_dynamic_entry (DT_TEXTREL, 0))
10281                 return FALSE;
10282             }
10283         }
10284     }
10285 #undef add_dynamic_entry
10286
10287   return TRUE;
10288 }
10289
10290 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
10291
10292 static bfd_boolean
10293 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
10294 {
10295   if (h->plt.plist != NULL
10296       && !h->def_regular
10297       && !h->pointer_equality_needed)
10298     return FALSE;
10299
10300   return _bfd_elf_hash_symbol (h);
10301 }
10302
10303 /* Determine the type of stub needed, if any, for a call.  */
10304
10305 static inline enum ppc_stub_type
10306 ppc_type_of_stub (asection *input_sec,
10307                   const Elf_Internal_Rela *rel,
10308                   struct ppc_link_hash_entry **hash,
10309                   struct plt_entry **plt_ent,
10310                   bfd_vma destination,
10311                   unsigned long local_off)
10312 {
10313   struct ppc_link_hash_entry *h = *hash;
10314   bfd_vma location;
10315   bfd_vma branch_offset;
10316   bfd_vma max_branch_offset;
10317   enum elf_ppc64_reloc_type r_type;
10318
10319   if (h != NULL)
10320     {
10321       struct plt_entry *ent;
10322       struct ppc_link_hash_entry *fdh = h;
10323       if (h->oh != NULL
10324           && h->oh->is_func_descriptor)
10325         {
10326           fdh = ppc_follow_link (h->oh);
10327           *hash = fdh;
10328         }
10329
10330       for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10331         if (ent->addend == rel->r_addend
10332             && ent->plt.offset != (bfd_vma) -1)
10333           {
10334             *plt_ent = ent;
10335             return ppc_stub_plt_call;
10336           }
10337
10338       /* Here, we know we don't have a plt entry.  If we don't have a
10339          either a defined function descriptor or a defined entry symbol
10340          in a regular object file, then it is pointless trying to make
10341          any other type of stub.  */
10342       if (!is_static_defined (&fdh->elf)
10343           && !is_static_defined (&h->elf))
10344         return ppc_stub_none;
10345     }
10346   else if (elf_local_got_ents (input_sec->owner) != NULL)
10347     {
10348       Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10349       struct plt_entry **local_plt = (struct plt_entry **)
10350         elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10351       unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10352
10353       if (local_plt[r_symndx] != NULL)
10354         {
10355           struct plt_entry *ent;
10356
10357           for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10358             if (ent->addend == rel->r_addend
10359                 && ent->plt.offset != (bfd_vma) -1)
10360               {
10361                 *plt_ent = ent;
10362                 return ppc_stub_plt_call;
10363               }
10364         }
10365     }
10366
10367   /* Determine where the call point is.  */
10368   location = (input_sec->output_offset
10369               + input_sec->output_section->vma
10370               + rel->r_offset);
10371
10372   branch_offset = destination - location;
10373   r_type = ELF64_R_TYPE (rel->r_info);
10374
10375   /* Determine if a long branch stub is needed.  */
10376   max_branch_offset = 1 << 25;
10377   if (r_type != R_PPC64_REL24)
10378     max_branch_offset = 1 << 15;
10379
10380   if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10381     /* We need a stub.  Figure out whether a long_branch or plt_branch
10382        is needed later.  */
10383     return ppc_stub_long_branch;
10384
10385   return ppc_stub_none;
10386 }
10387
10388 /* With power7 weakly ordered memory model, it is possible for ld.so
10389    to update a plt entry in one thread and have another thread see a
10390    stale zero toc entry.  To avoid this we need some sort of acquire
10391    barrier in the call stub.  One solution is to make the load of the
10392    toc word seem to appear to depend on the load of the function entry
10393    word.  Another solution is to test for r2 being zero, and branch to
10394    the appropriate glink entry if so.
10395
10396    .    fake dep barrier        compare
10397    .    ld 12,xxx(2)            ld 12,xxx(2)
10398    .    mtctr 12                mtctr 12
10399    .    xor 11,12,12            ld 2,xxx+8(2)
10400    .    add 2,2,11              cmpldi 2,0
10401    .    ld 2,xxx+8(2)           bnectr+
10402    .    bctr                    b <glink_entry>
10403
10404    The solution involving the compare turns out to be faster, so
10405    that's what we use unless the branch won't reach.  */
10406
10407 #define ALWAYS_USE_FAKE_DEP 0
10408 #define ALWAYS_EMIT_R2SAVE 0
10409
10410 #define PPC_LO(v) ((v) & 0xffff)
10411 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10412 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10413
10414 static inline unsigned int
10415 plt_stub_size (struct ppc_link_hash_table *htab,
10416                struct ppc_stub_hash_entry *stub_entry,
10417                bfd_vma off)
10418 {
10419   unsigned size = 12;
10420
10421   if (ALWAYS_EMIT_R2SAVE
10422       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10423     size += 4;
10424   if (PPC_HA (off) != 0)
10425     size += 4;
10426   if (htab->opd_abi)
10427     {
10428       size += 4;
10429       if (htab->params->plt_static_chain)
10430         size += 4;
10431       if (htab->params->plt_thread_safe
10432           && htab->elf.dynamic_sections_created
10433           && stub_entry->h != NULL
10434           && stub_entry->h->elf.dynindx != -1)
10435         size += 8;
10436       if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
10437         size += 4;
10438     }
10439   if (stub_entry->h != NULL
10440       && (stub_entry->h == htab->tls_get_addr_fd
10441           || stub_entry->h == htab->tls_get_addr)
10442       && htab->params->tls_get_addr_opt)
10443     size += 13 * 4;
10444   return size;
10445 }
10446
10447 /* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
10448    then return the padding needed to do so.  */
10449 static inline unsigned int
10450 plt_stub_pad (struct ppc_link_hash_table *htab,
10451               struct ppc_stub_hash_entry *stub_entry,
10452               bfd_vma plt_off)
10453 {
10454   int stub_align = 1 << htab->params->plt_stub_align;
10455   unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10456   bfd_vma stub_off = stub_entry->group->stub_sec->size;
10457
10458   if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10459       > ((stub_size - 1) & -stub_align))
10460     return stub_align - (stub_off & (stub_align - 1));
10461   return 0;
10462 }
10463
10464 /* Build a .plt call stub.  */
10465
10466 static inline bfd_byte *
10467 build_plt_stub (struct ppc_link_hash_table *htab,
10468                 struct ppc_stub_hash_entry *stub_entry,
10469                 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10470 {
10471   bfd *obfd = htab->params->stub_bfd;
10472   bfd_boolean plt_load_toc = htab->opd_abi;
10473   bfd_boolean plt_static_chain = htab->params->plt_static_chain;
10474   bfd_boolean plt_thread_safe = (htab->params->plt_thread_safe
10475                                  && htab->elf.dynamic_sections_created
10476                                  && stub_entry->h != NULL
10477                                  && stub_entry->h->elf.dynindx != -1);
10478   bfd_boolean use_fake_dep = plt_thread_safe;
10479   bfd_vma cmp_branch_off = 0;
10480
10481   if (!ALWAYS_USE_FAKE_DEP
10482       && plt_load_toc
10483       && plt_thread_safe
10484       && !((stub_entry->h == htab->tls_get_addr_fd
10485             || stub_entry->h == htab->tls_get_addr)
10486            && htab->params->tls_get_addr_opt))
10487     {
10488       bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10489       bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10490                           / PLT_ENTRY_SIZE (htab));
10491       bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10492       bfd_vma to, from;
10493
10494       if (pltindex > 32768)
10495         glinkoff += (pltindex - 32768) * 4;
10496       to = (glinkoff
10497             + htab->glink->output_offset
10498             + htab->glink->output_section->vma);
10499       from = (p - stub_entry->group->stub_sec->contents
10500               + 4 * (ALWAYS_EMIT_R2SAVE
10501                      || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10502               + 4 * (PPC_HA (offset) != 0)
10503               + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10504                      != PPC_HA (offset))
10505               + 4 * (plt_static_chain != 0)
10506               + 20
10507               + stub_entry->group->stub_sec->output_offset
10508               + stub_entry->group->stub_sec->output_section->vma);
10509       cmp_branch_off = to - from;
10510       use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10511     }
10512
10513   if (PPC_HA (offset) != 0)
10514     {
10515       if (r != NULL)
10516         {
10517           if (ALWAYS_EMIT_R2SAVE
10518               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10519             r[0].r_offset += 4;
10520           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10521           r[1].r_offset = r[0].r_offset + 4;
10522           r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10523           r[1].r_addend = r[0].r_addend;
10524           if (plt_load_toc)
10525             {
10526               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10527                 {
10528                   r[2].r_offset = r[1].r_offset + 4;
10529                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10530                   r[2].r_addend = r[0].r_addend;
10531                 }
10532               else
10533                 {
10534                   r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10535                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10536                   r[2].r_addend = r[0].r_addend + 8;
10537                   if (plt_static_chain)
10538                     {
10539                       r[3].r_offset = r[2].r_offset + 4;
10540                       r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10541                       r[3].r_addend = r[0].r_addend + 16;
10542                     }
10543                 }
10544             }
10545         }
10546       if (ALWAYS_EMIT_R2SAVE
10547           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10548         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10549       if (plt_load_toc)
10550         {
10551           bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10552           bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p),  p += 4;
10553         }
10554       else
10555         {
10556           bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
10557           bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p),  p += 4;
10558         }
10559       if (plt_load_toc
10560           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10561         {
10562           bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10563           offset = 0;
10564         }
10565       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10566       if (plt_load_toc)
10567         {
10568           if (use_fake_dep)
10569             {
10570               bfd_put_32 (obfd, XOR_R2_R12_R12, p),             p += 4;
10571               bfd_put_32 (obfd, ADD_R11_R11_R2, p),             p += 4;
10572             }
10573           bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10574           if (plt_static_chain)
10575             bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10576         }
10577     }
10578   else
10579     {
10580       if (r != NULL)
10581         {
10582           if (ALWAYS_EMIT_R2SAVE
10583               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10584             r[0].r_offset += 4;
10585           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10586           if (plt_load_toc)
10587             {
10588               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10589                 {
10590                   r[1].r_offset = r[0].r_offset + 4;
10591                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10592                   r[1].r_addend = r[0].r_addend;
10593                 }
10594               else
10595                 {
10596                   r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10597                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10598                   r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10599                   if (plt_static_chain)
10600                     {
10601                       r[2].r_offset = r[1].r_offset + 4;
10602                       r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10603                       r[2].r_addend = r[0].r_addend + 8;
10604                     }
10605                 }
10606             }
10607         }
10608       if (ALWAYS_EMIT_R2SAVE
10609           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10610         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10611       bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p),       p += 4;
10612       if (plt_load_toc
10613           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10614         {
10615           bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),   p += 4;
10616           offset = 0;
10617         }
10618       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10619       if (plt_load_toc)
10620         {
10621           if (use_fake_dep)
10622             {
10623               bfd_put_32 (obfd, XOR_R11_R12_R12, p),            p += 4;
10624               bfd_put_32 (obfd, ADD_R2_R2_R11, p),              p += 4;
10625             }
10626           if (plt_static_chain)
10627             bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10628           bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10629         }
10630     }
10631   if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10632     {
10633       bfd_put_32 (obfd, CMPLDI_R2_0, p),                        p += 4;
10634       bfd_put_32 (obfd, BNECTR_P4, p),                          p += 4;
10635       bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10636     }
10637   else
10638     bfd_put_32 (obfd, BCTR, p),                                 p += 4;
10639   return p;
10640 }
10641
10642 /* Build a special .plt call stub for __tls_get_addr.  */
10643
10644 #define LD_R11_0R3      0xe9630000
10645 #define LD_R12_0R3      0xe9830000
10646 #define MR_R0_R3        0x7c601b78
10647 #define CMPDI_R11_0     0x2c2b0000
10648 #define ADD_R3_R12_R13  0x7c6c6a14
10649 #define BEQLR           0x4d820020
10650 #define MR_R3_R0        0x7c030378
10651 #define STD_R11_0R1     0xf9610000
10652 #define BCTRL           0x4e800421
10653 #define LD_R11_0R1      0xe9610000
10654 #define MTLR_R11        0x7d6803a6
10655
10656 static inline bfd_byte *
10657 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10658                          struct ppc_stub_hash_entry *stub_entry,
10659                          bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10660 {
10661   bfd *obfd = htab->params->stub_bfd;
10662
10663   bfd_put_32 (obfd, LD_R11_0R3 + 0, p),         p += 4;
10664   bfd_put_32 (obfd, LD_R12_0R3 + 8, p),         p += 4;
10665   bfd_put_32 (obfd, MR_R0_R3, p),               p += 4;
10666   bfd_put_32 (obfd, CMPDI_R11_0, p),            p += 4;
10667   bfd_put_32 (obfd, ADD_R3_R12_R13, p),         p += 4;
10668   bfd_put_32 (obfd, BEQLR, p),                  p += 4;
10669   bfd_put_32 (obfd, MR_R3_R0, p),               p += 4;
10670   bfd_put_32 (obfd, MFLR_R11, p),               p += 4;
10671   bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10672
10673   if (r != NULL)
10674     r[0].r_offset += 9 * 4;
10675   p = build_plt_stub (htab, stub_entry, p, offset, r);
10676   bfd_put_32 (obfd, BCTRL, p - 4);
10677
10678   bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p),     p += 4;
10679   bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10680   bfd_put_32 (obfd, MTLR_R11, p),               p += 4;
10681   bfd_put_32 (obfd, BLR, p),                    p += 4;
10682
10683   return p;
10684 }
10685
10686 static Elf_Internal_Rela *
10687 get_relocs (asection *sec, int count)
10688 {
10689   Elf_Internal_Rela *relocs;
10690   struct bfd_elf_section_data *elfsec_data;
10691
10692   elfsec_data = elf_section_data (sec);
10693   relocs = elfsec_data->relocs;
10694   if (relocs == NULL)
10695     {
10696       bfd_size_type relsize;
10697       relsize = sec->reloc_count * sizeof (*relocs);
10698       relocs = bfd_alloc (sec->owner, relsize);
10699       if (relocs == NULL)
10700         return NULL;
10701       elfsec_data->relocs = relocs;
10702       elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10703                                           sizeof (Elf_Internal_Shdr));
10704       if (elfsec_data->rela.hdr == NULL)
10705         return NULL;
10706       elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10707                                         * sizeof (Elf64_External_Rela));
10708       elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10709       sec->reloc_count = 0;
10710     }
10711   relocs += sec->reloc_count;
10712   sec->reloc_count += count;
10713   return relocs;
10714 }
10715
10716 static bfd_vma
10717 get_r2off (struct bfd_link_info *info,
10718            struct ppc_stub_hash_entry *stub_entry)
10719 {
10720   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10721   bfd_vma r2off = htab->sec_info[stub_entry->target_section->id].toc_off;
10722
10723   if (r2off == 0)
10724     {
10725       /* Support linking -R objects.  Get the toc pointer from the
10726          opd entry.  */
10727       char buf[8];
10728       if (!htab->opd_abi)
10729         return r2off;
10730       asection *opd = stub_entry->h->elf.root.u.def.section;
10731       bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10732
10733       if (strcmp (opd->name, ".opd") != 0
10734           || opd->reloc_count != 0)
10735         {
10736           info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
10737                                   stub_entry->h->elf.root.root.string);
10738           bfd_set_error (bfd_error_bad_value);
10739           return (bfd_vma) -1;
10740         }
10741       if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10742         return (bfd_vma) -1;
10743       r2off = bfd_get_64 (opd->owner, buf);
10744       r2off -= elf_gp (info->output_bfd);
10745     }
10746   r2off -= htab->sec_info[stub_entry->group->link_sec->id].toc_off;
10747   return r2off;
10748 }
10749
10750 static bfd_boolean
10751 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10752 {
10753   struct ppc_stub_hash_entry *stub_entry;
10754   struct ppc_branch_hash_entry *br_entry;
10755   struct bfd_link_info *info;
10756   struct ppc_link_hash_table *htab;
10757   bfd_byte *loc;
10758   bfd_byte *p;
10759   bfd_vma dest, off;
10760   int size;
10761   Elf_Internal_Rela *r;
10762   asection *plt;
10763
10764   /* Massage our args to the form they really have.  */
10765   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10766   info = in_arg;
10767
10768   htab = ppc_hash_table (info);
10769   if (htab == NULL)
10770     return FALSE;
10771
10772   /* Make a note of the offset within the stubs for this entry.  */
10773   stub_entry->stub_offset = stub_entry->group->stub_sec->size;
10774   loc = stub_entry->group->stub_sec->contents + stub_entry->stub_offset;
10775
10776   htab->stub_count[stub_entry->stub_type - 1] += 1;
10777   switch (stub_entry->stub_type)
10778     {
10779     case ppc_stub_long_branch:
10780     case ppc_stub_long_branch_r2off:
10781       /* Branches are relative.  This is where we are going to.  */
10782       dest = (stub_entry->target_value
10783               + stub_entry->target_section->output_offset
10784               + stub_entry->target_section->output_section->vma);
10785       dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10786       off = dest;
10787
10788       /* And this is where we are coming from.  */
10789       off -= (stub_entry->stub_offset
10790               + stub_entry->group->stub_sec->output_offset
10791               + stub_entry->group->stub_sec->output_section->vma);
10792
10793       size = 4;
10794       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10795         {
10796           bfd_vma r2off = get_r2off (info, stub_entry);
10797
10798           if (r2off == (bfd_vma) -1)
10799             {
10800               htab->stub_error = TRUE;
10801               return FALSE;
10802             }
10803           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10804           loc += 4;
10805           size = 8;
10806           if (PPC_HA (r2off) != 0)
10807             {
10808               bfd_put_32 (htab->params->stub_bfd,
10809                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
10810               loc += 4;
10811               size += 4;
10812             }
10813           if (PPC_LO (r2off) != 0)
10814             {
10815               bfd_put_32 (htab->params->stub_bfd,
10816                           ADDI_R2_R2 | PPC_LO (r2off), loc);
10817               loc += 4;
10818               size += 4;
10819             }
10820           off -= size - 4;
10821         }
10822       bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10823
10824       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10825         {
10826           info->callbacks->einfo
10827             (_("%P: long branch stub `%s' offset overflow\n"),
10828              stub_entry->root.string);
10829           htab->stub_error = TRUE;
10830           return FALSE;
10831         }
10832
10833       if (info->emitrelocations)
10834         {
10835           r = get_relocs (stub_entry->group->stub_sec, 1);
10836           if (r == NULL)
10837             return FALSE;
10838           r->r_offset = loc - stub_entry->group->stub_sec->contents;
10839           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10840           r->r_addend = dest;
10841           if (stub_entry->h != NULL)
10842             {
10843               struct elf_link_hash_entry **hashes;
10844               unsigned long symndx;
10845               struct ppc_link_hash_entry *h;
10846
10847               hashes = elf_sym_hashes (htab->params->stub_bfd);
10848               if (hashes == NULL)
10849                 {
10850                   bfd_size_type hsize;
10851
10852                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10853                   hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
10854                   if (hashes == NULL)
10855                     return FALSE;
10856                   elf_sym_hashes (htab->params->stub_bfd) = hashes;
10857                   htab->stub_globals = 1;
10858                 }
10859               symndx = htab->stub_globals++;
10860               h = stub_entry->h;
10861               hashes[symndx] = &h->elf;
10862               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10863               if (h->oh != NULL && h->oh->is_func)
10864                 h = ppc_follow_link (h->oh);
10865               if (h->elf.root.u.def.section != stub_entry->target_section)
10866                 /* H is an opd symbol.  The addend must be zero.  */
10867                 r->r_addend = 0;
10868               else
10869                 {
10870                   off = (h->elf.root.u.def.value
10871                          + h->elf.root.u.def.section->output_offset
10872                          + h->elf.root.u.def.section->output_section->vma);
10873                   r->r_addend -= off;
10874                 }
10875             }
10876         }
10877       break;
10878
10879     case ppc_stub_plt_branch:
10880     case ppc_stub_plt_branch_r2off:
10881       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10882                                          stub_entry->root.string + 9,
10883                                          FALSE, FALSE);
10884       if (br_entry == NULL)
10885         {
10886           info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
10887                                   stub_entry->root.string);
10888           htab->stub_error = TRUE;
10889           return FALSE;
10890         }
10891
10892       dest = (stub_entry->target_value
10893               + stub_entry->target_section->output_offset
10894               + stub_entry->target_section->output_section->vma);
10895       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10896         dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10897
10898       bfd_put_64 (htab->brlt->owner, dest,
10899                   htab->brlt->contents + br_entry->offset);
10900
10901       if (br_entry->iter == htab->stub_iteration)
10902         {
10903           br_entry->iter = 0;
10904
10905           if (htab->relbrlt != NULL)
10906             {
10907               /* Create a reloc for the branch lookup table entry.  */
10908               Elf_Internal_Rela rela;
10909               bfd_byte *rl;
10910
10911               rela.r_offset = (br_entry->offset
10912                                + htab->brlt->output_offset
10913                                + htab->brlt->output_section->vma);
10914               rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10915               rela.r_addend = dest;
10916
10917               rl = htab->relbrlt->contents;
10918               rl += (htab->relbrlt->reloc_count++
10919                      * sizeof (Elf64_External_Rela));
10920               bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
10921             }
10922           else if (info->emitrelocations)
10923             {
10924               r = get_relocs (htab->brlt, 1);
10925               if (r == NULL)
10926                 return FALSE;
10927               /* brlt, being SEC_LINKER_CREATED does not go through the
10928                  normal reloc processing.  Symbols and offsets are not
10929                  translated from input file to output file form, so
10930                  set up the offset per the output file.  */
10931               r->r_offset = (br_entry->offset
10932                              + htab->brlt->output_offset
10933                              + htab->brlt->output_section->vma);
10934               r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10935               r->r_addend = dest;
10936             }
10937         }
10938
10939       dest = (br_entry->offset
10940               + htab->brlt->output_offset
10941               + htab->brlt->output_section->vma);
10942
10943       off = (dest
10944              - elf_gp (htab->brlt->output_section->owner)
10945              - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
10946
10947       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10948         {
10949           info->callbacks->einfo
10950             (_("%P: linkage table error against `%T'\n"),
10951              stub_entry->root.string);
10952           bfd_set_error (bfd_error_bad_value);
10953           htab->stub_error = TRUE;
10954           return FALSE;
10955         }
10956
10957       if (info->emitrelocations)
10958         {
10959           r = get_relocs (stub_entry->group->stub_sec, 1 + (PPC_HA (off) != 0));
10960           if (r == NULL)
10961             return FALSE;
10962           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
10963           if (bfd_big_endian (info->output_bfd))
10964             r[0].r_offset += 2;
10965           if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
10966             r[0].r_offset += 4;
10967           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10968           r[0].r_addend = dest;
10969           if (PPC_HA (off) != 0)
10970             {
10971               r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10972               r[1].r_offset = r[0].r_offset + 4;
10973               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10974               r[1].r_addend = r[0].r_addend;
10975             }
10976         }
10977
10978       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10979         {
10980           if (PPC_HA (off) != 0)
10981             {
10982               size = 16;
10983               bfd_put_32 (htab->params->stub_bfd,
10984                           ADDIS_R12_R2 | PPC_HA (off), loc);
10985               loc += 4;
10986               bfd_put_32 (htab->params->stub_bfd,
10987                           LD_R12_0R12 | PPC_LO (off), loc);
10988             }
10989           else
10990             {
10991               size = 12;
10992               bfd_put_32 (htab->params->stub_bfd,
10993                           LD_R12_0R2 | PPC_LO (off), loc);
10994             }
10995         }
10996       else
10997         {
10998           bfd_vma r2off = get_r2off (info, stub_entry);
10999
11000           if (r2off == (bfd_vma) -1)
11001             {
11002               htab->stub_error = TRUE;
11003               return FALSE;
11004             }
11005
11006           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
11007           loc += 4;
11008           size = 16;
11009           if (PPC_HA (off) != 0)
11010             {
11011               size += 4;
11012               bfd_put_32 (htab->params->stub_bfd,
11013                           ADDIS_R12_R2 | PPC_HA (off), loc);
11014               loc += 4;
11015               bfd_put_32 (htab->params->stub_bfd,
11016                           LD_R12_0R12 | PPC_LO (off), loc);
11017             }
11018           else
11019             bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
11020
11021           if (PPC_HA (r2off) != 0)
11022             {
11023               size += 4;
11024               loc += 4;
11025               bfd_put_32 (htab->params->stub_bfd,
11026                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
11027             }
11028           if (PPC_LO (r2off) != 0)
11029             {
11030               size += 4;
11031               loc += 4;
11032               bfd_put_32 (htab->params->stub_bfd,
11033                           ADDI_R2_R2 | PPC_LO (r2off), loc);
11034             }
11035         }
11036       loc += 4;
11037       bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, loc);
11038       loc += 4;
11039       bfd_put_32 (htab->params->stub_bfd, BCTR, loc);
11040       break;
11041
11042     case ppc_stub_plt_call:
11043     case ppc_stub_plt_call_r2save:
11044       if (stub_entry->h != NULL
11045           && stub_entry->h->is_func_descriptor
11046           && stub_entry->h->oh != NULL)
11047         {
11048           struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
11049
11050           /* If the old-ABI "dot-symbol" is undefined make it weak so
11051              we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.  */
11052           if (fh->elf.root.type == bfd_link_hash_undefined)
11053             fh->elf.root.type = bfd_link_hash_undefweak;
11054           /* Stop undo_symbol_twiddle changing it back to undefined.  */
11055           fh->was_undefined = 0;
11056         }
11057
11058       /* Now build the stub.  */
11059       dest = stub_entry->plt_ent->plt.offset & ~1;
11060       if (dest >= (bfd_vma) -2)
11061         abort ();
11062
11063       plt = htab->elf.splt;
11064       if (!htab->elf.dynamic_sections_created
11065           || stub_entry->h == NULL
11066           || stub_entry->h->elf.dynindx == -1)
11067         plt = htab->elf.iplt;
11068
11069       dest += plt->output_offset + plt->output_section->vma;
11070
11071       if (stub_entry->h == NULL
11072           && (stub_entry->plt_ent->plt.offset & 1) == 0)
11073         {
11074           Elf_Internal_Rela rela;
11075           bfd_byte *rl;
11076
11077           rela.r_offset = dest;
11078           if (htab->opd_abi)
11079             rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
11080           else
11081             rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
11082           rela.r_addend = (stub_entry->target_value
11083                            + stub_entry->target_section->output_offset
11084                            + stub_entry->target_section->output_section->vma);
11085
11086           rl = (htab->elf.irelplt->contents
11087                 + (htab->elf.irelplt->reloc_count++
11088                    * sizeof (Elf64_External_Rela)));
11089           bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
11090           stub_entry->plt_ent->plt.offset |= 1;
11091         }
11092
11093       off = (dest
11094              - elf_gp (plt->output_section->owner)
11095              - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11096
11097       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11098         {
11099           info->callbacks->einfo
11100             (_("%P: linkage table error against `%T'\n"),
11101              stub_entry->h != NULL
11102              ? stub_entry->h->elf.root.root.string
11103              : "<local sym>");
11104           bfd_set_error (bfd_error_bad_value);
11105           htab->stub_error = TRUE;
11106           return FALSE;
11107         }
11108
11109       if (htab->params->plt_stub_align != 0)
11110         {
11111           unsigned pad = plt_stub_pad (htab, stub_entry, off);
11112
11113           stub_entry->group->stub_sec->size += pad;
11114           stub_entry->stub_offset = stub_entry->group->stub_sec->size;
11115           loc += pad;
11116         }
11117
11118       r = NULL;
11119       if (info->emitrelocations)
11120         {
11121           r = get_relocs (stub_entry->group->stub_sec,
11122                           ((PPC_HA (off) != 0)
11123                            + (htab->opd_abi
11124                               ? 2 + (htab->params->plt_static_chain
11125                                      && PPC_HA (off + 16) == PPC_HA (off))
11126                               : 1)));
11127           if (r == NULL)
11128             return FALSE;
11129           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11130           if (bfd_big_endian (info->output_bfd))
11131             r[0].r_offset += 2;
11132           r[0].r_addend = dest;
11133         }
11134       if (stub_entry->h != NULL
11135           && (stub_entry->h == htab->tls_get_addr_fd
11136               || stub_entry->h == htab->tls_get_addr)
11137           && htab->params->tls_get_addr_opt)
11138         p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
11139       else
11140         p = build_plt_stub (htab, stub_entry, loc, off, r);
11141       size = p - loc;
11142       break;
11143
11144     case ppc_stub_save_res:
11145       return TRUE;
11146
11147     default:
11148       BFD_FAIL ();
11149       return FALSE;
11150     }
11151
11152   stub_entry->group->stub_sec->size += size;
11153
11154   if (htab->params->emit_stub_syms)
11155     {
11156       struct elf_link_hash_entry *h;
11157       size_t len1, len2;
11158       char *name;
11159       const char *const stub_str[] = { "long_branch",
11160                                        "long_branch_r2off",
11161                                        "plt_branch",
11162                                        "plt_branch_r2off",
11163                                        "plt_call",
11164                                        "plt_call" };
11165
11166       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
11167       len2 = strlen (stub_entry->root.string);
11168       name = bfd_malloc (len1 + len2 + 2);
11169       if (name == NULL)
11170         return FALSE;
11171       memcpy (name, stub_entry->root.string, 9);
11172       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
11173       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
11174       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
11175       if (h == NULL)
11176         return FALSE;
11177       if (h->root.type == bfd_link_hash_new)
11178         {
11179           h->root.type = bfd_link_hash_defined;
11180           h->root.u.def.section = stub_entry->group->stub_sec;
11181           h->root.u.def.value = stub_entry->stub_offset;
11182           h->ref_regular = 1;
11183           h->def_regular = 1;
11184           h->ref_regular_nonweak = 1;
11185           h->forced_local = 1;
11186           h->non_elf = 0;
11187           h->root.linker_def = 1;
11188         }
11189     }
11190
11191   return TRUE;
11192 }
11193
11194 /* As above, but don't actually build the stub.  Just bump offset so
11195    we know stub section sizes, and select plt_branch stubs where
11196    long_branch stubs won't do.  */
11197
11198 static bfd_boolean
11199 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11200 {
11201   struct ppc_stub_hash_entry *stub_entry;
11202   struct bfd_link_info *info;
11203   struct ppc_link_hash_table *htab;
11204   bfd_vma off;
11205   int size;
11206
11207   /* Massage our args to the form they really have.  */
11208   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11209   info = in_arg;
11210
11211   htab = ppc_hash_table (info);
11212   if (htab == NULL)
11213     return FALSE;
11214
11215   if (stub_entry->h != NULL
11216       && stub_entry->h->save_res
11217       && stub_entry->h->elf.root.type == bfd_link_hash_defined
11218       && stub_entry->h->elf.root.u.def.section == htab->sfpr)
11219     {
11220       /* Don't make stubs to out-of-line register save/restore
11221          functions.  Instead, emit copies of the functions.  */
11222       stub_entry->group->needs_save_res = 1;
11223       stub_entry->stub_type = ppc_stub_save_res;
11224       return TRUE;
11225     }
11226
11227   if (stub_entry->stub_type == ppc_stub_plt_call
11228       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11229     {
11230       asection *plt;
11231       off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
11232       if (off >= (bfd_vma) -2)
11233         abort ();
11234       plt = htab->elf.splt;
11235       if (!htab->elf.dynamic_sections_created
11236           || stub_entry->h == NULL
11237           || stub_entry->h->elf.dynindx == -1)
11238         plt = htab->elf.iplt;
11239       off += (plt->output_offset
11240               + plt->output_section->vma
11241               - elf_gp (plt->output_section->owner)
11242               - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11243
11244       size = plt_stub_size (htab, stub_entry, off);
11245       if (htab->params->plt_stub_align)
11246         size += plt_stub_pad (htab, stub_entry, off);
11247       if (info->emitrelocations)
11248         {
11249           stub_entry->group->stub_sec->reloc_count
11250             += ((PPC_HA (off) != 0)
11251                 + (htab->opd_abi
11252                    ? 2 + (htab->params->plt_static_chain
11253                           && PPC_HA (off + 16) == PPC_HA (off))
11254                    : 1));
11255           stub_entry->group->stub_sec->flags |= SEC_RELOC;
11256         }
11257     }
11258   else
11259     {
11260       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
11261          variants.  */
11262       bfd_vma r2off = 0;
11263       bfd_vma local_off = 0;
11264
11265       off = (stub_entry->target_value
11266              + stub_entry->target_section->output_offset
11267              + stub_entry->target_section->output_section->vma);
11268       off -= (stub_entry->group->stub_sec->size
11269               + stub_entry->group->stub_sec->output_offset
11270               + stub_entry->group->stub_sec->output_section->vma);
11271
11272       /* Reset the stub type from the plt variant in case we now
11273          can reach with a shorter stub.  */
11274       if (stub_entry->stub_type >= ppc_stub_plt_branch)
11275         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
11276
11277       size = 4;
11278       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11279         {
11280           r2off = get_r2off (info, stub_entry);
11281           if (r2off == (bfd_vma) -1)
11282             {
11283               htab->stub_error = TRUE;
11284               return FALSE;
11285             }
11286           size = 8;
11287           if (PPC_HA (r2off) != 0)
11288             size += 4;
11289           if (PPC_LO (r2off) != 0)
11290             size += 4;
11291           off -= size - 4;
11292         }
11293
11294       local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11295
11296       /* If the branch offset if too big, use a ppc_stub_plt_branch.
11297          Do the same for -R objects without function descriptors.  */
11298       if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
11299           || (stub_entry->stub_type == ppc_stub_long_branch_r2off
11300               && r2off == 0
11301               && htab->sec_info[stub_entry->target_section->id].toc_off == 0))
11302         {
11303           struct ppc_branch_hash_entry *br_entry;
11304
11305           br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11306                                              stub_entry->root.string + 9,
11307                                              TRUE, FALSE);
11308           if (br_entry == NULL)
11309             {
11310               info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
11311                                       stub_entry->root.string);
11312               htab->stub_error = TRUE;
11313               return FALSE;
11314             }
11315
11316           if (br_entry->iter != htab->stub_iteration)
11317             {
11318               br_entry->iter = htab->stub_iteration;
11319               br_entry->offset = htab->brlt->size;
11320               htab->brlt->size += 8;
11321
11322               if (htab->relbrlt != NULL)
11323                 htab->relbrlt->size += sizeof (Elf64_External_Rela);
11324               else if (info->emitrelocations)
11325                 {
11326                   htab->brlt->reloc_count += 1;
11327                   htab->brlt->flags |= SEC_RELOC;
11328                 }
11329             }
11330
11331           stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
11332           off = (br_entry->offset
11333                  + htab->brlt->output_offset
11334                  + htab->brlt->output_section->vma
11335                  - elf_gp (htab->brlt->output_section->owner)
11336                  - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11337
11338           if (info->emitrelocations)
11339             {
11340               stub_entry->group->stub_sec->reloc_count
11341                 += 1 + (PPC_HA (off) != 0);
11342               stub_entry->group->stub_sec->flags |= SEC_RELOC;
11343             }
11344
11345           if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11346             {
11347               size = 12;
11348               if (PPC_HA (off) != 0)
11349                 size = 16;
11350             }
11351           else
11352             {
11353               size = 16;
11354               if (PPC_HA (off) != 0)
11355                 size += 4;
11356
11357               if (PPC_HA (r2off) != 0)
11358                 size += 4;
11359               if (PPC_LO (r2off) != 0)
11360                 size += 4;
11361             }
11362         }
11363       else if (info->emitrelocations)
11364         {
11365           stub_entry->group->stub_sec->reloc_count += 1;
11366           stub_entry->group->stub_sec->flags |= SEC_RELOC;
11367         }
11368     }
11369
11370   stub_entry->group->stub_sec->size += size;
11371   return TRUE;
11372 }
11373
11374 /* Set up various things so that we can make a list of input sections
11375    for each output section included in the link.  Returns -1 on error,
11376    0 when no stubs will be needed, and 1 on success.  */
11377
11378 int
11379 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
11380 {
11381   unsigned int id;
11382   bfd_size_type amt;
11383   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11384
11385   if (htab == NULL)
11386     return -1;
11387
11388   htab->sec_info_arr_size = bfd_get_next_section_id ();
11389   amt = sizeof (*htab->sec_info) * (htab->sec_info_arr_size);
11390   htab->sec_info = bfd_zmalloc (amt);
11391   if (htab->sec_info == NULL)
11392     return -1;
11393
11394   /* Set toc_off for com, und, abs and ind sections.  */
11395   for (id = 0; id < 3; id++)
11396     htab->sec_info[id].toc_off = TOC_BASE_OFF;
11397
11398   return 1;
11399 }
11400
11401 /* Set up for first pass at multitoc partitioning.  */
11402
11403 void
11404 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11405 {
11406   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11407
11408   htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11409   htab->toc_bfd = NULL;
11410   htab->toc_first_sec = NULL;
11411 }
11412
11413 /* The linker repeatedly calls this function for each TOC input section
11414    and linker generated GOT section.  Group input bfds such that the toc
11415    within a group is less than 64k in size.  */
11416
11417 bfd_boolean
11418 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11419 {
11420   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11421   bfd_vma addr, off, limit;
11422
11423   if (htab == NULL)
11424     return FALSE;
11425
11426   if (!htab->second_toc_pass)
11427     {
11428       /* Keep track of the first .toc or .got section for this input bfd.  */
11429       bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11430
11431       if (new_bfd)
11432         {
11433           htab->toc_bfd = isec->owner;
11434           htab->toc_first_sec = isec;
11435         }
11436
11437       addr = isec->output_offset + isec->output_section->vma;
11438       off = addr - htab->toc_curr;
11439       limit = 0x80008000;
11440       if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11441         limit = 0x10000;
11442       if (off + isec->size > limit)
11443         {
11444           addr = (htab->toc_first_sec->output_offset
11445                   + htab->toc_first_sec->output_section->vma);
11446           htab->toc_curr = addr;
11447           htab->toc_curr &= -TOC_BASE_ALIGN;
11448         }
11449
11450       /* toc_curr is the base address of this toc group.  Set elf_gp
11451          for the input section to be the offset relative to the
11452          output toc base plus 0x8000.  Making the input elf_gp an
11453          offset allows us to move the toc as a whole without
11454          recalculating input elf_gp.  */
11455       off = htab->toc_curr - elf_gp (isec->output_section->owner);
11456       off += TOC_BASE_OFF;
11457
11458       /* Die if someone uses a linker script that doesn't keep input
11459          file .toc and .got together.  */
11460       if (new_bfd
11461           && elf_gp (isec->owner) != 0
11462           && elf_gp (isec->owner) != off)
11463         return FALSE;
11464
11465       elf_gp (isec->owner) = off;
11466       return TRUE;
11467     }
11468
11469   /* During the second pass toc_first_sec points to the start of
11470      a toc group, and toc_curr is used to track the old elf_gp.
11471      We use toc_bfd to ensure we only look at each bfd once.  */
11472   if (htab->toc_bfd == isec->owner)
11473     return TRUE;
11474   htab->toc_bfd = isec->owner;
11475
11476   if (htab->toc_first_sec == NULL
11477       || htab->toc_curr != elf_gp (isec->owner))
11478     {
11479       htab->toc_curr = elf_gp (isec->owner);
11480       htab->toc_first_sec = isec;
11481     }
11482   addr = (htab->toc_first_sec->output_offset
11483           + htab->toc_first_sec->output_section->vma);
11484   off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
11485   elf_gp (isec->owner) = off;
11486
11487   return TRUE;
11488 }
11489
11490 /* Called via elf_link_hash_traverse to merge GOT entries for global
11491    symbol H.  */
11492
11493 static bfd_boolean
11494 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11495 {
11496   if (h->root.type == bfd_link_hash_indirect)
11497     return TRUE;
11498
11499   merge_got_entries (&h->got.glist);
11500
11501   return TRUE;
11502 }
11503
11504 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11505    symbol H.  */
11506
11507 static bfd_boolean
11508 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11509 {
11510   struct got_entry *gent;
11511
11512   if (h->root.type == bfd_link_hash_indirect)
11513     return TRUE;
11514
11515   for (gent = h->got.glist; gent != NULL; gent = gent->next)
11516     if (!gent->is_indirect)
11517       allocate_got (h, (struct bfd_link_info *) inf, gent);
11518   return TRUE;
11519 }
11520
11521 /* Called on the first multitoc pass after the last call to
11522    ppc64_elf_next_toc_section.  This function removes duplicate GOT
11523    entries.  */
11524
11525 bfd_boolean
11526 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11527 {
11528   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11529   struct bfd *ibfd, *ibfd2;
11530   bfd_boolean done_something;
11531
11532   htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11533
11534   if (!htab->do_multi_toc)
11535     return FALSE;
11536
11537   /* Merge global sym got entries within a toc group.  */
11538   elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11539
11540   /* And tlsld_got.  */
11541   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11542     {
11543       struct got_entry *ent, *ent2;
11544
11545       if (!is_ppc64_elf (ibfd))
11546         continue;
11547
11548       ent = ppc64_tlsld_got (ibfd);
11549       if (!ent->is_indirect
11550           && ent->got.offset != (bfd_vma) -1)
11551         {
11552           for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
11553             {
11554               if (!is_ppc64_elf (ibfd2))
11555                 continue;
11556
11557               ent2 = ppc64_tlsld_got (ibfd2);
11558               if (!ent2->is_indirect
11559                   && ent2->got.offset != (bfd_vma) -1
11560                   && elf_gp (ibfd2) == elf_gp (ibfd))
11561                 {
11562                   ent2->is_indirect = TRUE;
11563                   ent2->got.ent = ent;
11564                 }
11565             }
11566         }
11567     }
11568
11569   /* Zap sizes of got sections.  */
11570   htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11571   htab->elf.irelplt->size -= htab->got_reli_size;
11572   htab->got_reli_size = 0;
11573
11574   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11575     {
11576       asection *got, *relgot;
11577
11578       if (!is_ppc64_elf (ibfd))
11579         continue;
11580
11581       got = ppc64_elf_tdata (ibfd)->got;
11582       if (got != NULL)
11583         {
11584           got->rawsize = got->size;
11585           got->size = 0;
11586           relgot = ppc64_elf_tdata (ibfd)->relgot;
11587           relgot->rawsize = relgot->size;
11588           relgot->size = 0;
11589         }
11590     }
11591
11592   /* Now reallocate the got, local syms first.  We don't need to
11593      allocate section contents again since we never increase size.  */
11594   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11595     {
11596       struct got_entry **lgot_ents;
11597       struct got_entry **end_lgot_ents;
11598       struct plt_entry **local_plt;
11599       struct plt_entry **end_local_plt;
11600       unsigned char *lgot_masks;
11601       bfd_size_type locsymcount;
11602       Elf_Internal_Shdr *symtab_hdr;
11603       asection *s;
11604
11605       if (!is_ppc64_elf (ibfd))
11606         continue;
11607
11608       lgot_ents = elf_local_got_ents (ibfd);
11609       if (!lgot_ents)
11610         continue;
11611
11612       symtab_hdr = &elf_symtab_hdr (ibfd);
11613       locsymcount = symtab_hdr->sh_info;
11614       end_lgot_ents = lgot_ents + locsymcount;
11615       local_plt = (struct plt_entry **) end_lgot_ents;
11616       end_local_plt = local_plt + locsymcount;
11617       lgot_masks = (unsigned char *) end_local_plt;
11618       s = ppc64_elf_tdata (ibfd)->got;
11619       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11620         {
11621           struct got_entry *ent;
11622
11623           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11624             {
11625               unsigned int ent_size = 8;
11626               unsigned int rel_size = sizeof (Elf64_External_Rela);
11627
11628               ent->got.offset = s->size;
11629               if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11630                 {
11631                   ent_size *= 2;
11632                   rel_size *= 2;
11633                 }
11634               s->size += ent_size;
11635               if ((*lgot_masks & PLT_IFUNC) != 0)
11636                 {
11637                   htab->elf.irelplt->size += rel_size;
11638                   htab->got_reli_size += rel_size;
11639                 }
11640               else if (bfd_link_pic (info))
11641                 {
11642                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11643                   srel->size += rel_size;
11644                 }
11645             }
11646         }
11647     }
11648
11649   elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11650
11651   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11652     {
11653       struct got_entry *ent;
11654
11655       if (!is_ppc64_elf (ibfd))
11656         continue;
11657
11658       ent = ppc64_tlsld_got (ibfd);
11659       if (!ent->is_indirect
11660           && ent->got.offset != (bfd_vma) -1)
11661         {
11662           asection *s = ppc64_elf_tdata (ibfd)->got;
11663           ent->got.offset = s->size;
11664           s->size += 16;
11665           if (bfd_link_pic (info))
11666             {
11667               asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11668               srel->size += sizeof (Elf64_External_Rela);
11669             }
11670         }
11671     }
11672
11673   done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11674   if (!done_something)
11675     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11676       {
11677         asection *got;
11678
11679         if (!is_ppc64_elf (ibfd))
11680           continue;
11681
11682         got = ppc64_elf_tdata (ibfd)->got;
11683         if (got != NULL)
11684           {
11685             done_something = got->rawsize != got->size;
11686             if (done_something)
11687               break;
11688           }
11689       }
11690
11691   if (done_something)
11692     (*htab->params->layout_sections_again) ();
11693
11694   /* Set up for second pass over toc sections to recalculate elf_gp
11695      on input sections.  */
11696   htab->toc_bfd = NULL;
11697   htab->toc_first_sec = NULL;
11698   htab->second_toc_pass = TRUE;
11699   return done_something;
11700 }
11701
11702 /* Called after second pass of multitoc partitioning.  */
11703
11704 void
11705 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11706 {
11707   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11708
11709   /* After the second pass, toc_curr tracks the TOC offset used
11710      for code sections below in ppc64_elf_next_input_section.  */
11711   htab->toc_curr = TOC_BASE_OFF;
11712 }
11713
11714 /* No toc references were found in ISEC.  If the code in ISEC makes no
11715    calls, then there's no need to use toc adjusting stubs when branching
11716    into ISEC.  Actually, indirect calls from ISEC are OK as they will
11717    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
11718    needed, and 2 if a cyclical call-graph was found but no other reason
11719    for a stub was detected.  If called from the top level, a return of
11720    2 means the same as a return of 0.  */
11721
11722 static int
11723 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11724 {
11725   int ret;
11726
11727   /* Mark this section as checked.  */
11728   isec->call_check_done = 1;
11729
11730   /* We know none of our code bearing sections will need toc stubs.  */
11731   if ((isec->flags & SEC_LINKER_CREATED) != 0)
11732     return 0;
11733
11734   if (isec->size == 0)
11735     return 0;
11736
11737   if (isec->output_section == NULL)
11738     return 0;
11739
11740   ret = 0;
11741   if (isec->reloc_count != 0)
11742     {
11743       Elf_Internal_Rela *relstart, *rel;
11744       Elf_Internal_Sym *local_syms;
11745       struct ppc_link_hash_table *htab;
11746
11747       relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11748                                             info->keep_memory);
11749       if (relstart == NULL)
11750         return -1;
11751
11752       /* Look for branches to outside of this section.  */
11753       local_syms = NULL;
11754       htab = ppc_hash_table (info);
11755       if (htab == NULL)
11756         return -1;
11757
11758       for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11759         {
11760           enum elf_ppc64_reloc_type r_type;
11761           unsigned long r_symndx;
11762           struct elf_link_hash_entry *h;
11763           struct ppc_link_hash_entry *eh;
11764           Elf_Internal_Sym *sym;
11765           asection *sym_sec;
11766           struct _opd_sec_data *opd;
11767           bfd_vma sym_value;
11768           bfd_vma dest;
11769
11770           r_type = ELF64_R_TYPE (rel->r_info);
11771           if (r_type != R_PPC64_REL24
11772               && r_type != R_PPC64_REL14
11773               && r_type != R_PPC64_REL14_BRTAKEN
11774               && r_type != R_PPC64_REL14_BRNTAKEN)
11775             continue;
11776
11777           r_symndx = ELF64_R_SYM (rel->r_info);
11778           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11779                           isec->owner))
11780             {
11781               ret = -1;
11782               break;
11783             }
11784
11785           /* Calls to dynamic lib functions go through a plt call stub
11786              that uses r2.  */
11787           eh = (struct ppc_link_hash_entry *) h;
11788           if (eh != NULL
11789               && (eh->elf.plt.plist != NULL
11790                   || (eh->oh != NULL
11791                       && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11792             {
11793               ret = 1;
11794               break;
11795             }
11796
11797           if (sym_sec == NULL)
11798             /* Ignore other undefined symbols.  */
11799             continue;
11800
11801           /* Assume branches to other sections not included in the
11802              link need stubs too, to cover -R and absolute syms.  */
11803           if (sym_sec->output_section == NULL)
11804             {
11805               ret = 1;
11806               break;
11807             }
11808
11809           if (h == NULL)
11810             sym_value = sym->st_value;
11811           else
11812             {
11813               if (h->root.type != bfd_link_hash_defined
11814                   && h->root.type != bfd_link_hash_defweak)
11815                 abort ();
11816               sym_value = h->root.u.def.value;
11817             }
11818           sym_value += rel->r_addend;
11819
11820           /* If this branch reloc uses an opd sym, find the code section.  */
11821           opd = get_opd_info (sym_sec);
11822           if (opd != NULL)
11823             {
11824               if (h == NULL && opd->adjust != NULL)
11825                 {
11826                   long adjust;
11827
11828                   adjust = opd->adjust[OPD_NDX (sym_value)];
11829                   if (adjust == -1)
11830                     /* Assume deleted functions won't ever be called.  */
11831                     continue;
11832                   sym_value += adjust;
11833                 }
11834
11835               dest = opd_entry_value (sym_sec, sym_value,
11836                                       &sym_sec, NULL, FALSE);
11837               if (dest == (bfd_vma) -1)
11838                 continue;
11839             }
11840           else
11841             dest = (sym_value
11842                     + sym_sec->output_offset
11843                     + sym_sec->output_section->vma);
11844
11845           /* Ignore branch to self.  */
11846           if (sym_sec == isec)
11847             continue;
11848
11849           /* If the called function uses the toc, we need a stub.  */
11850           if (sym_sec->has_toc_reloc
11851               || sym_sec->makes_toc_func_call)
11852             {
11853               ret = 1;
11854               break;
11855             }
11856
11857           /* Assume any branch that needs a long branch stub might in fact
11858              need a plt_branch stub.  A plt_branch stub uses r2.  */
11859           else if (dest - (isec->output_offset
11860                            + isec->output_section->vma
11861                            + rel->r_offset) + (1 << 25)
11862                    >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
11863                                                              ? h->other
11864                                                              : sym->st_other))
11865             {
11866               ret = 1;
11867               break;
11868             }
11869
11870           /* If calling back to a section in the process of being
11871              tested, we can't say for sure that no toc adjusting stubs
11872              are needed, so don't return zero.  */
11873           else if (sym_sec->call_check_in_progress)
11874             ret = 2;
11875
11876           /* Branches to another section that itself doesn't have any TOC
11877              references are OK.  Recursively call ourselves to check.  */
11878           else if (!sym_sec->call_check_done)
11879             {
11880               int recur;
11881
11882               /* Mark current section as indeterminate, so that other
11883                  sections that call back to current won't be marked as
11884                  known.  */
11885               isec->call_check_in_progress = 1;
11886               recur = toc_adjusting_stub_needed (info, sym_sec);
11887               isec->call_check_in_progress = 0;
11888
11889               if (recur != 0)
11890                 {
11891                   ret = recur;
11892                   if (recur != 2)
11893                     break;
11894                 }
11895             }
11896         }
11897
11898       if (local_syms != NULL
11899           && (elf_symtab_hdr (isec->owner).contents
11900               != (unsigned char *) local_syms))
11901         free (local_syms);
11902       if (elf_section_data (isec)->relocs != relstart)
11903         free (relstart);
11904     }
11905
11906   if ((ret & 1) == 0
11907       && isec->map_head.s != NULL
11908       && (strcmp (isec->output_section->name, ".init") == 0
11909           || strcmp (isec->output_section->name, ".fini") == 0))
11910     {
11911       if (isec->map_head.s->has_toc_reloc
11912           || isec->map_head.s->makes_toc_func_call)
11913         ret = 1;
11914       else if (!isec->map_head.s->call_check_done)
11915         {
11916           int recur;
11917           isec->call_check_in_progress = 1;
11918           recur = toc_adjusting_stub_needed (info, isec->map_head.s);
11919           isec->call_check_in_progress = 0;
11920           if (recur != 0)
11921             ret = recur;
11922         }
11923     }
11924
11925   if (ret == 1)
11926     isec->makes_toc_func_call = 1;
11927
11928   return ret;
11929 }
11930
11931 /* The linker repeatedly calls this function for each input section,
11932    in the order that input sections are linked into output sections.
11933    Build lists of input sections to determine groupings between which
11934    we may insert linker stubs.  */
11935
11936 bfd_boolean
11937 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
11938 {
11939   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11940
11941   if (htab == NULL)
11942     return FALSE;
11943
11944   if ((isec->output_section->flags & SEC_CODE) != 0
11945       && isec->output_section->id < htab->sec_info_arr_size)
11946     {
11947       /* This happens to make the list in reverse order,
11948          which is what we want.  */
11949       htab->sec_info[isec->id].u.list
11950         = htab->sec_info[isec->output_section->id].u.list;
11951       htab->sec_info[isec->output_section->id].u.list = isec;
11952     }
11953
11954   if (htab->multi_toc_needed)
11955     {
11956       /* Analyse sections that aren't already flagged as needing a
11957          valid toc pointer.  Exclude .fixup for the linux kernel.
11958          .fixup contains branches, but only back to the function that
11959          hit an exception.  */
11960       if (!(isec->has_toc_reloc
11961             || (isec->flags & SEC_CODE) == 0
11962             || strcmp (isec->name, ".fixup") == 0
11963             || isec->call_check_done))
11964         {
11965           if (toc_adjusting_stub_needed (info, isec) < 0)
11966             return FALSE;
11967         }
11968       /* Make all sections use the TOC assigned for this object file.
11969          This will be wrong for pasted sections;  We fix that in
11970          check_pasted_section().  */
11971       if (elf_gp (isec->owner) != 0)
11972         htab->toc_curr = elf_gp (isec->owner);
11973     }
11974
11975   htab->sec_info[isec->id].toc_off = htab->toc_curr;
11976   return TRUE;
11977 }
11978
11979 /* Check that all .init and .fini sections use the same toc, if they
11980    have toc relocs.  */
11981
11982 static bfd_boolean
11983 check_pasted_section (struct bfd_link_info *info, const char *name)
11984 {
11985   asection *o = bfd_get_section_by_name (info->output_bfd, name);
11986
11987   if (o != NULL)
11988     {
11989       struct ppc_link_hash_table *htab = ppc_hash_table (info);
11990       bfd_vma toc_off = 0;
11991       asection *i;
11992
11993       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11994         if (i->has_toc_reloc)
11995           {
11996             if (toc_off == 0)
11997               toc_off = htab->sec_info[i->id].toc_off;
11998             else if (toc_off != htab->sec_info[i->id].toc_off)
11999               return FALSE;
12000           }
12001
12002       if (toc_off == 0)
12003         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12004           if (i->makes_toc_func_call)
12005             {
12006               toc_off = htab->sec_info[i->id].toc_off;
12007               break;
12008             }
12009
12010       /* Make sure the whole pasted function uses the same toc offset.  */
12011       if (toc_off != 0)
12012         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12013           htab->sec_info[i->id].toc_off = toc_off;
12014     }
12015   return TRUE;
12016 }
12017
12018 bfd_boolean
12019 ppc64_elf_check_init_fini (struct bfd_link_info *info)
12020 {
12021   return (check_pasted_section (info, ".init")
12022           & check_pasted_section (info, ".fini"));
12023 }
12024
12025 /* See whether we can group stub sections together.  Grouping stub
12026    sections may result in fewer stubs.  More importantly, we need to
12027    put all .init* and .fini* stubs at the beginning of the .init or
12028    .fini output sections respectively, because glibc splits the
12029    _init and _fini functions into multiple parts.  Putting a stub in
12030    the middle of a function is not a good idea.  */
12031
12032 static bfd_boolean
12033 group_sections (struct bfd_link_info *info,
12034                 bfd_size_type stub_group_size,
12035                 bfd_boolean stubs_always_before_branch)
12036 {
12037   struct ppc_link_hash_table *htab;
12038   asection *osec;
12039   bfd_size_type stub14_group_size;
12040   bfd_boolean suppress_size_errors;
12041
12042   htab = ppc_hash_table (info);
12043   if (htab == NULL)
12044     return FALSE;
12045
12046   suppress_size_errors = FALSE;
12047   stub14_group_size = stub_group_size >> 10;
12048   if (stub_group_size == 1)
12049     {
12050       /* Default values.  */
12051       if (stubs_always_before_branch)
12052         {
12053           stub_group_size = 0x1e00000;
12054           stub14_group_size = 0x7800;
12055         }
12056       else
12057         {
12058           stub_group_size = 0x1c00000;
12059           stub14_group_size = 0x7000;
12060         }
12061       suppress_size_errors = TRUE;
12062     }
12063
12064   for (osec = info->output_bfd->sections; osec != NULL; osec = osec->next)
12065     {
12066       asection *tail;
12067
12068       if (osec->id >= htab->sec_info_arr_size)
12069         continue;
12070
12071       tail = htab->sec_info[osec->id].u.list;
12072       while (tail != NULL)
12073         {
12074           asection *curr;
12075           asection *prev;
12076           bfd_size_type total;
12077           bfd_boolean big_sec;
12078           bfd_vma curr_toc;
12079           struct map_stub *group;
12080
12081           curr = tail;
12082           total = tail->size;
12083           big_sec = total > (ppc64_elf_section_data (tail) != NULL
12084                              && ppc64_elf_section_data (tail)->has_14bit_branch
12085                              ? stub14_group_size : stub_group_size);
12086           if (big_sec && !suppress_size_errors)
12087             (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
12088                                      tail->owner, tail);
12089           curr_toc = htab->sec_info[tail->id].toc_off;
12090
12091           while ((prev = htab->sec_info[curr->id].u.list) != NULL
12092                  && ((total += curr->output_offset - prev->output_offset)
12093                      < (ppc64_elf_section_data (prev) != NULL
12094                         && ppc64_elf_section_data (prev)->has_14bit_branch
12095                         ? stub14_group_size : stub_group_size))
12096                  && htab->sec_info[prev->id].toc_off == curr_toc)
12097             curr = prev;
12098
12099           /* OK, the size from the start of CURR to the end is less
12100              than stub_group_size and thus can be handled by one stub
12101              section.  (or the tail section is itself larger than
12102              stub_group_size, in which case we may be toast.)  We
12103              should really be keeping track of the total size of stubs
12104              added here, as stubs contribute to the final output
12105              section size.  That's a little tricky, and this way will
12106              only break if stubs added make the total size more than
12107              2^25, ie. for the default stub_group_size, if stubs total
12108              more than 2097152 bytes, or nearly 75000 plt call stubs.  */
12109           group = bfd_alloc (curr->owner, sizeof (*group));
12110           if (group == NULL)
12111             return FALSE;
12112           group->link_sec = curr;
12113           group->stub_sec = NULL;
12114           group->needs_save_res = 0;
12115           group->next = htab->group;
12116           htab->group = group;
12117           do
12118             {
12119               prev = htab->sec_info[tail->id].u.list;
12120               /* Set up this stub group.  */
12121               htab->sec_info[tail->id].u.group = group;
12122             }
12123           while (tail != curr && (tail = prev) != NULL);
12124
12125           /* But wait, there's more!  Input sections up to stub_group_size
12126              bytes before the stub section can be handled by it too.
12127              Don't do this if we have a really large section after the
12128              stubs, as adding more stubs increases the chance that
12129              branches may not reach into the stub section.  */
12130           if (!stubs_always_before_branch && !big_sec)
12131             {
12132               total = 0;
12133               while (prev != NULL
12134                      && ((total += tail->output_offset - prev->output_offset)
12135                          < (ppc64_elf_section_data (prev) != NULL
12136                             && ppc64_elf_section_data (prev)->has_14bit_branch
12137                             ? stub14_group_size : stub_group_size))
12138                      && htab->sec_info[prev->id].toc_off == curr_toc)
12139                 {
12140                   tail = prev;
12141                   prev = htab->sec_info[tail->id].u.list;
12142                   htab->sec_info[tail->id].u.group = group;
12143                 }
12144             }
12145           tail = prev;
12146         }
12147     }
12148   return TRUE;
12149 }
12150
12151 static const unsigned char glink_eh_frame_cie[] =
12152 {
12153   0, 0, 0, 16,                          /* length.  */
12154   0, 0, 0, 0,                           /* id.  */
12155   1,                                    /* CIE version.  */
12156   'z', 'R', 0,                          /* Augmentation string.  */
12157   4,                                    /* Code alignment.  */
12158   0x78,                                 /* Data alignment.  */
12159   65,                                   /* RA reg.  */
12160   1,                                    /* Augmentation size.  */
12161   DW_EH_PE_pcrel | DW_EH_PE_sdata4,     /* FDE encoding.  */
12162   DW_CFA_def_cfa, 1, 0,                 /* def_cfa: r1 offset 0.  */
12163   0, 0, 0, 0
12164 };
12165
12166 /* Stripping output sections is normally done before dynamic section
12167    symbols have been allocated.  This function is called later, and
12168    handles cases like htab->brlt which is mapped to its own output
12169    section.  */
12170
12171 static void
12172 maybe_strip_output (struct bfd_link_info *info, asection *isec)
12173 {
12174   if (isec->size == 0
12175       && isec->output_section->size == 0
12176       && !(isec->output_section->flags & SEC_KEEP)
12177       && !bfd_section_removed_from_list (info->output_bfd,
12178                                          isec->output_section)
12179       && elf_section_data (isec->output_section)->dynindx == 0)
12180     {
12181       isec->output_section->flags |= SEC_EXCLUDE;
12182       bfd_section_list_remove (info->output_bfd, isec->output_section);
12183       info->output_bfd->section_count--;
12184     }
12185 }
12186
12187 /* Determine and set the size of the stub section for a final link.
12188
12189    The basic idea here is to examine all the relocations looking for
12190    PC-relative calls to a target that is unreachable with a "bl"
12191    instruction.  */
12192
12193 bfd_boolean
12194 ppc64_elf_size_stubs (struct bfd_link_info *info)
12195 {
12196   bfd_size_type stub_group_size;
12197   bfd_boolean stubs_always_before_branch;
12198   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12199
12200   if (htab == NULL)
12201     return FALSE;
12202
12203   if (htab->params->plt_thread_safe == -1 && !bfd_link_executable (info))
12204     htab->params->plt_thread_safe = 1;
12205   if (!htab->opd_abi)
12206     htab->params->plt_thread_safe = 0;
12207   else if (htab->params->plt_thread_safe == -1)
12208     {
12209       static const char *const thread_starter[] =
12210         {
12211           "pthread_create",
12212           /* libstdc++ */
12213           "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
12214           /* librt */
12215           "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
12216           "mq_notify", "create_timer",
12217           /* libanl */
12218           "getaddrinfo_a",
12219           /* libgomp */
12220           "GOMP_parallel",
12221           "GOMP_parallel_start",
12222           "GOMP_parallel_loop_static",
12223           "GOMP_parallel_loop_static_start",
12224           "GOMP_parallel_loop_dynamic",
12225           "GOMP_parallel_loop_dynamic_start",
12226           "GOMP_parallel_loop_guided",
12227           "GOMP_parallel_loop_guided_start",
12228           "GOMP_parallel_loop_runtime",
12229           "GOMP_parallel_loop_runtime_start",
12230           "GOMP_parallel_sections",
12231           "GOMP_parallel_sections_start",
12232           /* libgo */
12233           "__go_go",
12234         };
12235       unsigned i;
12236
12237       for (i = 0; i < ARRAY_SIZE (thread_starter); i++)
12238         {
12239           struct elf_link_hash_entry *h;
12240           h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
12241                                     FALSE, FALSE, TRUE);
12242           htab->params->plt_thread_safe = h != NULL && h->ref_regular;
12243           if (htab->params->plt_thread_safe)
12244             break;
12245         }
12246     }
12247   stubs_always_before_branch = htab->params->group_size < 0;
12248   if (htab->params->group_size < 0)
12249     stub_group_size = -htab->params->group_size;
12250   else
12251     stub_group_size = htab->params->group_size;
12252
12253   if (!group_sections (info, stub_group_size, stubs_always_before_branch))
12254     return FALSE;
12255
12256 #define STUB_SHRINK_ITER 20
12257   /* Loop until no stubs added.  After iteration 20 of this loop we may
12258      exit on a stub section shrinking.  This is to break out of a
12259      pathological case where adding stubs on one iteration decreases
12260      section gaps (perhaps due to alignment), which then requires
12261      fewer or smaller stubs on the next iteration.  */
12262
12263   while (1)
12264     {
12265       bfd *input_bfd;
12266       unsigned int bfd_indx;
12267       struct map_stub *group;
12268       asection *stub_sec;
12269
12270       htab->stub_iteration += 1;
12271
12272       for (input_bfd = info->input_bfds, bfd_indx = 0;
12273            input_bfd != NULL;
12274            input_bfd = input_bfd->link.next, bfd_indx++)
12275         {
12276           Elf_Internal_Shdr *symtab_hdr;
12277           asection *section;
12278           Elf_Internal_Sym *local_syms = NULL;
12279
12280           if (!is_ppc64_elf (input_bfd))
12281             continue;
12282
12283           /* We'll need the symbol table in a second.  */
12284           symtab_hdr = &elf_symtab_hdr (input_bfd);
12285           if (symtab_hdr->sh_info == 0)
12286             continue;
12287
12288           /* Walk over each section attached to the input bfd.  */
12289           for (section = input_bfd->sections;
12290                section != NULL;
12291                section = section->next)
12292             {
12293               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
12294
12295               /* If there aren't any relocs, then there's nothing more
12296                  to do.  */
12297               if ((section->flags & SEC_RELOC) == 0
12298                   || (section->flags & SEC_ALLOC) == 0
12299                   || (section->flags & SEC_LOAD) == 0
12300                   || (section->flags & SEC_CODE) == 0
12301                   || section->reloc_count == 0)
12302                 continue;
12303
12304               /* If this section is a link-once section that will be
12305                  discarded, then don't create any stubs.  */
12306               if (section->output_section == NULL
12307                   || section->output_section->owner != info->output_bfd)
12308                 continue;
12309
12310               /* Get the relocs.  */
12311               internal_relocs
12312                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
12313                                              info->keep_memory);
12314               if (internal_relocs == NULL)
12315                 goto error_ret_free_local;
12316
12317               /* Now examine each relocation.  */
12318               irela = internal_relocs;
12319               irelaend = irela + section->reloc_count;
12320               for (; irela < irelaend; irela++)
12321                 {
12322                   enum elf_ppc64_reloc_type r_type;
12323                   unsigned int r_indx;
12324                   enum ppc_stub_type stub_type;
12325                   struct ppc_stub_hash_entry *stub_entry;
12326                   asection *sym_sec, *code_sec;
12327                   bfd_vma sym_value, code_value;
12328                   bfd_vma destination;
12329                   unsigned long local_off;
12330                   bfd_boolean ok_dest;
12331                   struct ppc_link_hash_entry *hash;
12332                   struct ppc_link_hash_entry *fdh;
12333                   struct elf_link_hash_entry *h;
12334                   Elf_Internal_Sym *sym;
12335                   char *stub_name;
12336                   const asection *id_sec;
12337                   struct _opd_sec_data *opd;
12338                   struct plt_entry *plt_ent;
12339
12340                   r_type = ELF64_R_TYPE (irela->r_info);
12341                   r_indx = ELF64_R_SYM (irela->r_info);
12342
12343                   if (r_type >= R_PPC64_max)
12344                     {
12345                       bfd_set_error (bfd_error_bad_value);
12346                       goto error_ret_free_internal;
12347                     }
12348
12349                   /* Only look for stubs on branch instructions.  */
12350                   if (r_type != R_PPC64_REL24
12351                       && r_type != R_PPC64_REL14
12352                       && r_type != R_PPC64_REL14_BRTAKEN
12353                       && r_type != R_PPC64_REL14_BRNTAKEN)
12354                     continue;
12355
12356                   /* Now determine the call target, its name, value,
12357                      section.  */
12358                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12359                                   r_indx, input_bfd))
12360                     goto error_ret_free_internal;
12361                   hash = (struct ppc_link_hash_entry *) h;
12362
12363                   ok_dest = FALSE;
12364                   fdh = NULL;
12365                   sym_value = 0;
12366                   if (hash == NULL)
12367                     {
12368                       sym_value = sym->st_value;
12369                       if (sym_sec != NULL
12370                           && sym_sec->output_section != NULL)
12371                         ok_dest = TRUE;
12372                     }
12373                   else if (hash->elf.root.type == bfd_link_hash_defined
12374                            || hash->elf.root.type == bfd_link_hash_defweak)
12375                     {
12376                       sym_value = hash->elf.root.u.def.value;
12377                       if (sym_sec->output_section != NULL)
12378                         ok_dest = TRUE;
12379                     }
12380                   else if (hash->elf.root.type == bfd_link_hash_undefweak
12381                            || hash->elf.root.type == bfd_link_hash_undefined)
12382                     {
12383                       /* Recognise an old ABI func code entry sym, and
12384                          use the func descriptor sym instead if it is
12385                          defined.  */
12386                       if (hash->elf.root.root.string[0] == '.'
12387                           && (fdh = lookup_fdh (hash, htab)) != NULL)
12388                         {
12389                           if (fdh->elf.root.type == bfd_link_hash_defined
12390                               || fdh->elf.root.type == bfd_link_hash_defweak)
12391                             {
12392                               sym_sec = fdh->elf.root.u.def.section;
12393                               sym_value = fdh->elf.root.u.def.value;
12394                               if (sym_sec->output_section != NULL)
12395                                 ok_dest = TRUE;
12396                             }
12397                           else
12398                             fdh = NULL;
12399                         }
12400                     }
12401                   else
12402                     {
12403                       bfd_set_error (bfd_error_bad_value);
12404                       goto error_ret_free_internal;
12405                     }
12406
12407                   destination = 0;
12408                   local_off = 0;
12409                   if (ok_dest)
12410                     {
12411                       sym_value += irela->r_addend;
12412                       destination = (sym_value
12413                                      + sym_sec->output_offset
12414                                      + sym_sec->output_section->vma);
12415                       local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12416                                                             ? hash->elf.other
12417                                                             : sym->st_other);
12418                     }
12419
12420                   code_sec = sym_sec;
12421                   code_value = sym_value;
12422                   opd = get_opd_info (sym_sec);
12423                   if (opd != NULL)
12424                     {
12425                       bfd_vma dest;
12426
12427                       if (hash == NULL && opd->adjust != NULL)
12428                         {
12429                           long adjust = opd->adjust[OPD_NDX (sym_value)];
12430                           if (adjust == -1)
12431                             continue;
12432                           code_value += adjust;
12433                           sym_value += adjust;
12434                         }
12435                       dest = opd_entry_value (sym_sec, sym_value,
12436                                               &code_sec, &code_value, FALSE);
12437                       if (dest != (bfd_vma) -1)
12438                         {
12439                           destination = dest;
12440                           if (fdh != NULL)
12441                             {
12442                               /* Fixup old ABI sym to point at code
12443                                  entry.  */
12444                               hash->elf.root.type = bfd_link_hash_defweak;
12445                               hash->elf.root.u.def.section = code_sec;
12446                               hash->elf.root.u.def.value = code_value;
12447                             }
12448                         }
12449                     }
12450
12451                   /* Determine what (if any) linker stub is needed.  */
12452                   plt_ent = NULL;
12453                   stub_type = ppc_type_of_stub (section, irela, &hash,
12454                                                 &plt_ent, destination,
12455                                                 local_off);
12456
12457                   if (stub_type != ppc_stub_plt_call)
12458                     {
12459                       /* Check whether we need a TOC adjusting stub.
12460                          Since the linker pastes together pieces from
12461                          different object files when creating the
12462                          _init and _fini functions, it may be that a
12463                          call to what looks like a local sym is in
12464                          fact a call needing a TOC adjustment.  */
12465                       if (code_sec != NULL
12466                           && code_sec->output_section != NULL
12467                           && (htab->sec_info[code_sec->id].toc_off
12468                               != htab->sec_info[section->id].toc_off)
12469                           && (code_sec->has_toc_reloc
12470                               || code_sec->makes_toc_func_call))
12471                         stub_type = ppc_stub_long_branch_r2off;
12472                     }
12473
12474                   if (stub_type == ppc_stub_none)
12475                     continue;
12476
12477                   /* __tls_get_addr calls might be eliminated.  */
12478                   if (stub_type != ppc_stub_plt_call
12479                       && hash != NULL
12480                       && (hash == htab->tls_get_addr
12481                           || hash == htab->tls_get_addr_fd)
12482                       && section->has_tls_reloc
12483                       && irela != internal_relocs)
12484                     {
12485                       /* Get tls info.  */
12486                       unsigned char *tls_mask;
12487
12488                       if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12489                                          irela - 1, input_bfd))
12490                         goto error_ret_free_internal;
12491                       if (*tls_mask != 0)
12492                         continue;
12493                     }
12494
12495                   if (stub_type == ppc_stub_plt_call
12496                       && irela + 1 < irelaend
12497                       && irela[1].r_offset == irela->r_offset + 4
12498                       && ELF64_R_TYPE (irela[1].r_info) == R_PPC64_TOCSAVE)
12499                     {
12500                       if (!tocsave_find (htab, INSERT,
12501                                          &local_syms, irela + 1, input_bfd))
12502                         goto error_ret_free_internal;
12503                     }
12504                   else if (stub_type == ppc_stub_plt_call)
12505                     stub_type = ppc_stub_plt_call_r2save;
12506
12507                   /* Support for grouping stub sections.  */
12508                   id_sec = htab->sec_info[section->id].u.group->link_sec;
12509
12510                   /* Get the name of this stub.  */
12511                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12512                   if (!stub_name)
12513                     goto error_ret_free_internal;
12514
12515                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12516                                                      stub_name, FALSE, FALSE);
12517                   if (stub_entry != NULL)
12518                     {
12519                       /* The proper stub has already been created.  */
12520                       free (stub_name);
12521                       if (stub_type == ppc_stub_plt_call_r2save)
12522                         stub_entry->stub_type = stub_type;
12523                       continue;
12524                     }
12525
12526                   stub_entry = ppc_add_stub (stub_name, section, info);
12527                   if (stub_entry == NULL)
12528                     {
12529                       free (stub_name);
12530                     error_ret_free_internal:
12531                       if (elf_section_data (section)->relocs == NULL)
12532                         free (internal_relocs);
12533                     error_ret_free_local:
12534                       if (local_syms != NULL
12535                           && (symtab_hdr->contents
12536                               != (unsigned char *) local_syms))
12537                         free (local_syms);
12538                       return FALSE;
12539                     }
12540
12541                   stub_entry->stub_type = stub_type;
12542                   if (stub_type != ppc_stub_plt_call
12543                       && stub_type != ppc_stub_plt_call_r2save)
12544                     {
12545                       stub_entry->target_value = code_value;
12546                       stub_entry->target_section = code_sec;
12547                     }
12548                   else
12549                     {
12550                       stub_entry->target_value = sym_value;
12551                       stub_entry->target_section = sym_sec;
12552                     }
12553                   stub_entry->h = hash;
12554                   stub_entry->plt_ent = plt_ent;
12555                   stub_entry->other = hash ? hash->elf.other : sym->st_other;
12556
12557                   if (stub_entry->h != NULL)
12558                     htab->stub_globals += 1;
12559                 }
12560
12561               /* We're done with the internal relocs, free them.  */
12562               if (elf_section_data (section)->relocs != internal_relocs)
12563                 free (internal_relocs);
12564             }
12565
12566           if (local_syms != NULL
12567               && symtab_hdr->contents != (unsigned char *) local_syms)
12568             {
12569               if (!info->keep_memory)
12570                 free (local_syms);
12571               else
12572                 symtab_hdr->contents = (unsigned char *) local_syms;
12573             }
12574         }
12575
12576       /* We may have added some stubs.  Find out the new size of the
12577          stub sections.  */
12578       for (stub_sec = htab->params->stub_bfd->sections;
12579            stub_sec != NULL;
12580            stub_sec = stub_sec->next)
12581         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12582           {
12583             stub_sec->rawsize = stub_sec->size;
12584             stub_sec->size = 0;
12585             stub_sec->reloc_count = 0;
12586             stub_sec->flags &= ~SEC_RELOC;
12587           }
12588
12589       htab->brlt->size = 0;
12590       htab->brlt->reloc_count = 0;
12591       htab->brlt->flags &= ~SEC_RELOC;
12592       if (htab->relbrlt != NULL)
12593         htab->relbrlt->size = 0;
12594
12595       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12596
12597       for (group = htab->group; group != NULL; group = group->next)
12598         if (group->needs_save_res)
12599           group->stub_sec->size += htab->sfpr->size;
12600
12601       if (info->emitrelocations
12602           && htab->glink != NULL && htab->glink->size != 0)
12603         {
12604           htab->glink->reloc_count = 1;
12605           htab->glink->flags |= SEC_RELOC;
12606         }
12607
12608       if (htab->glink_eh_frame != NULL
12609           && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12610           && htab->glink_eh_frame->output_section->size != 0)
12611         {
12612           size_t size = 0, align;
12613
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               size += 24;
12619           if (htab->glink != NULL && htab->glink->size != 0)
12620             size += 24;
12621           if (size != 0)
12622             size += sizeof (glink_eh_frame_cie);
12623           align = 1;
12624           align <<= htab->glink_eh_frame->output_section->alignment_power;
12625           align -= 1;
12626           size = (size + align) & ~align;
12627           htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12628           htab->glink_eh_frame->size = size;
12629         }
12630
12631       if (htab->params->plt_stub_align != 0)
12632         for (stub_sec = htab->params->stub_bfd->sections;
12633              stub_sec != NULL;
12634              stub_sec = stub_sec->next)
12635           if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12636             stub_sec->size = ((stub_sec->size
12637                                + (1 << htab->params->plt_stub_align) - 1)
12638                               & -(1 << htab->params->plt_stub_align));
12639
12640       for (stub_sec = htab->params->stub_bfd->sections;
12641            stub_sec != NULL;
12642            stub_sec = stub_sec->next)
12643         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12644             && stub_sec->rawsize != stub_sec->size
12645             && (htab->stub_iteration <= STUB_SHRINK_ITER
12646                 || stub_sec->rawsize < stub_sec->size))
12647           break;
12648
12649       if (stub_sec == NULL
12650           && (htab->glink_eh_frame == NULL
12651               || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12652         break;
12653
12654       /* Ask the linker to do its stuff.  */
12655       (*htab->params->layout_sections_again) ();
12656     }
12657
12658   if (htab->glink_eh_frame != NULL
12659       && htab->glink_eh_frame->size != 0)
12660     {
12661       bfd_vma val;
12662       bfd_byte *p, *last_fde;
12663       size_t last_fde_len, size, align, pad;
12664       asection *stub_sec;
12665
12666       p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12667       if (p == NULL)
12668         return FALSE;
12669       htab->glink_eh_frame->contents = p;
12670       last_fde = p;
12671
12672       memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12673       /* CIE length (rewrite in case little-endian).  */
12674       last_fde_len = sizeof (glink_eh_frame_cie) - 4;
12675       bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12676       p += sizeof (glink_eh_frame_cie);
12677
12678       for (stub_sec = htab->params->stub_bfd->sections;
12679            stub_sec != NULL;
12680            stub_sec = stub_sec->next)
12681         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12682           {
12683             last_fde = p;
12684             last_fde_len = 20;
12685             /* FDE length.  */
12686             bfd_put_32 (htab->elf.dynobj, 20, p);
12687             p += 4;
12688             /* CIE pointer.  */
12689             val = p - htab->glink_eh_frame->contents;
12690             bfd_put_32 (htab->elf.dynobj, val, p);
12691             p += 4;
12692             /* Offset to stub section, written later.  */
12693             p += 4;
12694             /* stub section size.  */
12695             bfd_put_32 (htab->elf.dynobj, stub_sec->size, p);
12696             p += 4;
12697             /* Augmentation.  */
12698             p += 1;
12699             /* Pad.  */
12700             p += 7;
12701           }
12702       if (htab->glink != NULL && htab->glink->size != 0)
12703         {
12704           last_fde = p;
12705           last_fde_len = 20;
12706           /* FDE length.  */
12707           bfd_put_32 (htab->elf.dynobj, 20, p);
12708           p += 4;
12709           /* CIE pointer.  */
12710           val = p - htab->glink_eh_frame->contents;
12711           bfd_put_32 (htab->elf.dynobj, val, p);
12712           p += 4;
12713           /* Offset to .glink, written later.  */
12714           p += 4;
12715           /* .glink size.  */
12716           bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12717           p += 4;
12718           /* Augmentation.  */
12719           p += 1;
12720
12721           *p++ = DW_CFA_advance_loc + 1;
12722           *p++ = DW_CFA_register;
12723           *p++ = 65;
12724           *p++ = htab->opd_abi ? 12 : 0;
12725           *p++ = DW_CFA_advance_loc + 4;
12726           *p++ = DW_CFA_restore_extended;
12727           *p++ = 65;
12728         }
12729       /* Subsume any padding into the last FDE if user .eh_frame
12730          sections are aligned more than glink_eh_frame.  Otherwise any
12731          zero padding will be seen as a terminator.  */
12732       size = p - htab->glink_eh_frame->contents;
12733       align = 1;
12734       align <<= htab->glink_eh_frame->output_section->alignment_power;
12735       align -= 1;
12736       pad = ((size + align) & ~align) - size;
12737       htab->glink_eh_frame->size = size + pad;
12738       bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12739     }
12740
12741   maybe_strip_output (info, htab->brlt);
12742   if (htab->glink_eh_frame != NULL)
12743     maybe_strip_output (info, htab->glink_eh_frame);
12744
12745   return TRUE;
12746 }
12747
12748 /* Called after we have determined section placement.  If sections
12749    move, we'll be called again.  Provide a value for TOCstart.  */
12750
12751 bfd_vma
12752 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12753 {
12754   asection *s;
12755   bfd_vma TOCstart, adjust;
12756
12757   if (info != NULL)
12758     {
12759       struct elf_link_hash_entry *h;
12760       struct elf_link_hash_table *htab = elf_hash_table (info);
12761
12762       if (is_elf_hash_table (htab)
12763           && htab->hgot != NULL)
12764         h = htab->hgot;
12765       else
12766         {
12767           h = elf_link_hash_lookup (htab, ".TOC.", FALSE, FALSE, TRUE);
12768           if (is_elf_hash_table (htab))
12769             htab->hgot = h;
12770         }
12771       if (h != NULL
12772           && h->root.type == bfd_link_hash_defined
12773           && !h->root.linker_def
12774           && (!is_elf_hash_table (htab)
12775               || h->def_regular))
12776         {
12777           TOCstart = (h->root.u.def.value - TOC_BASE_OFF
12778                       + h->root.u.def.section->output_offset
12779                       + h->root.u.def.section->output_section->vma);
12780           _bfd_set_gp_value (obfd, TOCstart);
12781           return TOCstart;
12782         }
12783     }
12784
12785   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12786      order.  The TOC starts where the first of these sections starts.  */
12787   s = bfd_get_section_by_name (obfd, ".got");
12788   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12789     s = bfd_get_section_by_name (obfd, ".toc");
12790   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12791     s = bfd_get_section_by_name (obfd, ".tocbss");
12792   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12793     s = bfd_get_section_by_name (obfd, ".plt");
12794   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12795     {
12796       /* This may happen for
12797          o  references to TOC base (SYM@toc / TOC[tc0]) without a
12798          .toc directive
12799          o  bad linker script
12800          o --gc-sections and empty TOC sections
12801
12802          FIXME: Warn user?  */
12803
12804       /* Look for a likely section.  We probably won't even be
12805          using TOCstart.  */
12806       for (s = obfd->sections; s != NULL; s = s->next)
12807         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
12808                          | SEC_EXCLUDE))
12809             == (SEC_ALLOC | SEC_SMALL_DATA))
12810           break;
12811       if (s == NULL)
12812         for (s = obfd->sections; s != NULL; s = s->next)
12813           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
12814               == (SEC_ALLOC | SEC_SMALL_DATA))
12815             break;
12816       if (s == NULL)
12817         for (s = obfd->sections; s != NULL; s = s->next)
12818           if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
12819               == SEC_ALLOC)
12820             break;
12821       if (s == NULL)
12822         for (s = obfd->sections; s != NULL; s = s->next)
12823           if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
12824             break;
12825     }
12826
12827   TOCstart = 0;
12828   if (s != NULL)
12829     TOCstart = s->output_section->vma + s->output_offset;
12830
12831   /* Force alignment.  */
12832   adjust = TOCstart & (TOC_BASE_ALIGN - 1);
12833   TOCstart -= adjust;
12834   _bfd_set_gp_value (obfd, TOCstart);
12835
12836   if (info != NULL && s != NULL)
12837     {
12838       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12839
12840       if (htab != NULL)
12841         {
12842           if (htab->elf.hgot != NULL)
12843             {
12844               htab->elf.hgot->root.u.def.value = TOC_BASE_OFF - adjust;
12845               htab->elf.hgot->root.u.def.section = s;
12846             }
12847         }
12848       else
12849         {
12850           struct bfd_link_hash_entry *bh = NULL;
12851           _bfd_generic_link_add_one_symbol (info, obfd, ".TOC.", BSF_GLOBAL,
12852                                             s, TOC_BASE_OFF - adjust,
12853                                             NULL, FALSE, FALSE, &bh);
12854         }
12855     }
12856   return TOCstart;
12857 }
12858
12859 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
12860    write out any global entry stubs.  */
12861
12862 static bfd_boolean
12863 build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
12864 {
12865   struct bfd_link_info *info;
12866   struct ppc_link_hash_table *htab;
12867   struct plt_entry *pent;
12868   asection *s;
12869
12870   if (h->root.type == bfd_link_hash_indirect)
12871     return TRUE;
12872
12873   if (!h->pointer_equality_needed)
12874     return TRUE;
12875
12876   if (h->def_regular)
12877     return TRUE;
12878
12879   info = inf;
12880   htab = ppc_hash_table (info);
12881   if (htab == NULL)
12882     return FALSE;
12883
12884   s = htab->glink;
12885   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
12886     if (pent->plt.offset != (bfd_vma) -1
12887         && pent->addend == 0)
12888       {
12889         bfd_byte *p;
12890         asection *plt;
12891         bfd_vma off;
12892
12893         p = s->contents + h->root.u.def.value;
12894         plt = htab->elf.splt;
12895         if (!htab->elf.dynamic_sections_created
12896             || h->dynindx == -1)
12897           plt = htab->elf.iplt;
12898         off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
12899         off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
12900
12901         if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
12902           {
12903             info->callbacks->einfo
12904               (_("%P: linkage table error against `%T'\n"),
12905                h->root.root.string);
12906             bfd_set_error (bfd_error_bad_value);
12907             htab->stub_error = TRUE;
12908           }
12909
12910         htab->stub_count[ppc_stub_global_entry - 1] += 1;
12911         if (htab->params->emit_stub_syms)
12912           {
12913             size_t len = strlen (h->root.root.string);
12914             char *name = bfd_malloc (sizeof "12345678.global_entry." + len);
12915
12916             if (name == NULL)
12917               return FALSE;
12918
12919             sprintf (name, "%08x.global_entry.%s", s->id, h->root.root.string);
12920             h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
12921             if (h == NULL)
12922               return FALSE;
12923             if (h->root.type == bfd_link_hash_new)
12924               {
12925                 h->root.type = bfd_link_hash_defined;
12926                 h->root.u.def.section = s;
12927                 h->root.u.def.value = p - s->contents;
12928                 h->ref_regular = 1;
12929                 h->def_regular = 1;
12930                 h->ref_regular_nonweak = 1;
12931                 h->forced_local = 1;
12932                 h->non_elf = 0;
12933                 h->root.linker_def = 1;
12934               }
12935           }
12936
12937         if (PPC_HA (off) != 0)
12938           {
12939             bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
12940             p += 4;
12941           }
12942         bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
12943         p += 4;
12944         bfd_put_32 (s->owner, MTCTR_R12, p);
12945         p += 4;
12946         bfd_put_32 (s->owner, BCTR, p);
12947         break;
12948       }
12949   return TRUE;
12950 }
12951
12952 /* Build all the stubs associated with the current output file.
12953    The stubs are kept in a hash table attached to the main linker
12954    hash table.  This function is called via gldelf64ppc_finish.  */
12955
12956 bfd_boolean
12957 ppc64_elf_build_stubs (struct bfd_link_info *info,
12958                        char **stats)
12959 {
12960   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12961   struct map_stub *group;
12962   asection *stub_sec;
12963   bfd_byte *p;
12964   int stub_sec_count = 0;
12965
12966   if (htab == NULL)
12967     return FALSE;
12968
12969   /* Allocate memory to hold the linker stubs.  */
12970   for (stub_sec = htab->params->stub_bfd->sections;
12971        stub_sec != NULL;
12972        stub_sec = stub_sec->next)
12973     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12974         && stub_sec->size != 0)
12975       {
12976         stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
12977         if (stub_sec->contents == NULL)
12978           return FALSE;
12979         stub_sec->size = 0;
12980       }
12981
12982   if (htab->glink != NULL && htab->glink->size != 0)
12983     {
12984       unsigned int indx;
12985       bfd_vma plt0;
12986
12987       /* Build the .glink plt call stub.  */
12988       if (htab->params->emit_stub_syms)
12989         {
12990           struct elf_link_hash_entry *h;
12991           h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
12992                                     TRUE, FALSE, FALSE);
12993           if (h == NULL)
12994             return FALSE;
12995           if (h->root.type == bfd_link_hash_new)
12996             {
12997               h->root.type = bfd_link_hash_defined;
12998               h->root.u.def.section = htab->glink;
12999               h->root.u.def.value = 8;
13000               h->ref_regular = 1;
13001               h->def_regular = 1;
13002               h->ref_regular_nonweak = 1;
13003               h->forced_local = 1;
13004               h->non_elf = 0;
13005               h->root.linker_def = 1;
13006             }
13007         }
13008       plt0 = (htab->elf.splt->output_section->vma
13009               + htab->elf.splt->output_offset
13010               - 16);
13011       if (info->emitrelocations)
13012         {
13013           Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
13014           if (r == NULL)
13015             return FALSE;
13016           r->r_offset = (htab->glink->output_offset
13017                          + htab->glink->output_section->vma);
13018           r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
13019           r->r_addend = plt0;
13020         }
13021       p = htab->glink->contents;
13022       plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
13023       bfd_put_64 (htab->glink->owner, plt0, p);
13024       p += 8;
13025       if (htab->opd_abi)
13026         {
13027           bfd_put_32 (htab->glink->owner, MFLR_R12, p);
13028           p += 4;
13029           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13030           p += 4;
13031           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13032           p += 4;
13033           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13034           p += 4;
13035           bfd_put_32 (htab->glink->owner, MTLR_R12, p);
13036           p += 4;
13037           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13038           p += 4;
13039           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13040           p += 4;
13041           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
13042           p += 4;
13043           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13044           p += 4;
13045           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
13046           p += 4;
13047         }
13048       else
13049         {
13050           bfd_put_32 (htab->glink->owner, MFLR_R0, p);
13051           p += 4;
13052           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13053           p += 4;
13054           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13055           p += 4;
13056           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13057           p += 4;
13058           bfd_put_32 (htab->glink->owner, MTLR_R0, p);
13059           p += 4;
13060           bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
13061           p += 4;
13062           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13063           p += 4;
13064           bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
13065           p += 4;
13066           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13067           p += 4;
13068           bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
13069           p += 4;
13070           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13071           p += 4;
13072           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
13073           p += 4;
13074         }
13075       bfd_put_32 (htab->glink->owner, BCTR, p);
13076       p += 4;
13077       while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
13078         {
13079           bfd_put_32 (htab->glink->owner, NOP, p);
13080           p += 4;
13081         }
13082
13083       /* Build the .glink lazy link call stubs.  */
13084       indx = 0;
13085       while (p < htab->glink->contents + htab->glink->rawsize)
13086         {
13087           if (htab->opd_abi)
13088             {
13089               if (indx < 0x8000)
13090                 {
13091                   bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
13092                   p += 4;
13093                 }
13094               else
13095                 {
13096                   bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
13097                   p += 4;
13098                   bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
13099                               p);
13100                   p += 4;
13101                 }
13102             }
13103           bfd_put_32 (htab->glink->owner,
13104                       B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
13105           indx++;
13106           p += 4;
13107         }
13108
13109       /* Build .glink global entry stubs.  */
13110       if (htab->glink->size > htab->glink->rawsize)
13111         elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
13112     }
13113
13114   if (htab->brlt != NULL && htab->brlt->size != 0)
13115     {
13116       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
13117                                          htab->brlt->size);
13118       if (htab->brlt->contents == NULL)
13119         return FALSE;
13120     }
13121   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
13122     {
13123       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
13124                                             htab->relbrlt->size);
13125       if (htab->relbrlt->contents == NULL)
13126         return FALSE;
13127     }
13128
13129   /* Build the stubs as directed by the stub hash table.  */
13130   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
13131
13132   for (group = htab->group; group != NULL; group = group->next)
13133     if (group->needs_save_res)
13134       {
13135         stub_sec = group->stub_sec;
13136         memcpy (stub_sec->contents + stub_sec->size, htab->sfpr->contents,
13137                 htab->sfpr->size);
13138         if (htab->params->emit_stub_syms)
13139           {
13140             unsigned int i;
13141
13142             for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
13143               if (!sfpr_define (info, &save_res_funcs[i], stub_sec))
13144                 return FALSE;
13145           }
13146         stub_sec->size += htab->sfpr->size;
13147       }
13148
13149   if (htab->relbrlt != NULL)
13150     htab->relbrlt->reloc_count = 0;
13151
13152   if (htab->params->plt_stub_align != 0)
13153     for (stub_sec = htab->params->stub_bfd->sections;
13154          stub_sec != NULL;
13155          stub_sec = stub_sec->next)
13156       if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
13157         stub_sec->size = ((stub_sec->size
13158                            + (1 << htab->params->plt_stub_align) - 1)
13159                           & -(1 << htab->params->plt_stub_align));
13160
13161   for (stub_sec = htab->params->stub_bfd->sections;
13162        stub_sec != NULL;
13163        stub_sec = stub_sec->next)
13164     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
13165       {
13166         stub_sec_count += 1;
13167         if (stub_sec->rawsize != stub_sec->size
13168             && (htab->stub_iteration <= STUB_SHRINK_ITER
13169                 || stub_sec->rawsize < stub_sec->size))
13170           break;
13171       }
13172
13173   /* Note that the glink_eh_frame check here is not only testing that
13174      the generated size matched the calculated size but also that
13175      bfd_elf_discard_info didn't make any changes to the section.  */
13176   if (stub_sec != NULL
13177       || (htab->glink_eh_frame != NULL
13178           && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
13179     {
13180       htab->stub_error = TRUE;
13181       info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
13182     }
13183
13184   if (htab->stub_error)
13185     return FALSE;
13186
13187   if (stats != NULL)
13188     {
13189       *stats = bfd_malloc (500);
13190       if (*stats == NULL)
13191         return FALSE;
13192
13193       sprintf (*stats, _("linker stubs in %u group%s\n"
13194                          "  branch       %lu\n"
13195                          "  toc adjust   %lu\n"
13196                          "  long branch  %lu\n"
13197                          "  long toc adj %lu\n"
13198                          "  plt call     %lu\n"
13199                          "  plt call toc %lu\n"
13200                          "  global entry %lu"),
13201                stub_sec_count,
13202                stub_sec_count == 1 ? "" : "s",
13203                htab->stub_count[ppc_stub_long_branch - 1],
13204                htab->stub_count[ppc_stub_long_branch_r2off - 1],
13205                htab->stub_count[ppc_stub_plt_branch - 1],
13206                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
13207                htab->stub_count[ppc_stub_plt_call - 1],
13208                htab->stub_count[ppc_stub_plt_call_r2save - 1],
13209                htab->stub_count[ppc_stub_global_entry - 1]);
13210     }
13211   return TRUE;
13212 }
13213
13214 /* This function undoes the changes made by add_symbol_adjust.  */
13215
13216 static bfd_boolean
13217 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
13218 {
13219   struct ppc_link_hash_entry *eh;
13220
13221   if (h->root.type == bfd_link_hash_indirect)
13222     return TRUE;
13223
13224   eh = (struct ppc_link_hash_entry *) h;
13225   if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
13226     return TRUE;
13227
13228   eh->elf.root.type = bfd_link_hash_undefined;
13229   return TRUE;
13230 }
13231
13232 void
13233 ppc64_elf_restore_symbols (struct bfd_link_info *info)
13234 {
13235   struct ppc_link_hash_table *htab = ppc_hash_table (info);
13236
13237   if (htab != NULL)
13238     elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
13239 }
13240
13241 /* What to do when ld finds relocations against symbols defined in
13242    discarded sections.  */
13243
13244 static unsigned int
13245 ppc64_elf_action_discarded (asection *sec)
13246 {
13247   if (strcmp (".opd", sec->name) == 0)
13248     return 0;
13249
13250   if (strcmp (".toc", sec->name) == 0)
13251     return 0;
13252
13253   if (strcmp (".toc1", sec->name) == 0)
13254     return 0;
13255
13256   return _bfd_elf_default_action_discarded (sec);
13257 }
13258
13259 /* The RELOCATE_SECTION function is called by the ELF backend linker
13260    to handle the relocations for a section.
13261
13262    The relocs are always passed as Rela structures; if the section
13263    actually uses Rel structures, the r_addend field will always be
13264    zero.
13265
13266    This function is responsible for adjust the section contents as
13267    necessary, and (if using Rela relocs and generating a
13268    relocatable output file) adjusting the reloc addend as
13269    necessary.
13270
13271    This function does not have to worry about setting the reloc
13272    address or the reloc symbol index.
13273
13274    LOCAL_SYMS is a pointer to the swapped in local symbols.
13275
13276    LOCAL_SECTIONS is an array giving the section in the input file
13277    corresponding to the st_shndx field of each local symbol.
13278
13279    The global hash table entry for the global symbols can be found
13280    via elf_sym_hashes (input_bfd).
13281
13282    When generating relocatable output, this function must handle
13283    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
13284    going to be the section symbol corresponding to the output
13285    section, which means that the addend must be adjusted
13286    accordingly.  */
13287
13288 static bfd_boolean
13289 ppc64_elf_relocate_section (bfd *output_bfd,
13290                             struct bfd_link_info *info,
13291                             bfd *input_bfd,
13292                             asection *input_section,
13293                             bfd_byte *contents,
13294                             Elf_Internal_Rela *relocs,
13295                             Elf_Internal_Sym *local_syms,
13296                             asection **local_sections)
13297 {
13298   struct ppc_link_hash_table *htab;
13299   Elf_Internal_Shdr *symtab_hdr;
13300   struct elf_link_hash_entry **sym_hashes;
13301   Elf_Internal_Rela *rel;
13302   Elf_Internal_Rela *wrel;
13303   Elf_Internal_Rela *relend;
13304   Elf_Internal_Rela outrel;
13305   bfd_byte *loc;
13306   struct got_entry **local_got_ents;
13307   bfd_vma TOCstart;
13308   bfd_boolean ret = TRUE;
13309   bfd_boolean is_opd;
13310   /* Assume 'at' branch hints.  */
13311   bfd_boolean is_isa_v2 = TRUE;
13312   bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
13313
13314   /* Initialize howto table if needed.  */
13315   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
13316     ppc_howto_init ();
13317
13318   htab = ppc_hash_table (info);
13319   if (htab == NULL)
13320     return FALSE;
13321
13322   /* Don't relocate stub sections.  */
13323   if (input_section->owner == htab->params->stub_bfd)
13324     return TRUE;
13325
13326   BFD_ASSERT (is_ppc64_elf (input_bfd));
13327
13328   local_got_ents = elf_local_got_ents (input_bfd);
13329   TOCstart = elf_gp (output_bfd);
13330   symtab_hdr = &elf_symtab_hdr (input_bfd);
13331   sym_hashes = elf_sym_hashes (input_bfd);
13332   is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
13333
13334   rel = wrel = relocs;
13335   relend = relocs + input_section->reloc_count;
13336   for (; rel < relend; wrel++, rel++)
13337     {
13338       enum elf_ppc64_reloc_type r_type;
13339       bfd_vma addend;
13340       bfd_reloc_status_type r;
13341       Elf_Internal_Sym *sym;
13342       asection *sec;
13343       struct elf_link_hash_entry *h_elf;
13344       struct ppc_link_hash_entry *h;
13345       struct ppc_link_hash_entry *fdh;
13346       const char *sym_name;
13347       unsigned long r_symndx, toc_symndx;
13348       bfd_vma toc_addend;
13349       unsigned char tls_mask, tls_gd, tls_type;
13350       unsigned char sym_type;
13351       bfd_vma relocation;
13352       bfd_boolean unresolved_reloc;
13353       bfd_boolean warned;
13354       enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
13355       unsigned int insn;
13356       unsigned int mask;
13357       struct ppc_stub_hash_entry *stub_entry;
13358       bfd_vma max_br_offset;
13359       bfd_vma from;
13360       Elf_Internal_Rela orig_rel;
13361       reloc_howto_type *howto;
13362       struct reloc_howto_struct alt_howto;
13363
13364     again:
13365       orig_rel = *rel;
13366
13367       r_type = ELF64_R_TYPE (rel->r_info);
13368       r_symndx = ELF64_R_SYM (rel->r_info);
13369
13370       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
13371          symbol of the previous ADDR64 reloc.  The symbol gives us the
13372          proper TOC base to use.  */
13373       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
13374           && wrel != relocs
13375           && ELF64_R_TYPE (wrel[-1].r_info) == R_PPC64_ADDR64
13376           && is_opd)
13377         r_symndx = ELF64_R_SYM (wrel[-1].r_info);
13378
13379       sym = NULL;
13380       sec = NULL;
13381       h_elf = NULL;
13382       sym_name = NULL;
13383       unresolved_reloc = FALSE;
13384       warned = FALSE;
13385
13386       if (r_symndx < symtab_hdr->sh_info)
13387         {
13388           /* It's a local symbol.  */
13389           struct _opd_sec_data *opd;
13390
13391           sym = local_syms + r_symndx;
13392           sec = local_sections[r_symndx];
13393           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
13394           sym_type = ELF64_ST_TYPE (sym->st_info);
13395           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
13396           opd = get_opd_info (sec);
13397           if (opd != NULL && opd->adjust != NULL)
13398             {
13399               long adjust = opd->adjust[OPD_NDX (sym->st_value
13400                                                  + rel->r_addend)];
13401               if (adjust == -1)
13402                 relocation = 0;
13403               else
13404                 {
13405                   /* If this is a relocation against the opd section sym
13406                      and we have edited .opd, adjust the reloc addend so
13407                      that ld -r and ld --emit-relocs output is correct.
13408                      If it is a reloc against some other .opd symbol,
13409                      then the symbol value will be adjusted later.  */
13410                   if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
13411                     rel->r_addend += adjust;
13412                   else
13413                     relocation += adjust;
13414                 }
13415             }
13416         }
13417       else
13418         {
13419           bfd_boolean ignored;
13420
13421           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
13422                                    r_symndx, symtab_hdr, sym_hashes,
13423                                    h_elf, sec, relocation,
13424                                    unresolved_reloc, warned, ignored);
13425           sym_name = h_elf->root.root.string;
13426           sym_type = h_elf->type;
13427           if (sec != NULL
13428               && sec->owner == output_bfd
13429               && strcmp (sec->name, ".opd") == 0)
13430             {
13431               /* This is a symbol defined in a linker script.  All
13432                  such are defined in output sections, even those
13433                  defined by simple assignment from a symbol defined in
13434                  an input section.  Transfer the symbol to an
13435                  appropriate input .opd section, so that a branch to
13436                  this symbol will be mapped to the location specified
13437                  by the opd entry.  */
13438               struct bfd_link_order *lo;
13439               for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
13440                 if (lo->type == bfd_indirect_link_order)
13441                   {
13442                     asection *isec = lo->u.indirect.section;
13443                     if (h_elf->root.u.def.value >= isec->output_offset
13444                         && h_elf->root.u.def.value < (isec->output_offset
13445                                                       + isec->size))
13446                       {
13447                         h_elf->root.u.def.value -= isec->output_offset;
13448                         h_elf->root.u.def.section = isec;
13449                         sec = isec;
13450                         break;
13451                       }
13452                   }
13453             }
13454         }
13455       h = (struct ppc_link_hash_entry *) h_elf;
13456
13457       if (sec != NULL && discarded_section (sec))
13458         {
13459           _bfd_clear_contents (ppc64_elf_howto_table[r_type],
13460                                input_bfd, input_section,
13461                                contents + rel->r_offset);
13462           wrel->r_offset = rel->r_offset;
13463           wrel->r_info = 0;
13464           wrel->r_addend = 0;
13465
13466           /* For ld -r, remove relocations in debug sections against
13467              sections defined in discarded sections.  Not done for
13468              non-debug to preserve relocs in .eh_frame which the
13469              eh_frame editing code expects to be present.  */
13470           if (bfd_link_relocatable (info)
13471               && (input_section->flags & SEC_DEBUGGING))
13472             wrel--;
13473
13474           continue;
13475         }
13476
13477       if (bfd_link_relocatable (info))
13478         goto copy_reloc;
13479
13480       if (h != NULL && &h->elf == htab->elf.hgot)
13481         {
13482           relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
13483           sec = bfd_abs_section_ptr;
13484           unresolved_reloc = FALSE;
13485         }
13486
13487       /* TLS optimizations.  Replace instruction sequences and relocs
13488          based on information we collected in tls_optimize.  We edit
13489          RELOCS so that --emit-relocs will output something sensible
13490          for the final instruction stream.  */
13491       tls_mask = 0;
13492       tls_gd = 0;
13493       toc_symndx = 0;
13494       if (h != NULL)
13495         tls_mask = h->tls_mask;
13496       else if (local_got_ents != NULL)
13497         {
13498           struct plt_entry **local_plt = (struct plt_entry **)
13499             (local_got_ents + symtab_hdr->sh_info);
13500           unsigned char *lgot_masks = (unsigned char *)
13501             (local_plt + symtab_hdr->sh_info);
13502           tls_mask = lgot_masks[r_symndx];
13503         }
13504       if (tls_mask == 0
13505           && (r_type == R_PPC64_TLS
13506               || r_type == R_PPC64_TLSGD
13507               || r_type == R_PPC64_TLSLD))
13508         {
13509           /* Check for toc tls entries.  */
13510           unsigned char *toc_tls;
13511
13512           if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13513                              &local_syms, rel, input_bfd))
13514             return FALSE;
13515
13516           if (toc_tls)
13517             tls_mask = *toc_tls;
13518         }
13519
13520       /* Check that tls relocs are used with tls syms, and non-tls
13521          relocs are used with non-tls syms.  */
13522       if (r_symndx != STN_UNDEF
13523           && r_type != R_PPC64_NONE
13524           && (h == NULL
13525               || h->elf.root.type == bfd_link_hash_defined
13526               || h->elf.root.type == bfd_link_hash_defweak)
13527           && (IS_PPC64_TLS_RELOC (r_type)
13528               != (sym_type == STT_TLS
13529                   || (sym_type == STT_SECTION
13530                       && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13531         {
13532           if (tls_mask != 0
13533               && (r_type == R_PPC64_TLS
13534                   || r_type == R_PPC64_TLSGD
13535                   || r_type == R_PPC64_TLSLD))
13536             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
13537             ;
13538           else
13539             info->callbacks->einfo
13540               (!IS_PPC64_TLS_RELOC (r_type)
13541                ? _("%P: %H: %s used with TLS symbol `%T'\n")
13542                : _("%P: %H: %s used with non-TLS symbol `%T'\n"),
13543                input_bfd, input_section, rel->r_offset,
13544                ppc64_elf_howto_table[r_type]->name,
13545                sym_name);
13546         }
13547
13548       /* Ensure reloc mapping code below stays sane.  */
13549       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13550           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13551           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
13552           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13553           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13554           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13555           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
13556           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13557           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13558           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13559         abort ();
13560
13561       switch (r_type)
13562         {
13563         default:
13564           break;
13565
13566         case R_PPC64_LO_DS_OPT:
13567           insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13568           if ((insn & (0x3f << 26)) != 58u << 26)
13569             abort ();
13570           insn += (14u << 26) - (58u << 26);
13571           bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13572           r_type = R_PPC64_TOC16_LO;
13573           rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13574           break;
13575
13576         case R_PPC64_TOC16:
13577         case R_PPC64_TOC16_LO:
13578         case R_PPC64_TOC16_DS:
13579         case R_PPC64_TOC16_LO_DS:
13580           {
13581             /* Check for toc tls entries.  */
13582             unsigned char *toc_tls;
13583             int retval;
13584
13585             retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13586                                    &local_syms, rel, input_bfd);
13587             if (retval == 0)
13588               return FALSE;
13589
13590             if (toc_tls)
13591               {
13592                 tls_mask = *toc_tls;
13593                 if (r_type == R_PPC64_TOC16_DS
13594                     || r_type == R_PPC64_TOC16_LO_DS)
13595                   {
13596                     if (tls_mask != 0
13597                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13598                       goto toctprel;
13599                   }
13600                 else
13601                   {
13602                     /* If we found a GD reloc pair, then we might be
13603                        doing a GD->IE transition.  */
13604                     if (retval == 2)
13605                       {
13606                         tls_gd = TLS_TPRELGD;
13607                         if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13608                           goto tls_ldgd_opt;
13609                       }
13610                     else if (retval == 3)
13611                       {
13612                         if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13613                           goto tls_ldgd_opt;
13614                       }
13615                   }
13616               }
13617           }
13618           break;
13619
13620         case R_PPC64_GOT_TPREL16_HI:
13621         case R_PPC64_GOT_TPREL16_HA:
13622           if (tls_mask != 0
13623               && (tls_mask & TLS_TPREL) == 0)
13624             {
13625               rel->r_offset -= d_offset;
13626               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13627               r_type = R_PPC64_NONE;
13628               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13629             }
13630           break;
13631
13632         case R_PPC64_GOT_TPREL16_DS:
13633         case R_PPC64_GOT_TPREL16_LO_DS:
13634           if (tls_mask != 0
13635               && (tls_mask & TLS_TPREL) == 0)
13636             {
13637             toctprel:
13638               insn = bfd_get_32 (output_bfd,
13639                                  contents + rel->r_offset - d_offset);
13640               insn &= 31 << 21;
13641               insn |= 0x3c0d0000;       /* addis 0,13,0 */
13642               bfd_put_32 (output_bfd, insn,
13643                           contents + rel->r_offset - d_offset);
13644               r_type = R_PPC64_TPREL16_HA;
13645               if (toc_symndx != 0)
13646                 {
13647                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13648                   rel->r_addend = toc_addend;
13649                   /* We changed the symbol.  Start over in order to
13650                      get h, sym, sec etc. right.  */
13651                   goto again;
13652                 }
13653               else
13654                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13655             }
13656           break;
13657
13658         case R_PPC64_TLS:
13659           if (tls_mask != 0
13660               && (tls_mask & TLS_TPREL) == 0)
13661             {
13662               insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
13663               insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13664               if (insn == 0)
13665                 abort ();
13666               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13667               /* Was PPC64_TLS which sits on insn boundary, now
13668                  PPC64_TPREL16_LO which is at low-order half-word.  */
13669               rel->r_offset += d_offset;
13670               r_type = R_PPC64_TPREL16_LO;
13671               if (toc_symndx != 0)
13672                 {
13673                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13674                   rel->r_addend = toc_addend;
13675                   /* We changed the symbol.  Start over in order to
13676                      get h, sym, sec etc. right.  */
13677                   goto again;
13678                 }
13679               else
13680                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13681             }
13682           break;
13683
13684         case R_PPC64_GOT_TLSGD16_HI:
13685         case R_PPC64_GOT_TLSGD16_HA:
13686           tls_gd = TLS_TPRELGD;
13687           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13688             goto tls_gdld_hi;
13689           break;
13690
13691         case R_PPC64_GOT_TLSLD16_HI:
13692         case R_PPC64_GOT_TLSLD16_HA:
13693           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13694             {
13695             tls_gdld_hi:
13696               if ((tls_mask & tls_gd) != 0)
13697                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13698                           + R_PPC64_GOT_TPREL16_DS);
13699               else
13700                 {
13701                   rel->r_offset -= d_offset;
13702                   bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13703                   r_type = R_PPC64_NONE;
13704                 }
13705               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13706             }
13707           break;
13708
13709         case R_PPC64_GOT_TLSGD16:
13710         case R_PPC64_GOT_TLSGD16_LO:
13711           tls_gd = TLS_TPRELGD;
13712           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13713             goto tls_ldgd_opt;
13714           break;
13715
13716         case R_PPC64_GOT_TLSLD16:
13717         case R_PPC64_GOT_TLSLD16_LO:
13718           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13719             {
13720               unsigned int insn1, insn2, insn3;
13721               bfd_vma offset;
13722
13723             tls_ldgd_opt:
13724               offset = (bfd_vma) -1;
13725               /* If not using the newer R_PPC64_TLSGD/LD to mark
13726                  __tls_get_addr calls, we must trust that the call
13727                  stays with its arg setup insns, ie. that the next
13728                  reloc is the __tls_get_addr call associated with
13729                  the current reloc.  Edit both insns.  */
13730               if (input_section->has_tls_get_addr_call
13731                   && rel + 1 < relend
13732                   && branch_reloc_hash_match (input_bfd, rel + 1,
13733                                               htab->tls_get_addr,
13734                                               htab->tls_get_addr_fd))
13735                 offset = rel[1].r_offset;
13736               /* We read the low GOT_TLS (or TOC16) insn because we
13737                  need to keep the destination reg.  It may be
13738                  something other than the usual r3, and moved to r3
13739                  before the call by intervening code.  */
13740               insn1 = bfd_get_32 (output_bfd,
13741                                   contents + rel->r_offset - d_offset);
13742               if ((tls_mask & tls_gd) != 0)
13743                 {
13744                   /* IE */
13745                   insn1 &= (0x1f << 21) | (0x1f << 16);
13746                   insn1 |= 58 << 26;    /* ld */
13747                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13748                   if (offset != (bfd_vma) -1)
13749                     rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13750                   if ((tls_mask & TLS_EXPLICIT) == 0)
13751                     r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13752                               + R_PPC64_GOT_TPREL16_DS);
13753                   else
13754                     r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13755                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13756                 }
13757               else
13758                 {
13759                   /* LE */
13760                   insn1 &= 0x1f << 21;
13761                   insn1 |= 0x3c0d0000;  /* addis r,13,0 */
13762                   insn2 = 0x38630000;   /* addi 3,3,0 */
13763                   if (tls_gd == 0)
13764                     {
13765                       /* Was an LD reloc.  */
13766                       if (toc_symndx)
13767                         sec = local_sections[toc_symndx];
13768                       for (r_symndx = 0;
13769                            r_symndx < symtab_hdr->sh_info;
13770                            r_symndx++)
13771                         if (local_sections[r_symndx] == sec)
13772                           break;
13773                       if (r_symndx >= symtab_hdr->sh_info)
13774                         r_symndx = STN_UNDEF;
13775                       rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13776                       if (r_symndx != STN_UNDEF)
13777                         rel->r_addend -= (local_syms[r_symndx].st_value
13778                                           + sec->output_offset
13779                                           + sec->output_section->vma);
13780                     }
13781                   else if (toc_symndx != 0)
13782                     {
13783                       r_symndx = toc_symndx;
13784                       rel->r_addend = toc_addend;
13785                     }
13786                   r_type = R_PPC64_TPREL16_HA;
13787                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13788                   if (offset != (bfd_vma) -1)
13789                     {
13790                       rel[1].r_info = ELF64_R_INFO (r_symndx,
13791                                                     R_PPC64_TPREL16_LO);
13792                       rel[1].r_offset = offset + d_offset;
13793                       rel[1].r_addend = rel->r_addend;
13794                     }
13795                 }
13796               bfd_put_32 (output_bfd, insn1,
13797                           contents + rel->r_offset - d_offset);
13798               if (offset != (bfd_vma) -1)
13799                 {
13800                   insn3 = bfd_get_32 (output_bfd,
13801                                       contents + offset + 4);
13802                   if (insn3 == NOP
13803                       || insn3 == CROR_151515 || insn3 == CROR_313131)
13804                     {
13805                       rel[1].r_offset += 4;
13806                       bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13807                       insn2 = NOP;
13808                     }
13809                   bfd_put_32 (output_bfd, insn2, contents + offset);
13810                 }
13811               if ((tls_mask & tls_gd) == 0
13812                   && (tls_gd == 0 || toc_symndx != 0))
13813                 {
13814                   /* We changed the symbol.  Start over in order
13815                      to get h, sym, sec etc. right.  */
13816                   goto again;
13817                 }
13818             }
13819           break;
13820
13821         case R_PPC64_TLSGD:
13822           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13823             {
13824               unsigned int insn2, insn3;
13825               bfd_vma offset = rel->r_offset;
13826
13827               if ((tls_mask & TLS_TPRELGD) != 0)
13828                 {
13829                   /* IE */
13830                   r_type = R_PPC64_NONE;
13831                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13832                 }
13833               else
13834                 {
13835                   /* LE */
13836                   if (toc_symndx != 0)
13837                     {
13838                       r_symndx = toc_symndx;
13839                       rel->r_addend = toc_addend;
13840                     }
13841                   r_type = R_PPC64_TPREL16_LO;
13842                   rel->r_offset = offset + d_offset;
13843                   insn2 = 0x38630000;   /* addi 3,3,0 */
13844                 }
13845               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13846               /* Zap the reloc on the _tls_get_addr call too.  */
13847               BFD_ASSERT (offset == rel[1].r_offset);
13848               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13849               insn3 = bfd_get_32 (output_bfd,
13850                                   contents + offset + 4);
13851               if (insn3 == NOP
13852                   || insn3 == CROR_151515 || insn3 == CROR_313131)
13853                 {
13854                   rel->r_offset += 4;
13855                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13856                   insn2 = NOP;
13857                 }
13858               bfd_put_32 (output_bfd, insn2, contents + offset);
13859               if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
13860                 goto again;
13861             }
13862           break;
13863
13864         case R_PPC64_TLSLD:
13865           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13866             {
13867               unsigned int insn2, insn3;
13868               bfd_vma offset = rel->r_offset;
13869
13870               if (toc_symndx)
13871                 sec = local_sections[toc_symndx];
13872               for (r_symndx = 0;
13873                    r_symndx < symtab_hdr->sh_info;
13874                    r_symndx++)
13875                 if (local_sections[r_symndx] == sec)
13876                   break;
13877               if (r_symndx >= symtab_hdr->sh_info)
13878                 r_symndx = STN_UNDEF;
13879               rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13880               if (r_symndx != STN_UNDEF)
13881                 rel->r_addend -= (local_syms[r_symndx].st_value
13882                                   + sec->output_offset
13883                                   + sec->output_section->vma);
13884
13885               r_type = R_PPC64_TPREL16_LO;
13886               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13887               rel->r_offset = offset + d_offset;
13888               /* Zap the reloc on the _tls_get_addr call too.  */
13889               BFD_ASSERT (offset == rel[1].r_offset);
13890               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13891               insn2 = 0x38630000;       /* addi 3,3,0 */
13892               insn3 = bfd_get_32 (output_bfd,
13893                                   contents + offset + 4);
13894               if (insn3 == NOP
13895                   || insn3 == CROR_151515 || insn3 == CROR_313131)
13896                 {
13897                   rel->r_offset += 4;
13898                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13899                   insn2 = NOP;
13900                 }
13901               bfd_put_32 (output_bfd, insn2, contents + offset);
13902               goto again;
13903             }
13904           break;
13905
13906         case R_PPC64_DTPMOD64:
13907           if (rel + 1 < relend
13908               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
13909               && rel[1].r_offset == rel->r_offset + 8)
13910             {
13911               if ((tls_mask & TLS_GD) == 0)
13912                 {
13913                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
13914                   if ((tls_mask & TLS_TPRELGD) != 0)
13915                     r_type = R_PPC64_TPREL64;
13916                   else
13917                     {
13918                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13919                       r_type = R_PPC64_NONE;
13920                     }
13921                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13922                 }
13923             }
13924           else
13925             {
13926               if ((tls_mask & TLS_LD) == 0)
13927                 {
13928                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13929                   r_type = R_PPC64_NONE;
13930                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13931                 }
13932             }
13933           break;
13934
13935         case R_PPC64_TPREL64:
13936           if ((tls_mask & TLS_TPREL) == 0)
13937             {
13938               r_type = R_PPC64_NONE;
13939               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13940             }
13941           break;
13942
13943         case R_PPC64_ENTRY:
13944           relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
13945           if (!bfd_link_pic (info)
13946               && !info->traditional_format
13947               && relocation + 0x80008000 <= 0xffffffff)
13948             {
13949               unsigned int insn1, insn2;
13950
13951               insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
13952               insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
13953               if ((insn1 & ~0xfffc) == LD_R2_0R12
13954                   && insn2 == ADD_R2_R2_R12)
13955                 {
13956                   bfd_put_32 (output_bfd,
13957                               LIS_R2 + PPC_HA (relocation),
13958                               contents + rel->r_offset);
13959                   bfd_put_32 (output_bfd,
13960                               ADDI_R2_R2 + PPC_LO (relocation),
13961                               contents + rel->r_offset + 4);
13962                 }
13963             }
13964           else
13965             {
13966               relocation -= (rel->r_offset
13967                              + input_section->output_offset
13968                              + input_section->output_section->vma);
13969               if (relocation + 0x80008000 <= 0xffffffff)
13970                 {
13971                   unsigned int insn1, insn2;
13972
13973                   insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
13974                   insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
13975                   if ((insn1 & ~0xfffc) == LD_R2_0R12
13976                       && insn2 == ADD_R2_R2_R12)
13977                     {
13978                       bfd_put_32 (output_bfd,
13979                                   ADDIS_R2_R12 + PPC_HA (relocation),
13980                                   contents + rel->r_offset);
13981                       bfd_put_32 (output_bfd,
13982                                   ADDI_R2_R2 + PPC_LO (relocation),
13983                                   contents + rel->r_offset + 4);
13984                     }
13985                 }
13986             }
13987           break;
13988
13989         case R_PPC64_REL16_HA:
13990           /* If we are generating a non-PIC executable, edit
13991              .  0:      addis 2,12,.TOC.-0b@ha
13992              .          addi 2,2,.TOC.-0b@l
13993              used by ELFv2 global entry points to set up r2, to
13994              .          lis 2,.TOC.@ha
13995              .          addi 2,2,.TOC.@l
13996              if .TOC. is in range.  */
13997           if (!bfd_link_pic (info)
13998               && !info->traditional_format
13999               && !htab->opd_abi
14000               && rel->r_addend == d_offset
14001               && h != NULL && &h->elf == htab->elf.hgot
14002               && rel + 1 < relend
14003               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
14004               && rel[1].r_offset == rel->r_offset + 4
14005               && rel[1].r_addend == rel->r_addend + 4
14006               && relocation + 0x80008000 <= 0xffffffff)
14007             {
14008               unsigned int insn1, insn2;
14009               bfd_vma offset = rel->r_offset - d_offset;
14010               insn1 = bfd_get_32 (output_bfd, contents + offset);
14011               insn2 = bfd_get_32 (output_bfd, contents + offset + 4);
14012               if ((insn1 & 0xffff0000) == ADDIS_R2_R12
14013                   && (insn2 & 0xffff0000) == ADDI_R2_R2)
14014                 {
14015                   r_type = R_PPC64_ADDR16_HA;
14016                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14017                   rel->r_addend -= d_offset;
14018                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
14019                   rel[1].r_addend -= d_offset + 4;
14020                   bfd_put_32 (output_bfd, LIS_R2, contents + offset);
14021                 }
14022             }
14023           break;
14024         }
14025
14026       /* Handle other relocations that tweak non-addend part of insn.  */
14027       insn = 0;
14028       max_br_offset = 1 << 25;
14029       addend = rel->r_addend;
14030       reloc_dest = DEST_NORMAL;
14031       switch (r_type)
14032         {
14033         default:
14034           break;
14035
14036         case R_PPC64_TOCSAVE:
14037           if (relocation + addend == (rel->r_offset
14038                                       + input_section->output_offset
14039                                       + input_section->output_section->vma)
14040               && tocsave_find (htab, NO_INSERT,
14041                                &local_syms, rel, input_bfd))
14042             {
14043               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
14044               if (insn == NOP
14045                   || insn == CROR_151515 || insn == CROR_313131)
14046                 bfd_put_32 (input_bfd,
14047                             STD_R2_0R1 + STK_TOC (htab),
14048                             contents + rel->r_offset);
14049             }
14050           break;
14051
14052           /* Branch taken prediction relocations.  */
14053         case R_PPC64_ADDR14_BRTAKEN:
14054         case R_PPC64_REL14_BRTAKEN:
14055           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
14056           /* Fall thru.  */
14057
14058           /* Branch not taken prediction relocations.  */
14059         case R_PPC64_ADDR14_BRNTAKEN:
14060         case R_PPC64_REL14_BRNTAKEN:
14061           insn |= bfd_get_32 (output_bfd,
14062                               contents + rel->r_offset) & ~(0x01 << 21);
14063           /* Fall thru.  */
14064
14065         case R_PPC64_REL14:
14066           max_br_offset = 1 << 15;
14067           /* Fall thru.  */
14068
14069         case R_PPC64_REL24:
14070           /* Calls to functions with a different TOC, such as calls to
14071              shared objects, need to alter the TOC pointer.  This is
14072              done using a linkage stub.  A REL24 branching to these
14073              linkage stubs needs to be followed by a nop, as the nop
14074              will be replaced with an instruction to restore the TOC
14075              base pointer.  */
14076           fdh = h;
14077           if (h != NULL
14078               && h->oh != NULL
14079               && h->oh->is_func_descriptor)
14080             fdh = ppc_follow_link (h->oh);
14081           stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
14082                                            htab);
14083           if (stub_entry != NULL
14084               && (stub_entry->stub_type == ppc_stub_plt_call
14085                   || stub_entry->stub_type == ppc_stub_plt_call_r2save
14086                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
14087                   || stub_entry->stub_type == ppc_stub_long_branch_r2off))
14088             {
14089               bfd_boolean can_plt_call = FALSE;
14090
14091               /* All of these stubs will modify r2, so there must be a
14092                  branch and link followed by a nop.  The nop is
14093                  replaced by an insn to restore r2.  */
14094               if (rel->r_offset + 8 <= input_section->size)
14095                 {
14096                   unsigned long br;
14097
14098                   br = bfd_get_32 (input_bfd,
14099                                    contents + rel->r_offset);
14100                   if ((br & 1) != 0)
14101                     {
14102                       unsigned long nop;
14103
14104                       nop = bfd_get_32 (input_bfd,
14105                                         contents + rel->r_offset + 4);
14106                       if (nop == NOP
14107                           || nop == CROR_151515 || nop == CROR_313131)
14108                         {
14109                           if (h != NULL
14110                               && (h == htab->tls_get_addr_fd
14111                                   || h == htab->tls_get_addr)
14112                               && htab->params->tls_get_addr_opt)
14113                             {
14114                               /* Special stub used, leave nop alone.  */
14115                             }
14116                           else
14117                             bfd_put_32 (input_bfd,
14118                                         LD_R2_0R1 + STK_TOC (htab),
14119                                         contents + rel->r_offset + 4);
14120                           can_plt_call = TRUE;
14121                         }
14122                     }
14123                 }
14124
14125               if (!can_plt_call && h != NULL)
14126                 {
14127                   const char *name = h->elf.root.root.string;
14128
14129                   if (*name == '.')
14130                     ++name;
14131
14132                   if (strncmp (name, "__libc_start_main", 17) == 0
14133                       && (name[17] == 0 || name[17] == '@'))
14134                     {
14135                       /* Allow crt1 branch to go via a toc adjusting
14136                          stub.  Other calls that never return could do
14137                          the same, if we could detect such.  */
14138                       can_plt_call = TRUE;
14139                     }
14140                 }
14141
14142               if (!can_plt_call)
14143                 {
14144                   /* g++ as of 20130507 emits self-calls without a
14145                      following nop.  This is arguably wrong since we
14146                      have conflicting information.  On the one hand a
14147                      global symbol and on the other a local call
14148                      sequence, but don't error for this special case.
14149                      It isn't possible to cheaply verify we have
14150                      exactly such a call.  Allow all calls to the same
14151                      section.  */
14152                   asection *code_sec = sec;
14153
14154                   if (get_opd_info (sec) != NULL)
14155                     {
14156                       bfd_vma off = (relocation + addend
14157                                      - sec->output_section->vma
14158                                      - sec->output_offset);
14159
14160                       opd_entry_value (sec, off, &code_sec, NULL, FALSE);
14161                     }
14162                   if (code_sec == input_section)
14163                     can_plt_call = TRUE;
14164                 }
14165
14166               if (!can_plt_call)
14167                 {
14168                   if (stub_entry->stub_type == ppc_stub_plt_call
14169                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14170                     info->callbacks->einfo
14171                       (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
14172                          "recompile with -fPIC\n"),
14173                        input_bfd, input_section, rel->r_offset, sym_name);
14174                   else
14175                     info->callbacks->einfo
14176                       (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
14177                          "(-mcmodel=small toc adjust stub)\n"),
14178                        input_bfd, input_section, rel->r_offset, sym_name);
14179
14180                   bfd_set_error (bfd_error_bad_value);
14181                   ret = FALSE;
14182                 }
14183
14184               if (can_plt_call
14185                   && (stub_entry->stub_type == ppc_stub_plt_call
14186                       || stub_entry->stub_type == ppc_stub_plt_call_r2save))
14187                 unresolved_reloc = FALSE;
14188             }
14189
14190           if ((stub_entry == NULL
14191                || stub_entry->stub_type == ppc_stub_long_branch
14192                || stub_entry->stub_type == ppc_stub_plt_branch)
14193               && get_opd_info (sec) != NULL)
14194             {
14195               /* The branch destination is the value of the opd entry. */
14196               bfd_vma off = (relocation + addend
14197                              - sec->output_section->vma
14198                              - sec->output_offset);
14199               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
14200               if (dest != (bfd_vma) -1)
14201                 {
14202                   relocation = dest;
14203                   addend = 0;
14204                   reloc_dest = DEST_OPD;
14205                 }
14206             }
14207
14208           /* If the branch is out of reach we ought to have a long
14209              branch stub.  */
14210           from = (rel->r_offset
14211                   + input_section->output_offset
14212                   + input_section->output_section->vma);
14213
14214           relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
14215                                                   ? fdh->elf.other
14216                                                   : sym->st_other);
14217
14218           if (stub_entry != NULL
14219               && (stub_entry->stub_type == ppc_stub_long_branch
14220                   || stub_entry->stub_type == ppc_stub_plt_branch)
14221               && (r_type == R_PPC64_ADDR14_BRTAKEN
14222                   || r_type == R_PPC64_ADDR14_BRNTAKEN
14223                   || (relocation + addend - from + max_br_offset
14224                       < 2 * max_br_offset)))
14225             /* Don't use the stub if this branch is in range.  */
14226             stub_entry = NULL;
14227
14228           if (stub_entry != NULL)
14229             {
14230               /* Munge up the value and addend so that we call the stub
14231                  rather than the procedure directly.  */
14232               asection *stub_sec = stub_entry->group->stub_sec;
14233
14234               if (stub_entry->stub_type == ppc_stub_save_res)
14235                 relocation += (stub_sec->output_offset
14236                                + stub_sec->output_section->vma
14237                                + stub_sec->size - htab->sfpr->size
14238                                - htab->sfpr->output_offset
14239                                - htab->sfpr->output_section->vma);
14240               else
14241                 relocation = (stub_entry->stub_offset
14242                               + stub_sec->output_offset
14243                               + stub_sec->output_section->vma);
14244               addend = 0;
14245               reloc_dest = DEST_STUB;
14246
14247               if ((stub_entry->stub_type == ppc_stub_plt_call
14248                    || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14249                   && (ALWAYS_EMIT_R2SAVE
14250                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14251                   && rel + 1 < relend
14252                   && rel[1].r_offset == rel->r_offset + 4
14253                   && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
14254                 relocation += 4;
14255             }
14256
14257           if (insn != 0)
14258             {
14259               if (is_isa_v2)
14260                 {
14261                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
14262                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
14263                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
14264                   if ((insn & (0x14 << 21)) == (0x04 << 21))
14265                     insn |= 0x02 << 21;
14266                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
14267                     insn |= 0x08 << 21;
14268                   else
14269                     break;
14270                 }
14271               else
14272                 {
14273                   /* Invert 'y' bit if not the default.  */
14274                   if ((bfd_signed_vma) (relocation + addend - from) < 0)
14275                     insn ^= 0x01 << 21;
14276                 }
14277
14278               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
14279             }
14280
14281           /* NOP out calls to undefined weak functions.
14282              We can thus call a weak function without first
14283              checking whether the function is defined.  */
14284           else if (h != NULL
14285                    && h->elf.root.type == bfd_link_hash_undefweak
14286                    && h->elf.dynindx == -1
14287                    && r_type == R_PPC64_REL24
14288                    && relocation == 0
14289                    && addend == 0)
14290             {
14291               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
14292               goto copy_reloc;
14293             }
14294           break;
14295         }
14296
14297       /* Set `addend'.  */
14298       tls_type = 0;
14299       switch (r_type)
14300         {
14301         default:
14302           info->callbacks->einfo
14303             (_("%P: %B: unknown relocation type %d for `%T'\n"),
14304              input_bfd, (int) r_type, sym_name);
14305
14306           bfd_set_error (bfd_error_bad_value);
14307           ret = FALSE;
14308           goto copy_reloc;
14309
14310         case R_PPC64_NONE:
14311         case R_PPC64_TLS:
14312         case R_PPC64_TLSGD:
14313         case R_PPC64_TLSLD:
14314         case R_PPC64_TOCSAVE:
14315         case R_PPC64_GNU_VTINHERIT:
14316         case R_PPC64_GNU_VTENTRY:
14317         case R_PPC64_ENTRY:
14318           goto copy_reloc;
14319
14320           /* GOT16 relocations.  Like an ADDR16 using the symbol's
14321              address in the GOT as relocation value instead of the
14322              symbol's value itself.  Also, create a GOT entry for the
14323              symbol and put the symbol value there.  */
14324         case R_PPC64_GOT_TLSGD16:
14325         case R_PPC64_GOT_TLSGD16_LO:
14326         case R_PPC64_GOT_TLSGD16_HI:
14327         case R_PPC64_GOT_TLSGD16_HA:
14328           tls_type = TLS_TLS | TLS_GD;
14329           goto dogot;
14330
14331         case R_PPC64_GOT_TLSLD16:
14332         case R_PPC64_GOT_TLSLD16_LO:
14333         case R_PPC64_GOT_TLSLD16_HI:
14334         case R_PPC64_GOT_TLSLD16_HA:
14335           tls_type = TLS_TLS | TLS_LD;
14336           goto dogot;
14337
14338         case R_PPC64_GOT_TPREL16_DS:
14339         case R_PPC64_GOT_TPREL16_LO_DS:
14340         case R_PPC64_GOT_TPREL16_HI:
14341         case R_PPC64_GOT_TPREL16_HA:
14342           tls_type = TLS_TLS | TLS_TPREL;
14343           goto dogot;
14344
14345         case R_PPC64_GOT_DTPREL16_DS:
14346         case R_PPC64_GOT_DTPREL16_LO_DS:
14347         case R_PPC64_GOT_DTPREL16_HI:
14348         case R_PPC64_GOT_DTPREL16_HA:
14349           tls_type = TLS_TLS | TLS_DTPREL;
14350           goto dogot;
14351
14352         case R_PPC64_GOT16:
14353         case R_PPC64_GOT16_LO:
14354         case R_PPC64_GOT16_HI:
14355         case R_PPC64_GOT16_HA:
14356         case R_PPC64_GOT16_DS:
14357         case R_PPC64_GOT16_LO_DS:
14358         dogot:
14359           {
14360             /* Relocation is to the entry for this symbol in the global
14361                offset table.  */
14362             asection *got;
14363             bfd_vma *offp;
14364             bfd_vma off;
14365             unsigned long indx = 0;
14366             struct got_entry *ent;
14367
14368             if (tls_type == (TLS_TLS | TLS_LD)
14369                 && (h == NULL
14370                     || !h->elf.def_dynamic))
14371               ent = ppc64_tlsld_got (input_bfd);
14372             else
14373               {
14374
14375                 if (h != NULL)
14376                   {
14377                     bfd_boolean dyn = htab->elf.dynamic_sections_created;
14378                     if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info),
14379                                                           &h->elf)
14380                         || (bfd_link_pic (info)
14381                             && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
14382                       /* This is actually a static link, or it is a
14383                          -Bsymbolic link and the symbol is defined
14384                          locally, or the symbol was forced to be local
14385                          because of a version file.  */
14386                       ;
14387                     else
14388                       {
14389                         BFD_ASSERT (h->elf.dynindx != -1);
14390                         indx = h->elf.dynindx;
14391                         unresolved_reloc = FALSE;
14392                       }
14393                     ent = h->elf.got.glist;
14394                   }
14395                 else
14396                   {
14397                     if (local_got_ents == NULL)
14398                       abort ();
14399                     ent = local_got_ents[r_symndx];
14400                   }
14401
14402                 for (; ent != NULL; ent = ent->next)
14403                   if (ent->addend == orig_rel.r_addend
14404                       && ent->owner == input_bfd
14405                       && ent->tls_type == tls_type)
14406                     break;
14407               }
14408
14409             if (ent == NULL)
14410               abort ();
14411             if (ent->is_indirect)
14412               ent = ent->got.ent;
14413             offp = &ent->got.offset;
14414             got = ppc64_elf_tdata (ent->owner)->got;
14415             if (got == NULL)
14416               abort ();
14417
14418             /* The offset must always be a multiple of 8.  We use the
14419                least significant bit to record whether we have already
14420                processed this entry.  */
14421             off = *offp;
14422             if ((off & 1) != 0)
14423               off &= ~1;
14424             else
14425               {
14426                 /* Generate relocs for the dynamic linker, except in
14427                    the case of TLSLD where we'll use one entry per
14428                    module.  */
14429                 asection *relgot;
14430                 bfd_boolean ifunc;
14431
14432                 *offp = off | 1;
14433                 relgot = NULL;
14434                 ifunc = (h != NULL
14435                          ? h->elf.type == STT_GNU_IFUNC
14436                          : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
14437                 if (ifunc)
14438                   relgot = htab->elf.irelplt;
14439                 else if ((bfd_link_pic (info) || indx != 0)
14440                          && (h == NULL
14441                              || (tls_type == (TLS_TLS | TLS_LD)
14442                                  && !h->elf.def_dynamic)
14443                              || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14444                              || h->elf.root.type != bfd_link_hash_undefweak))
14445                   relgot = ppc64_elf_tdata (ent->owner)->relgot;
14446                 if (relgot != NULL)
14447                   {
14448                     outrel.r_offset = (got->output_section->vma
14449                                        + got->output_offset
14450                                        + off);
14451                     outrel.r_addend = addend;
14452                     if (tls_type & (TLS_LD | TLS_GD))
14453                       {
14454                         outrel.r_addend = 0;
14455                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
14456                         if (tls_type == (TLS_TLS | TLS_GD))
14457                           {
14458                             loc = relgot->contents;
14459                             loc += (relgot->reloc_count++
14460                                     * sizeof (Elf64_External_Rela));
14461                             bfd_elf64_swap_reloca_out (output_bfd,
14462                                                        &outrel, loc);
14463                             outrel.r_offset += 8;
14464                             outrel.r_addend = addend;
14465                             outrel.r_info
14466                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14467                           }
14468                       }
14469                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
14470                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14471                     else if (tls_type == (TLS_TLS | TLS_TPREL))
14472                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
14473                     else if (indx != 0)
14474                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
14475                     else
14476                       {
14477                         if (ifunc)
14478                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14479                         else
14480                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14481
14482                         /* Write the .got section contents for the sake
14483                            of prelink.  */
14484                         loc = got->contents + off;
14485                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
14486                                     loc);
14487                       }
14488
14489                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
14490                       {
14491                         outrel.r_addend += relocation;
14492                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
14493                           {
14494                             if (htab->elf.tls_sec == NULL)
14495                               outrel.r_addend = 0;
14496                             else
14497                               outrel.r_addend -= htab->elf.tls_sec->vma;
14498                           }
14499                       }
14500                     loc = relgot->contents;
14501                     loc += (relgot->reloc_count++
14502                             * sizeof (Elf64_External_Rela));
14503                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14504                   }
14505
14506                 /* Init the .got section contents here if we're not
14507                    emitting a reloc.  */
14508                 else
14509                   {
14510                     relocation += addend;
14511                     if (tls_type == (TLS_TLS | TLS_LD))
14512                       relocation = 1;
14513                     else if (tls_type != 0)
14514                       {
14515                         if (htab->elf.tls_sec == NULL)
14516                           relocation = 0;
14517                         else
14518                           {
14519                             relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
14520                             if (tls_type == (TLS_TLS | TLS_TPREL))
14521                               relocation += DTP_OFFSET - TP_OFFSET;
14522                           }
14523
14524                         if (tls_type == (TLS_TLS | TLS_GD))
14525                           {
14526                             bfd_put_64 (output_bfd, relocation,
14527                                         got->contents + off + 8);
14528                             relocation = 1;
14529                           }
14530                       }
14531
14532                     bfd_put_64 (output_bfd, relocation,
14533                                 got->contents + off);
14534                   }
14535               }
14536
14537             if (off >= (bfd_vma) -2)
14538               abort ();
14539
14540             relocation = got->output_section->vma + got->output_offset + off;
14541             addend = -(TOCstart + htab->sec_info[input_section->id].toc_off);
14542           }
14543           break;
14544
14545         case R_PPC64_PLT16_HA:
14546         case R_PPC64_PLT16_HI:
14547         case R_PPC64_PLT16_LO:
14548         case R_PPC64_PLT32:
14549         case R_PPC64_PLT64:
14550           /* Relocation is to the entry for this symbol in the
14551              procedure linkage table.  */
14552           {
14553             struct plt_entry **plt_list = NULL;
14554             if (h != NULL)
14555               plt_list = &h->elf.plt.plist;
14556             else if (local_got_ents != NULL)
14557               {
14558                 struct plt_entry **local_plt = (struct plt_entry **)
14559                   (local_got_ents + symtab_hdr->sh_info);
14560                 unsigned char *local_got_tls_masks = (unsigned char *)
14561                   (local_plt + symtab_hdr->sh_info);
14562                 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
14563                   plt_list = local_plt + r_symndx;
14564               }
14565             if (plt_list)
14566               {
14567                 struct plt_entry *ent;
14568
14569                 for (ent = *plt_list; ent != NULL; ent = ent->next)
14570                   if (ent->plt.offset != (bfd_vma) -1
14571                       && ent->addend == orig_rel.r_addend)
14572                     {
14573                       asection *plt;
14574
14575                       plt = htab->elf.splt;
14576                       if (!htab->elf.dynamic_sections_created
14577                           || h == NULL
14578                           || h->elf.dynindx == -1)
14579                         plt = htab->elf.iplt;
14580                       relocation = (plt->output_section->vma
14581                                     + plt->output_offset
14582                                     + ent->plt.offset);
14583                       addend = 0;
14584                       unresolved_reloc = FALSE;
14585                       break;
14586                     }
14587               }
14588           }
14589           break;
14590
14591         case R_PPC64_TOC:
14592           /* Relocation value is TOC base.  */
14593           relocation = TOCstart;
14594           if (r_symndx == STN_UNDEF)
14595             relocation += htab->sec_info[input_section->id].toc_off;
14596           else if (unresolved_reloc)
14597             ;
14598           else if (sec != NULL && sec->id < htab->sec_info_arr_size)
14599             relocation += htab->sec_info[sec->id].toc_off;
14600           else
14601             unresolved_reloc = TRUE;
14602           goto dodyn;
14603
14604           /* TOC16 relocs.  We want the offset relative to the TOC base,
14605              which is the address of the start of the TOC plus 0x8000.
14606              The TOC consists of sections .got, .toc, .tocbss, and .plt,
14607              in this order.  */
14608         case R_PPC64_TOC16:
14609         case R_PPC64_TOC16_LO:
14610         case R_PPC64_TOC16_HI:
14611         case R_PPC64_TOC16_DS:
14612         case R_PPC64_TOC16_LO_DS:
14613         case R_PPC64_TOC16_HA:
14614           addend -= TOCstart + htab->sec_info[input_section->id].toc_off;
14615           break;
14616
14617           /* Relocate against the beginning of the section.  */
14618         case R_PPC64_SECTOFF:
14619         case R_PPC64_SECTOFF_LO:
14620         case R_PPC64_SECTOFF_HI:
14621         case R_PPC64_SECTOFF_DS:
14622         case R_PPC64_SECTOFF_LO_DS:
14623         case R_PPC64_SECTOFF_HA:
14624           if (sec != NULL)
14625             addend -= sec->output_section->vma;
14626           break;
14627
14628         case R_PPC64_REL16:
14629         case R_PPC64_REL16_LO:
14630         case R_PPC64_REL16_HI:
14631         case R_PPC64_REL16_HA:
14632         case R_PPC64_REL16DX_HA:
14633           break;
14634
14635         case R_PPC64_REL14:
14636         case R_PPC64_REL14_BRNTAKEN:
14637         case R_PPC64_REL14_BRTAKEN:
14638         case R_PPC64_REL24:
14639           break;
14640
14641         case R_PPC64_TPREL16:
14642         case R_PPC64_TPREL16_LO:
14643         case R_PPC64_TPREL16_HI:
14644         case R_PPC64_TPREL16_HA:
14645         case R_PPC64_TPREL16_DS:
14646         case R_PPC64_TPREL16_LO_DS:
14647         case R_PPC64_TPREL16_HIGH:
14648         case R_PPC64_TPREL16_HIGHA:
14649         case R_PPC64_TPREL16_HIGHER:
14650         case R_PPC64_TPREL16_HIGHERA:
14651         case R_PPC64_TPREL16_HIGHEST:
14652         case R_PPC64_TPREL16_HIGHESTA:
14653           if (h != NULL
14654               && h->elf.root.type == bfd_link_hash_undefweak
14655               && h->elf.dynindx == -1)
14656             {
14657               /* Make this relocation against an undefined weak symbol
14658                  resolve to zero.  This is really just a tweak, since
14659                  code using weak externs ought to check that they are
14660                  defined before using them.  */
14661               bfd_byte *p = contents + rel->r_offset - d_offset;
14662
14663               insn = bfd_get_32 (output_bfd, p);
14664               insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14665               if (insn != 0)
14666                 bfd_put_32 (output_bfd, insn, p);
14667               break;
14668             }
14669           if (htab->elf.tls_sec != NULL)
14670             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14671           if (bfd_link_pic (info))
14672             /* The TPREL16 relocs shouldn't really be used in shared
14673                libs as they will result in DT_TEXTREL being set, but
14674                support them anyway.  */
14675             goto dodyn;
14676           break;
14677
14678         case R_PPC64_DTPREL16:
14679         case R_PPC64_DTPREL16_LO:
14680         case R_PPC64_DTPREL16_HI:
14681         case R_PPC64_DTPREL16_HA:
14682         case R_PPC64_DTPREL16_DS:
14683         case R_PPC64_DTPREL16_LO_DS:
14684         case R_PPC64_DTPREL16_HIGH:
14685         case R_PPC64_DTPREL16_HIGHA:
14686         case R_PPC64_DTPREL16_HIGHER:
14687         case R_PPC64_DTPREL16_HIGHERA:
14688         case R_PPC64_DTPREL16_HIGHEST:
14689         case R_PPC64_DTPREL16_HIGHESTA:
14690           if (htab->elf.tls_sec != NULL)
14691             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14692           break;
14693
14694         case R_PPC64_ADDR64_LOCAL:
14695           addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
14696                                               ? h->elf.other
14697                                               : sym->st_other);
14698           break;
14699
14700         case R_PPC64_DTPMOD64:
14701           relocation = 1;
14702           addend = 0;
14703           goto dodyn;
14704
14705         case R_PPC64_TPREL64:
14706           if (htab->elf.tls_sec != NULL)
14707             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14708           goto dodyn;
14709
14710         case R_PPC64_DTPREL64:
14711           if (htab->elf.tls_sec != NULL)
14712             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14713           /* Fall thru */
14714
14715           /* Relocations that may need to be propagated if this is a
14716              dynamic object.  */
14717         case R_PPC64_REL30:
14718         case R_PPC64_REL32:
14719         case R_PPC64_REL64:
14720         case R_PPC64_ADDR14:
14721         case R_PPC64_ADDR14_BRNTAKEN:
14722         case R_PPC64_ADDR14_BRTAKEN:
14723         case R_PPC64_ADDR16:
14724         case R_PPC64_ADDR16_DS:
14725         case R_PPC64_ADDR16_HA:
14726         case R_PPC64_ADDR16_HI:
14727         case R_PPC64_ADDR16_HIGH:
14728         case R_PPC64_ADDR16_HIGHA:
14729         case R_PPC64_ADDR16_HIGHER:
14730         case R_PPC64_ADDR16_HIGHERA:
14731         case R_PPC64_ADDR16_HIGHEST:
14732         case R_PPC64_ADDR16_HIGHESTA:
14733         case R_PPC64_ADDR16_LO:
14734         case R_PPC64_ADDR16_LO_DS:
14735         case R_PPC64_ADDR24:
14736         case R_PPC64_ADDR32:
14737         case R_PPC64_ADDR64:
14738         case R_PPC64_UADDR16:
14739         case R_PPC64_UADDR32:
14740         case R_PPC64_UADDR64:
14741         dodyn:
14742           if ((input_section->flags & SEC_ALLOC) == 0)
14743             break;
14744
14745           if (NO_OPD_RELOCS && is_opd)
14746             break;
14747
14748           if (h != NULL
14749               ? h->dyn_relocs != NULL
14750               : (bfd_link_pic (info)
14751                  ? must_be_dyn_reloc (info, r_type)
14752                  : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14753             {
14754               bfd_boolean skip, relocate;
14755               asection *sreloc;
14756               bfd_vma out_off;
14757
14758               /* When generating a dynamic object, these relocations
14759                  are copied into the output file to be resolved at run
14760                  time.  */
14761
14762               skip = FALSE;
14763               relocate = FALSE;
14764
14765               out_off = _bfd_elf_section_offset (output_bfd, info,
14766                                                  input_section, rel->r_offset);
14767               if (out_off == (bfd_vma) -1)
14768                 skip = TRUE;
14769               else if (out_off == (bfd_vma) -2)
14770                 skip = TRUE, relocate = TRUE;
14771               out_off += (input_section->output_section->vma
14772                           + input_section->output_offset);
14773               outrel.r_offset = out_off;
14774               outrel.r_addend = rel->r_addend;
14775
14776               /* Optimize unaligned reloc use.  */
14777               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14778                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14779                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14780               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14781                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
14782                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
14783               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
14784                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
14785                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
14786
14787               if (skip)
14788                 memset (&outrel, 0, sizeof outrel);
14789               else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14790                        && !is_opd
14791                        && r_type != R_PPC64_TOC)
14792                 {
14793                   BFD_ASSERT (h->elf.dynindx != -1);
14794                   outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
14795                 }
14796               else
14797                 {
14798                   /* This symbol is local, or marked to become local,
14799                      or this is an opd section reloc which must point
14800                      at a local function.  */
14801                   outrel.r_addend += relocation;
14802                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
14803                     {
14804                       if (is_opd && h != NULL)
14805                         {
14806                           /* Lie about opd entries.  This case occurs
14807                              when building shared libraries and we
14808                              reference a function in another shared
14809                              lib.  The same thing happens for a weak
14810                              definition in an application that's
14811                              overridden by a strong definition in a
14812                              shared lib.  (I believe this is a generic
14813                              bug in binutils handling of weak syms.)
14814                              In these cases we won't use the opd
14815                              entry in this lib.  */
14816                           unresolved_reloc = FALSE;
14817                         }
14818                       if (!is_opd
14819                           && r_type == R_PPC64_ADDR64
14820                           && (h != NULL
14821                               ? h->elf.type == STT_GNU_IFUNC
14822                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14823                         outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14824                       else
14825                         {
14826                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14827
14828                           /* We need to relocate .opd contents for ld.so.
14829                              Prelink also wants simple and consistent rules
14830                              for relocs.  This make all RELATIVE relocs have
14831                              *r_offset equal to r_addend.  */
14832                           relocate = TRUE;
14833                         }
14834                     }
14835                   else
14836                     {
14837                       long indx = 0;
14838
14839                       if (h != NULL
14840                           ? h->elf.type == STT_GNU_IFUNC
14841                           : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14842                         {
14843                           info->callbacks->einfo
14844                             (_("%P: %H: %s for indirect "
14845                                "function `%T' unsupported\n"),
14846                              input_bfd, input_section, rel->r_offset,
14847                              ppc64_elf_howto_table[r_type]->name,
14848                              sym_name);
14849                           ret = FALSE;
14850                         }
14851                       else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
14852                         ;
14853                       else if (sec == NULL || sec->owner == NULL)
14854                         {
14855                           bfd_set_error (bfd_error_bad_value);
14856                           return FALSE;
14857                         }
14858                       else
14859                         {
14860                           asection *osec;
14861
14862                           osec = sec->output_section;
14863                           indx = elf_section_data (osec)->dynindx;
14864
14865                           if (indx == 0)
14866                             {
14867                               if ((osec->flags & SEC_READONLY) == 0
14868                                   && htab->elf.data_index_section != NULL)
14869                                 osec = htab->elf.data_index_section;
14870                               else
14871                                 osec = htab->elf.text_index_section;
14872                               indx = elf_section_data (osec)->dynindx;
14873                             }
14874                           BFD_ASSERT (indx != 0);
14875
14876                           /* We are turning this relocation into one
14877                              against a section symbol, so subtract out
14878                              the output section's address but not the
14879                              offset of the input section in the output
14880                              section.  */
14881                           outrel.r_addend -= osec->vma;
14882                         }
14883
14884                       outrel.r_info = ELF64_R_INFO (indx, r_type);
14885                     }
14886                 }
14887
14888               sreloc = elf_section_data (input_section)->sreloc;
14889               if (h != NULL
14890                   ? h->elf.type == STT_GNU_IFUNC
14891                   : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14892                 sreloc = htab->elf.irelplt;
14893               if (sreloc == NULL)
14894                 abort ();
14895
14896               if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
14897                   >= sreloc->size)
14898                 abort ();
14899               loc = sreloc->contents;
14900               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
14901               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14902
14903               /* If this reloc is against an external symbol, it will
14904                  be computed at runtime, so there's no need to do
14905                  anything now.  However, for the sake of prelink ensure
14906                  that the section contents are a known value.  */
14907               if (! relocate)
14908                 {
14909                   unresolved_reloc = FALSE;
14910                   /* The value chosen here is quite arbitrary as ld.so
14911                      ignores section contents except for the special
14912                      case of .opd where the contents might be accessed
14913                      before relocation.  Choose zero, as that won't
14914                      cause reloc overflow.  */
14915                   relocation = 0;
14916                   addend = 0;
14917                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
14918                      to improve backward compatibility with older
14919                      versions of ld.  */
14920                   if (r_type == R_PPC64_ADDR64)
14921                     addend = outrel.r_addend;
14922                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
14923                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
14924                     addend = (input_section->output_section->vma
14925                               + input_section->output_offset
14926                               + rel->r_offset);
14927                 }
14928             }
14929           break;
14930
14931         case R_PPC64_COPY:
14932         case R_PPC64_GLOB_DAT:
14933         case R_PPC64_JMP_SLOT:
14934         case R_PPC64_JMP_IREL:
14935         case R_PPC64_RELATIVE:
14936           /* We shouldn't ever see these dynamic relocs in relocatable
14937              files.  */
14938           /* Fall through.  */
14939
14940         case R_PPC64_PLTGOT16:
14941         case R_PPC64_PLTGOT16_DS:
14942         case R_PPC64_PLTGOT16_HA:
14943         case R_PPC64_PLTGOT16_HI:
14944         case R_PPC64_PLTGOT16_LO:
14945         case R_PPC64_PLTGOT16_LO_DS:
14946         case R_PPC64_PLTREL32:
14947         case R_PPC64_PLTREL64:
14948           /* These ones haven't been implemented yet.  */
14949
14950           info->callbacks->einfo
14951             (_("%P: %B: %s is not supported for `%T'\n"),
14952              input_bfd,
14953              ppc64_elf_howto_table[r_type]->name, sym_name);
14954
14955           bfd_set_error (bfd_error_invalid_operation);
14956           ret = FALSE;
14957           goto copy_reloc;
14958         }
14959
14960       /* Multi-instruction sequences that access the TOC can be
14961          optimized, eg. addis ra,r2,0; addi rb,ra,x;
14962          to             nop;           addi rb,r2,x;  */
14963       switch (r_type)
14964         {
14965         default:
14966           break;
14967
14968         case R_PPC64_GOT_TLSLD16_HI:
14969         case R_PPC64_GOT_TLSGD16_HI:
14970         case R_PPC64_GOT_TPREL16_HI:
14971         case R_PPC64_GOT_DTPREL16_HI:
14972         case R_PPC64_GOT16_HI:
14973         case R_PPC64_TOC16_HI:
14974           /* These relocs would only be useful if building up an
14975              offset to later add to r2, perhaps in an indexed
14976              addressing mode instruction.  Don't try to optimize.
14977              Unfortunately, the possibility of someone building up an
14978              offset like this or even with the HA relocs, means that
14979              we need to check the high insn when optimizing the low
14980              insn.  */
14981           break;
14982
14983         case R_PPC64_GOT_TLSLD16_HA:
14984         case R_PPC64_GOT_TLSGD16_HA:
14985         case R_PPC64_GOT_TPREL16_HA:
14986         case R_PPC64_GOT_DTPREL16_HA:
14987         case R_PPC64_GOT16_HA:
14988         case R_PPC64_TOC16_HA:
14989           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14990               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14991             {
14992               bfd_byte *p = contents + (rel->r_offset & ~3);
14993               bfd_put_32 (input_bfd, NOP, p);
14994             }
14995           break;
14996
14997         case R_PPC64_GOT_TLSLD16_LO:
14998         case R_PPC64_GOT_TLSGD16_LO:
14999         case R_PPC64_GOT_TPREL16_LO_DS:
15000         case R_PPC64_GOT_DTPREL16_LO_DS:
15001         case R_PPC64_GOT16_LO:
15002         case R_PPC64_GOT16_LO_DS:
15003         case R_PPC64_TOC16_LO:
15004         case R_PPC64_TOC16_LO_DS:
15005           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
15006               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
15007             {
15008               bfd_byte *p = contents + (rel->r_offset & ~3);
15009               insn = bfd_get_32 (input_bfd, p);
15010               if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
15011                 {
15012                   /* Transform addic to addi when we change reg.  */
15013                   insn &= ~((0x3f << 26) | (0x1f << 16));
15014                   insn |= (14u << 26) | (2 << 16);
15015                 }
15016               else
15017                 {
15018                   insn &= ~(0x1f << 16);
15019                   insn |= 2 << 16;
15020                 }
15021               bfd_put_32 (input_bfd, insn, p);
15022             }
15023           break;
15024         }
15025
15026       /* Do any further special processing.  */
15027       howto = ppc64_elf_howto_table[(int) r_type];
15028       switch (r_type)
15029         {
15030         default:
15031           break;
15032
15033         case R_PPC64_REL16_HA:
15034         case R_PPC64_REL16DX_HA:
15035         case R_PPC64_ADDR16_HA:
15036         case R_PPC64_ADDR16_HIGHA:
15037         case R_PPC64_ADDR16_HIGHERA:
15038         case R_PPC64_ADDR16_HIGHESTA:
15039         case R_PPC64_TOC16_HA:
15040         case R_PPC64_SECTOFF_HA:
15041         case R_PPC64_TPREL16_HA:
15042         case R_PPC64_TPREL16_HIGHA:
15043         case R_PPC64_TPREL16_HIGHERA:
15044         case R_PPC64_TPREL16_HIGHESTA:
15045         case R_PPC64_DTPREL16_HA:
15046         case R_PPC64_DTPREL16_HIGHA:
15047         case R_PPC64_DTPREL16_HIGHERA:
15048         case R_PPC64_DTPREL16_HIGHESTA:
15049           /* It's just possible that this symbol is a weak symbol
15050              that's not actually defined anywhere. In that case,
15051              'sec' would be NULL, and we should leave the symbol
15052              alone (it will be set to zero elsewhere in the link).  */
15053           if (sec == NULL)
15054             break;
15055           /* Fall thru */
15056
15057         case R_PPC64_GOT16_HA:
15058         case R_PPC64_PLTGOT16_HA:
15059         case R_PPC64_PLT16_HA:
15060         case R_PPC64_GOT_TLSGD16_HA:
15061         case R_PPC64_GOT_TLSLD16_HA:
15062         case R_PPC64_GOT_TPREL16_HA:
15063         case R_PPC64_GOT_DTPREL16_HA:
15064           /* Add 0x10000 if sign bit in 0:15 is set.
15065              Bits 0:15 are not used.  */
15066           addend += 0x8000;
15067           break;
15068
15069         case R_PPC64_ADDR16_DS:
15070         case R_PPC64_ADDR16_LO_DS:
15071         case R_PPC64_GOT16_DS:
15072         case R_PPC64_GOT16_LO_DS:
15073         case R_PPC64_PLT16_LO_DS:
15074         case R_PPC64_SECTOFF_DS:
15075         case R_PPC64_SECTOFF_LO_DS:
15076         case R_PPC64_TOC16_DS:
15077         case R_PPC64_TOC16_LO_DS:
15078         case R_PPC64_PLTGOT16_DS:
15079         case R_PPC64_PLTGOT16_LO_DS:
15080         case R_PPC64_GOT_TPREL16_DS:
15081         case R_PPC64_GOT_TPREL16_LO_DS:
15082         case R_PPC64_GOT_DTPREL16_DS:
15083         case R_PPC64_GOT_DTPREL16_LO_DS:
15084         case R_PPC64_TPREL16_DS:
15085         case R_PPC64_TPREL16_LO_DS:
15086         case R_PPC64_DTPREL16_DS:
15087         case R_PPC64_DTPREL16_LO_DS:
15088           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15089           mask = 3;
15090           /* If this reloc is against an lq, lxv, or stxv insn, then
15091              the value must be a multiple of 16.  This is somewhat of
15092              a hack, but the "correct" way to do this by defining _DQ
15093              forms of all the _DS relocs bloats all reloc switches in
15094              this file.  It doesn't make much sense to use these
15095              relocs in data, so testing the insn should be safe.  */
15096           if ((insn & (0x3f << 26)) == (56u << 26)
15097               || ((insn & (0x3f << 26)) == (61u << 26) && (insn & 3) == 1))
15098             mask = 15;
15099           relocation += addend;
15100           addend = insn & (mask ^ 3);
15101           if ((relocation & mask) != 0)
15102             {
15103               relocation ^= relocation & mask;
15104               info->callbacks->einfo
15105                 (_("%P: %H: error: %s not a multiple of %u\n"),
15106                  input_bfd, input_section, rel->r_offset,
15107                  howto->name,
15108                  mask + 1);
15109               bfd_set_error (bfd_error_bad_value);
15110               ret = FALSE;
15111               goto copy_reloc;
15112             }
15113           break;
15114         }
15115
15116       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
15117          because such sections are not SEC_ALLOC and thus ld.so will
15118          not process them.  */
15119       if (unresolved_reloc
15120           && !((input_section->flags & SEC_DEBUGGING) != 0
15121                && h->elf.def_dynamic)
15122           && _bfd_elf_section_offset (output_bfd, info, input_section,
15123                                       rel->r_offset) != (bfd_vma) -1)
15124         {
15125           info->callbacks->einfo
15126             (_("%P: %H: unresolvable %s against `%T'\n"),
15127              input_bfd, input_section, rel->r_offset,
15128              howto->name,
15129              h->elf.root.root.string);
15130           ret = FALSE;
15131         }
15132
15133       /* 16-bit fields in insns mostly have signed values, but a
15134          few insns have 16-bit unsigned values.  Really, we should
15135          have different reloc types.  */
15136       if (howto->complain_on_overflow != complain_overflow_dont
15137           && howto->dst_mask == 0xffff
15138           && (input_section->flags & SEC_CODE) != 0)
15139         {
15140           enum complain_overflow complain = complain_overflow_signed;
15141
15142           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15143           if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
15144             complain = complain_overflow_bitfield;
15145           else if (howto->rightshift == 0
15146                    ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
15147                       || (insn & (0x3f << 26)) == 24u << 26 /* ori */
15148                       || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
15149                    : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
15150                       || (insn & (0x3f << 26)) == 25u << 26 /* oris */
15151                       || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
15152             complain = complain_overflow_unsigned;
15153           if (howto->complain_on_overflow != complain)
15154             {
15155               alt_howto = *howto;
15156               alt_howto.complain_on_overflow = complain;
15157               howto = &alt_howto;
15158             }
15159         }
15160
15161       if (r_type == R_PPC64_REL16DX_HA)
15162         {
15163           /* Split field reloc isn't handled by _bfd_final_link_relocate.  */
15164           if (rel->r_offset + 4 > input_section->size)
15165             r = bfd_reloc_outofrange;
15166           else
15167             {
15168               relocation += addend;
15169               relocation -= (rel->r_offset
15170                              + input_section->output_offset
15171                              + input_section->output_section->vma);
15172               relocation = (bfd_signed_vma) relocation >> 16;
15173               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
15174               insn &= ~0x1fffc1;
15175               insn |= (relocation & 0xffc1) | ((relocation & 0x3e) << 15);
15176               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
15177               r = bfd_reloc_ok;
15178               if (relocation + 0x8000 > 0xffff)
15179                 r = bfd_reloc_overflow;
15180             }
15181         }
15182       else
15183         r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
15184                                       rel->r_offset, relocation, addend);
15185
15186       if (r != bfd_reloc_ok)
15187         {
15188           char *more_info = NULL;
15189           const char *reloc_name = howto->name;
15190
15191           if (reloc_dest != DEST_NORMAL)
15192             {
15193               more_info = bfd_malloc (strlen (reloc_name) + 8);
15194               if (more_info != NULL)
15195                 {
15196                   strcpy (more_info, reloc_name);
15197                   strcat (more_info, (reloc_dest == DEST_OPD
15198                                       ? " (OPD)" : " (stub)"));
15199                   reloc_name = more_info;
15200                 }
15201             }
15202
15203           if (r == bfd_reloc_overflow)
15204             {
15205               /* On code like "if (foo) foo();" don't report overflow
15206                  on a branch to zero when foo is undefined.  */
15207               if (!warned
15208                   && (reloc_dest == DEST_STUB
15209                       || !(h != NULL
15210                            && (h->elf.root.type == bfd_link_hash_undefweak
15211                                || h->elf.root.type == bfd_link_hash_undefined)
15212                            && is_branch_reloc (r_type))))
15213                 info->callbacks->reloc_overflow (info, &h->elf.root,
15214                                                  sym_name, reloc_name,
15215                                                  orig_rel.r_addend,
15216                                                  input_bfd, input_section,
15217                                                  rel->r_offset);
15218             }
15219           else
15220             {
15221               info->callbacks->einfo
15222                 (_("%P: %H: %s against `%T': error %d\n"),
15223                  input_bfd, input_section, rel->r_offset,
15224                  reloc_name, sym_name, (int) r);
15225               ret = FALSE;
15226             }
15227           if (more_info != NULL)
15228             free (more_info);
15229         }
15230     copy_reloc:
15231       if (wrel != rel)
15232         *wrel = *rel;
15233     }
15234
15235   if (wrel != rel)
15236     {
15237       Elf_Internal_Shdr *rel_hdr;
15238       size_t deleted = rel - wrel;
15239
15240       rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
15241       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15242       if (rel_hdr->sh_size == 0)
15243         {
15244           /* It is too late to remove an empty reloc section.  Leave
15245              one NONE reloc.
15246              ??? What is wrong with an empty section???  */
15247           rel_hdr->sh_size = rel_hdr->sh_entsize;
15248           deleted -= 1;
15249         }
15250       rel_hdr = _bfd_elf_single_rel_hdr (input_section);
15251       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15252       input_section->reloc_count -= deleted;
15253     }
15254
15255   /* If we're emitting relocations, then shortly after this function
15256      returns, reloc offsets and addends for this section will be
15257      adjusted.  Worse, reloc symbol indices will be for the output
15258      file rather than the input.  Save a copy of the relocs for
15259      opd_entry_value.  */
15260   if (is_opd && (info->emitrelocations || bfd_link_relocatable (info)))
15261     {
15262       bfd_size_type amt;
15263       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
15264       rel = bfd_alloc (input_bfd, amt);
15265       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
15266       ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
15267       if (rel == NULL)
15268         return FALSE;
15269       memcpy (rel, relocs, amt);
15270     }
15271   return ret;
15272 }
15273
15274 /* Adjust the value of any local symbols in opd sections.  */
15275
15276 static int
15277 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
15278                               const char *name ATTRIBUTE_UNUSED,
15279                               Elf_Internal_Sym *elfsym,
15280                               asection *input_sec,
15281                               struct elf_link_hash_entry *h)
15282 {
15283   struct _opd_sec_data *opd;
15284   long adjust;
15285   bfd_vma value;
15286
15287   if (h != NULL)
15288     return 1;
15289
15290   opd = get_opd_info (input_sec);
15291   if (opd == NULL || opd->adjust == NULL)
15292     return 1;
15293
15294   value = elfsym->st_value - input_sec->output_offset;
15295   if (!bfd_link_relocatable (info))
15296     value -= input_sec->output_section->vma;
15297
15298   adjust = opd->adjust[OPD_NDX (value)];
15299   if (adjust == -1)
15300     return 2;
15301
15302   elfsym->st_value += adjust;
15303   return 1;
15304 }
15305
15306 /* Finish up dynamic symbol handling.  We set the contents of various
15307    dynamic sections here.  */
15308
15309 static bfd_boolean
15310 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
15311                                  struct bfd_link_info *info,
15312                                  struct elf_link_hash_entry *h,
15313                                  Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
15314 {
15315   struct ppc_link_hash_table *htab;
15316   struct plt_entry *ent;
15317   Elf_Internal_Rela rela;
15318   bfd_byte *loc;
15319
15320   htab = ppc_hash_table (info);
15321   if (htab == NULL)
15322     return FALSE;
15323
15324   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
15325     if (ent->plt.offset != (bfd_vma) -1)
15326       {
15327         /* This symbol has an entry in the procedure linkage
15328            table.  Set it up.  */
15329         if (!htab->elf.dynamic_sections_created
15330             || h->dynindx == -1)
15331           {
15332             BFD_ASSERT (h->type == STT_GNU_IFUNC
15333                         && h->def_regular
15334                         && (h->root.type == bfd_link_hash_defined
15335                             || h->root.type == bfd_link_hash_defweak));
15336             rela.r_offset = (htab->elf.iplt->output_section->vma
15337                              + htab->elf.iplt->output_offset
15338                              + ent->plt.offset);
15339             if (htab->opd_abi)
15340               rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
15341             else
15342               rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15343             rela.r_addend = (h->root.u.def.value
15344                              + h->root.u.def.section->output_offset
15345                              + h->root.u.def.section->output_section->vma
15346                              + ent->addend);
15347             loc = (htab->elf.irelplt->contents
15348                    + (htab->elf.irelplt->reloc_count++
15349                       * sizeof (Elf64_External_Rela)));
15350           }
15351         else
15352           {
15353             rela.r_offset = (htab->elf.splt->output_section->vma
15354                              + htab->elf.splt->output_offset
15355                              + ent->plt.offset);
15356             rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
15357             rela.r_addend = ent->addend;
15358             loc = (htab->elf.srelplt->contents
15359                    + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
15360                       / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
15361           }
15362         bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15363
15364         if (!htab->opd_abi)
15365           {
15366             if (!h->def_regular)
15367               {
15368                 /* Mark the symbol as undefined, rather than as
15369                    defined in glink.  Leave the value if there were
15370                    any relocations where pointer equality matters
15371                    (this is a clue for the dynamic linker, to make
15372                    function pointer comparisons work between an
15373                    application and shared library), otherwise set it
15374                    to zero.  */
15375                 sym->st_shndx = SHN_UNDEF;
15376                 if (!h->pointer_equality_needed)
15377                   sym->st_value = 0;
15378                 else if (!h->ref_regular_nonweak)
15379                   {
15380                     /* This breaks function pointer comparisons, but
15381                        that is better than breaking tests for a NULL
15382                        function pointer.  */
15383                     sym->st_value = 0;
15384                   }
15385               }
15386           }
15387       }
15388
15389   if (h->needs_copy)
15390     {
15391       /* This symbol needs a copy reloc.  Set it up.  */
15392
15393       if (h->dynindx == -1
15394           || (h->root.type != bfd_link_hash_defined
15395               && h->root.type != bfd_link_hash_defweak)
15396           || htab->relbss == NULL)
15397         abort ();
15398
15399       rela.r_offset = (h->root.u.def.value
15400                        + h->root.u.def.section->output_section->vma
15401                        + h->root.u.def.section->output_offset);
15402       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
15403       rela.r_addend = 0;
15404       loc = htab->relbss->contents;
15405       loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
15406       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15407     }
15408
15409   return TRUE;
15410 }
15411
15412 /* Used to decide how to sort relocs in an optimal manner for the
15413    dynamic linker, before writing them out.  */
15414
15415 static enum elf_reloc_type_class
15416 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
15417                             const asection *rel_sec,
15418                             const Elf_Internal_Rela *rela)
15419 {
15420   enum elf_ppc64_reloc_type r_type;
15421   struct ppc_link_hash_table *htab = ppc_hash_table (info);
15422
15423   if (rel_sec == htab->elf.irelplt)
15424     return reloc_class_ifunc;
15425
15426   r_type = ELF64_R_TYPE (rela->r_info);
15427   switch (r_type)
15428     {
15429     case R_PPC64_RELATIVE:
15430       return reloc_class_relative;
15431     case R_PPC64_JMP_SLOT:
15432       return reloc_class_plt;
15433     case R_PPC64_COPY:
15434       return reloc_class_copy;
15435     default:
15436       return reloc_class_normal;
15437     }
15438 }
15439
15440 /* Finish up the dynamic sections.  */
15441
15442 static bfd_boolean
15443 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
15444                                    struct bfd_link_info *info)
15445 {
15446   struct ppc_link_hash_table *htab;
15447   bfd *dynobj;
15448   asection *sdyn;
15449
15450   htab = ppc_hash_table (info);
15451   if (htab == NULL)
15452     return FALSE;
15453
15454   dynobj = htab->elf.dynobj;
15455   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
15456
15457   if (htab->elf.dynamic_sections_created)
15458     {
15459       Elf64_External_Dyn *dyncon, *dynconend;
15460
15461       if (sdyn == NULL || htab->elf.sgot == NULL)
15462         abort ();
15463
15464       dyncon = (Elf64_External_Dyn *) sdyn->contents;
15465       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
15466       for (; dyncon < dynconend; dyncon++)
15467         {
15468           Elf_Internal_Dyn dyn;
15469           asection *s;
15470
15471           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
15472
15473           switch (dyn.d_tag)
15474             {
15475             default:
15476               continue;
15477
15478             case DT_PPC64_GLINK:
15479               s = htab->glink;
15480               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15481               /* We stupidly defined DT_PPC64_GLINK to be the start
15482                  of glink rather than the first entry point, which is
15483                  what ld.so needs, and now have a bigger stub to
15484                  support automatic multiple TOCs.  */
15485               dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
15486               break;
15487
15488             case DT_PPC64_OPD:
15489               s = bfd_get_section_by_name (output_bfd, ".opd");
15490               if (s == NULL)
15491                 continue;
15492               dyn.d_un.d_ptr = s->vma;
15493               break;
15494
15495             case DT_PPC64_OPT:
15496               if (htab->do_multi_toc && htab->multi_toc_needed)
15497                 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
15498               break;
15499
15500             case DT_PPC64_OPDSZ:
15501               s = bfd_get_section_by_name (output_bfd, ".opd");
15502               if (s == NULL)
15503                 continue;
15504               dyn.d_un.d_val = s->size;
15505               break;
15506
15507             case DT_PLTGOT:
15508               s = htab->elf.splt;
15509               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15510               break;
15511
15512             case DT_JMPREL:
15513               s = htab->elf.srelplt;
15514               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15515               break;
15516
15517             case DT_PLTRELSZ:
15518               dyn.d_un.d_val = htab->elf.srelplt->size;
15519               break;
15520
15521             case DT_RELASZ:
15522               /* Don't count procedure linkage table relocs in the
15523                  overall reloc count.  */
15524               s = htab->elf.srelplt;
15525               if (s == NULL)
15526                 continue;
15527               dyn.d_un.d_val -= s->size;
15528               break;
15529
15530             case DT_RELA:
15531               /* We may not be using the standard ELF linker script.
15532                  If .rela.plt is the first .rela section, we adjust
15533                  DT_RELA to not include it.  */
15534               s = htab->elf.srelplt;
15535               if (s == NULL)
15536                 continue;
15537               if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
15538                 continue;
15539               dyn.d_un.d_ptr += s->size;
15540               break;
15541             }
15542
15543           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
15544         }
15545     }
15546
15547   if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0)
15548     {
15549       /* Fill in the first entry in the global offset table.
15550          We use it to hold the link-time TOCbase.  */
15551       bfd_put_64 (output_bfd,
15552                   elf_gp (output_bfd) + TOC_BASE_OFF,
15553                   htab->elf.sgot->contents);
15554
15555       /* Set .got entry size.  */
15556       elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
15557     }
15558
15559   if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
15560     {
15561       /* Set .plt entry size.  */
15562       elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
15563         = PLT_ENTRY_SIZE (htab);
15564     }
15565
15566   /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
15567      brlt ourselves if emitrelocations.  */
15568   if (htab->brlt != NULL
15569       && htab->brlt->reloc_count != 0
15570       && !_bfd_elf_link_output_relocs (output_bfd,
15571                                        htab->brlt,
15572                                        elf_section_data (htab->brlt)->rela.hdr,
15573                                        elf_section_data (htab->brlt)->relocs,
15574                                        NULL))
15575     return FALSE;
15576
15577   if (htab->glink != NULL
15578       && htab->glink->reloc_count != 0
15579       && !_bfd_elf_link_output_relocs (output_bfd,
15580                                        htab->glink,
15581                                        elf_section_data (htab->glink)->rela.hdr,
15582                                        elf_section_data (htab->glink)->relocs,
15583                                        NULL))
15584     return FALSE;
15585
15586   if (htab->glink_eh_frame != NULL
15587       && htab->glink_eh_frame->size != 0)
15588     {
15589       bfd_vma val;
15590       bfd_byte *p;
15591       asection *stub_sec;
15592
15593       p = htab->glink_eh_frame->contents + sizeof (glink_eh_frame_cie);
15594       for (stub_sec = htab->params->stub_bfd->sections;
15595            stub_sec != NULL;
15596            stub_sec = stub_sec->next)
15597         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
15598           {
15599             /* FDE length.  */
15600             p += 4;
15601             /* CIE pointer.  */
15602             p += 4;
15603             /* Offset to stub section.  */
15604             val = (stub_sec->output_section->vma
15605                    + stub_sec->output_offset);
15606             val -= (htab->glink_eh_frame->output_section->vma
15607                     + htab->glink_eh_frame->output_offset
15608                     + (p - htab->glink_eh_frame->contents));
15609             if (val + 0x80000000 > 0xffffffff)
15610               {
15611                 info->callbacks->einfo
15612                   (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15613                    stub_sec->name);
15614                 return FALSE;
15615               }
15616             bfd_put_32 (dynobj, val, p);
15617             p += 4;
15618             /* stub section size.  */
15619             p += 4;
15620             /* Augmentation.  */
15621             p += 1;
15622             /* Pad.  */
15623             p += 7;
15624           }
15625       if (htab->glink != NULL && htab->glink->size != 0)
15626         {
15627           /* FDE length.  */
15628           p += 4;
15629           /* CIE pointer.  */
15630           p += 4;
15631           /* Offset to .glink.  */
15632           val = (htab->glink->output_section->vma
15633                  + htab->glink->output_offset
15634                  + 8);
15635           val -= (htab->glink_eh_frame->output_section->vma
15636                   + htab->glink_eh_frame->output_offset
15637                   + (p - htab->glink_eh_frame->contents));
15638           if (val + 0x80000000 > 0xffffffff)
15639             {
15640               info->callbacks->einfo
15641                 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15642                  htab->glink->name);
15643               return FALSE;
15644             }
15645           bfd_put_32 (dynobj, val, p);
15646           p += 4;
15647           /* .glink size.  */
15648           p += 4;
15649           /* Augmentation.  */
15650           p += 1;
15651           /* Ops.  */
15652           p += 7;
15653         }
15654
15655       if (htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
15656           && !_bfd_elf_write_section_eh_frame (output_bfd, info,
15657                                                htab->glink_eh_frame,
15658                                                htab->glink_eh_frame->contents))
15659         return FALSE;
15660     }
15661
15662   /* We need to handle writing out multiple GOT sections ourselves,
15663      since we didn't add them to DYNOBJ.  We know dynobj is the first
15664      bfd.  */
15665   while ((dynobj = dynobj->link.next) != NULL)
15666     {
15667       asection *s;
15668
15669       if (!is_ppc64_elf (dynobj))
15670         continue;
15671
15672       s = ppc64_elf_tdata (dynobj)->got;
15673       if (s != NULL
15674           && s->size != 0
15675           && s->output_section != bfd_abs_section_ptr
15676           && !bfd_set_section_contents (output_bfd, s->output_section,
15677                                         s->contents, s->output_offset,
15678                                         s->size))
15679         return FALSE;
15680       s = ppc64_elf_tdata (dynobj)->relgot;
15681       if (s != NULL
15682           && s->size != 0
15683           && s->output_section != bfd_abs_section_ptr
15684           && !bfd_set_section_contents (output_bfd, s->output_section,
15685                                         s->contents, s->output_offset,
15686                                         s->size))
15687         return FALSE;
15688     }
15689
15690   return TRUE;
15691 }
15692
15693 #include "elf64-target.h"
15694
15695 /* FreeBSD support */
15696
15697 #undef  TARGET_LITTLE_SYM
15698 #undef  TARGET_LITTLE_NAME
15699
15700 #undef  TARGET_BIG_SYM
15701 #define TARGET_BIG_SYM  powerpc_elf64_fbsd_vec
15702 #undef  TARGET_BIG_NAME
15703 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15704
15705 #undef  ELF_OSABI
15706 #define ELF_OSABI       ELFOSABI_FREEBSD
15707
15708 #undef  elf64_bed
15709 #define elf64_bed       elf64_powerpc_fbsd_bed
15710
15711 #include "elf64-target.h"
15712