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