bfd/elf64-ppc.c

   1 /* PowerPC64-specific support for 64-bit ELF.
   2    Copyright (C) 1999-2017 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_want_dynrelro 1
  76 #define elf_backend_can_gc_sections 1
  77 #define elf_backend_can_refcount 1
  78 #define elf_backend_rela_normal 1
  79 #define elf_backend_dtrel_excludes_plt 1
  80 #define elf_backend_default_execstack 0
  81
  82 #define bfd_elf64_mkobject                    ppc64_elf_mkobject
  83 #define bfd_elf64_bfd_reloc_type_lookup       ppc64_elf_reloc_type_lookup
  84 #define bfd_elf64_bfd_reloc_name_lookup       ppc64_elf_reloc_name_lookup
  85 #define bfd_elf64_bfd_merge_private_bfd_data  ppc64_elf_merge_private_bfd_data
  86 #define bfd_elf64_bfd_print_private_bfd_data  ppc64_elf_print_private_bfd_data
  87 #define bfd_elf64_new_section_hook            ppc64_elf_new_section_hook
  88 #define bfd_elf64_bfd_link_hash_table_create  ppc64_elf_link_hash_table_create
  89 #define bfd_elf64_get_synthetic_symtab        ppc64_elf_get_synthetic_symtab
  90 #define bfd_elf64_bfd_link_just_syms          ppc64_elf_link_just_syms
  91 #define bfd_elf64_bfd_gc_sections             ppc64_elf_gc_sections
  92
  93 #define elf_backend_object_p                  ppc64_elf_object_p
  94 #define elf_backend_grok_prstatus             ppc64_elf_grok_prstatus
  95 #define elf_backend_grok_psinfo               ppc64_elf_grok_psinfo
  96 #define elf_backend_write_core_note           ppc64_elf_write_core_note
  97 #define elf_backend_create_dynamic_sections   _bfd_elf_create_dynamic_sections
  98 #define elf_backend_copy_indirect_symbol      ppc64_elf_copy_indirect_symbol
  99 #define elf_backend_add_symbol_hook           ppc64_elf_add_symbol_hook
 100 #define elf_backend_check_directives          ppc64_elf_before_check_relocs
 101 #define elf_backend_notice_as_needed          ppc64_elf_notice_as_needed
 102 #define elf_backend_archive_symbol_lookup     ppc64_elf_archive_symbol_lookup
 103 #define elf_backend_check_relocs              ppc64_elf_check_relocs
 104 #define elf_backend_gc_keep                   ppc64_elf_gc_keep
 105 #define elf_backend_gc_mark_dynamic_ref       ppc64_elf_gc_mark_dynamic_ref
 106 #define elf_backend_gc_mark_hook              ppc64_elf_gc_mark_hook
 107 #define elf_backend_gc_sweep_hook             ppc64_elf_gc_sweep_hook
 108 #define elf_backend_adjust_dynamic_symbol     ppc64_elf_adjust_dynamic_symbol
 109 #define elf_backend_hide_symbol               ppc64_elf_hide_symbol
 110 #define elf_backend_maybe_function_sym        ppc64_elf_maybe_function_sym
 111 #define elf_backend_always_size_sections      ppc64_elf_func_desc_adjust
 112 #define elf_backend_size_dynamic_sections     ppc64_elf_size_dynamic_sections
 113 #define elf_backend_hash_symbol               ppc64_elf_hash_symbol
 114 #define elf_backend_init_index_section        _bfd_elf_init_2_index_sections
 115 #define elf_backend_action_discarded          ppc64_elf_action_discarded
 116 #define elf_backend_relocate_section          ppc64_elf_relocate_section
 117 #define elf_backend_finish_dynamic_symbol     ppc64_elf_finish_dynamic_symbol
 118 #define elf_backend_reloc_type_class          ppc64_elf_reloc_type_class
 119 #define elf_backend_finish_dynamic_sections   ppc64_elf_finish_dynamic_sections
 120 #define elf_backend_link_output_symbol_hook   ppc64_elf_output_symbol_hook
 121 #define elf_backend_special_sections          ppc64_elf_special_sections
 122 #define elf_backend_merge_symbol_attribute    ppc64_elf_merge_symbol_attribute
 123 #define elf_backend_merge_symbol              ppc64_elf_merge_symbol
 124 #define elf_backend_get_reloc_section         bfd_get_section_by_name
 125
 126 /* The name of the dynamic interpreter.  This is put in the .interp
 127    section.  */
 128 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
 129
 130 /* The size in bytes of an entry in the procedure linkage table.  */
 131 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
 132
 133 /* The initial size of the plt reserved for the dynamic linker.  */
 134 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
 135
 136 /* Offsets to some stack save slots.  */
 137 #define STK_LR 16
 138 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
 139 /* This one is dodgy.  ELFv2 does not have a linker word, so use the
 140    CR save slot.  Used only by optimised __tls_get_addr call stub,
 141    relying on __tls_get_addr_opt not saving CR..  */
 142 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
 143
 144 /* TOC base pointers offset from start of TOC.  */
 145 #define TOC_BASE_OFF    0x8000
 146 /* TOC base alignment.  */
 147 #define TOC_BASE_ALIGN  256
 148
 149 /* Offset of tp and dtp pointers from start of TLS block.  */
 150 #define TP_OFFSET       0x7000
 151 #define DTP_OFFSET      0x8000
 152
 153 /* .plt call stub instructions.  The normal stub is like this, but
 154    sometimes the .plt entry crosses a 64k boundary and we need to
 155    insert an addi to adjust r11.  */
 156 #define STD_R2_0R1      0xf8410000      /* std   %r2,0+40(%r1)       */
 157 #define ADDIS_R11_R2    0x3d620000      /* addis %r11,%r2,xxx@ha     */
 158 #define LD_R12_0R11     0xe98b0000      /* ld    %r12,xxx+0@l(%r11)  */
 159 #define MTCTR_R12       0x7d8903a6      /* mtctr %r12                */
 160 #define LD_R2_0R11      0xe84b0000      /* ld    %r2,xxx+8@l(%r11)   */
 161 #define LD_R11_0R11     0xe96b0000      /* ld    %r11,xxx+16@l(%r11) */
 162 #define BCTR            0x4e800420      /* bctr                      */
 163
 164 #define ADDI_R11_R11    0x396b0000      /* addi %r11,%r11,off@l  */
 165 #define ADDIS_R2_R2     0x3c420000      /* addis %r2,%r2,off@ha  */
 166 #define ADDI_R2_R2      0x38420000      /* addi  %r2,%r2,off@l   */
 167
 168 #define XOR_R2_R12_R12  0x7d826278      /* xor   %r2,%r12,%r12   */
 169 #define ADD_R11_R11_R2  0x7d6b1214      /* add   %r11,%r11,%r2   */
 170 #define XOR_R11_R12_R12 0x7d8b6278      /* xor   %r11,%r12,%r12  */
 171 #define ADD_R2_R2_R11   0x7c425a14      /* add   %r2,%r2,%r11    */
 172 #define CMPLDI_R2_0     0x28220000      /* cmpldi %r2,0          */
 173 #define BNECTR          0x4ca20420      /* bnectr+               */
 174 #define BNECTR_P4       0x4ce20420      /* bnectr+               */
 175
 176 #define LD_R12_0R2      0xe9820000      /* ld    %r12,xxx+0(%r2) */
 177 #define LD_R11_0R2      0xe9620000      /* ld    %r11,xxx+0(%r2) */
 178 #define LD_R2_0R2       0xe8420000      /* ld    %r2,xxx+0(%r2)  */
 179
 180 #define LD_R2_0R1       0xe8410000      /* ld    %r2,0(%r1)      */
 181 #define LD_R2_0R12      0xe84c0000      /* ld    %r2,0(%r12)     */
 182 #define ADD_R2_R2_R12   0x7c426214      /* add   %r2,%r2,%r12    */
 183
 184 #define LIS_R2          0x3c400000      /* lis %r2,xxx@ha         */
 185 #define ADDIS_R2_R12    0x3c4c0000      /* addis %r2,%r12,xxx@ha  */
 186 #define ADDIS_R12_R2    0x3d820000      /* addis %r12,%r2,xxx@ha  */
 187 #define ADDIS_R12_R12   0x3d8c0000      /* addis %r12,%r12,xxx@ha */
 188 #define LD_R12_0R12     0xe98c0000      /* ld    %r12,xxx@l(%r12) */
 189
 190 /* glink call stub instructions.  We enter with the index in R0.  */
 191 #define GLINK_CALL_STUB_SIZE (16*4)
 192                                         /* 0:                           */
 193                                         /*  .quad plt0-1f               */
 194                                         /* __glink:                     */
 195 #define MFLR_R12        0x7d8802a6      /*  mflr %12                    */
 196 #define BCL_20_31       0x429f0005      /*  bcl 20,31,1f                */
 197                                         /* 1:                           */
 198 #define MFLR_R11        0x7d6802a6      /*  mflr %11                    */
 199                                         /*  ld %2,(0b-1b)(%11)          */
 200 #define MTLR_R12        0x7d8803a6      /*  mtlr %12                    */
 201 #define ADD_R11_R2_R11  0x7d625a14      /*  add %11,%2,%11              */
 202                                         /*  ld %12,0(%11)               */
 203                                         /*  ld %2,8(%11)                */
 204                                         /*  mtctr %12                   */
 205                                         /*  ld %11,16(%11)              */
 206                                         /*  bctr                        */
 207 #define MFLR_R0         0x7c0802a6      /*  mflr %r0                    */
 208 #define MTLR_R0         0x7c0803a6      /*  mtlr %r0                    */
 209 #define SUB_R12_R12_R11 0x7d8b6050      /*  subf %r12,%r11,%r12         */
 210 #define ADDI_R0_R12     0x380c0000      /*  addi %r0,%r12,0             */
 211 #define SRDI_R0_R0_2    0x7800f082      /*  rldicl %r0,%r0,62,2         */
 212
 213 /* Pad with this.  */
 214 #define NOP             0x60000000
 215
 216 /* Some other nops.  */
 217 #define CROR_151515     0x4def7b82
 218 #define CROR_313131     0x4ffffb82
 219
 220 /* .glink entries for the first 32k functions are two instructions.  */
 221 #define LI_R0_0         0x38000000      /* li    %r0,0          */
 222 #define B_DOT           0x48000000      /* b     .              */
 223
 224 /* After that, we need two instructions to load the index, followed by
 225    a branch.  */
 226 #define LIS_R0_0        0x3c000000      /* lis   %r0,0          */
 227 #define ORI_R0_R0_0     0x60000000      /* ori   %r0,%r0,0      */
 228
 229 /* Instructions used by the save and restore reg functions.  */
 230 #define STD_R0_0R1      0xf8010000      /* std   %r0,0(%r1)     */
 231 #define STD_R0_0R12     0xf80c0000      /* std   %r0,0(%r12)    */
 232 #define LD_R0_0R1       0xe8010000      /* ld    %r0,0(%r1)     */
 233 #define LD_R0_0R12      0xe80c0000      /* ld    %r0,0(%r12)    */
 234 #define STFD_FR0_0R1    0xd8010000      /* stfd  %fr0,0(%r1)    */
 235 #define LFD_FR0_0R1     0xc8010000      /* lfd   %fr0,0(%r1)    */
 236 #define LI_R12_0        0x39800000      /* li    %r12,0         */
 237 #define STVX_VR0_R12_R0 0x7c0c01ce      /* stvx  %v0,%r12,%r0   */
 238 #define LVX_VR0_R12_R0  0x7c0c00ce      /* lvx   %v0,%r12,%r0   */
 239 #define MTLR_R0         0x7c0803a6      /* mtlr  %r0            */
 240 #define BLR             0x4e800020      /* blr                  */
 241
 242 /* Since .opd is an array of descriptors and each entry will end up
 243    with identical R_PPC64_RELATIVE relocs, there is really no need to
 244    propagate .opd relocs;  The dynamic linker should be taught to
 245    relocate .opd without reloc entries.  */
 246 #ifndef NO_OPD_RELOCS
 247 #define NO_OPD_RELOCS 0
 248 #endif
 249
 250 #ifndef ARRAY_SIZE
 251 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
 252 #endif
 253
 254 static inline int
 255 abiversion (bfd *abfd)
 256 {
 257   return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
 258 }
 259
 260 static inline void
 261 set_abiversion (bfd *abfd, int ver)
 262 {
 263   elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
 264   elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
 265 }
 266 \f
 267 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
 268
 269 /* Relocation HOWTO's.  */
 270 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
 271
 272 static reloc_howto_type ppc64_elf_howto_raw[] = {
 273   /* This reloc does nothing.  */
 274   HOWTO (R_PPC64_NONE,          /* type */
 275          0,                     /* rightshift */
 276          3,                     /* size (0 = byte, 1 = short, 2 = long) */
 277          0,                     /* bitsize */
 278          FALSE,                 /* pc_relative */
 279          0,                     /* bitpos */
 280          complain_overflow_dont, /* complain_on_overflow */
 281          bfd_elf_generic_reloc, /* special_function */
 282          "R_PPC64_NONE",        /* name */
 283          FALSE,                 /* partial_inplace */
 284          0,                     /* src_mask */
 285          0,                     /* dst_mask */
 286          FALSE),                /* pcrel_offset */
 287
 288   /* A standard 32 bit relocation.  */
 289   HOWTO (R_PPC64_ADDR32,        /* type */
 290          0,                     /* rightshift */
 291          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 292          32,                    /* bitsize */
 293          FALSE,                 /* pc_relative */
 294          0,                     /* bitpos */
 295          complain_overflow_bitfield, /* complain_on_overflow */
 296          bfd_elf_generic_reloc, /* special_function */
 297          "R_PPC64_ADDR32",      /* name */
 298          FALSE,                 /* partial_inplace */
 299          0,                     /* src_mask */
 300          0xffffffff,            /* dst_mask */
 301          FALSE),                /* pcrel_offset */
 302
 303   /* An absolute 26 bit branch; the lower two bits must be zero.
 304      FIXME: we don't check that, we just clear them.  */
 305   HOWTO (R_PPC64_ADDR24,        /* type */
 306          0,                     /* rightshift */
 307          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 308          26,                    /* bitsize */
 309          FALSE,                 /* pc_relative */
 310          0,                     /* bitpos */
 311          complain_overflow_bitfield, /* complain_on_overflow */
 312          bfd_elf_generic_reloc, /* special_function */
 313          "R_PPC64_ADDR24",      /* name */
 314          FALSE,                 /* partial_inplace */
 315          0,                     /* src_mask */
 316          0x03fffffc,            /* dst_mask */
 317          FALSE),                /* pcrel_offset */
 318
 319   /* A standard 16 bit relocation.  */
 320   HOWTO (R_PPC64_ADDR16,        /* type */
 321          0,                     /* rightshift */
 322          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 323          16,                    /* bitsize */
 324          FALSE,                 /* pc_relative */
 325          0,                     /* bitpos */
 326          complain_overflow_bitfield, /* complain_on_overflow */
 327          bfd_elf_generic_reloc, /* special_function */
 328          "R_PPC64_ADDR16",      /* name */
 329          FALSE,                 /* partial_inplace */
 330          0,                     /* src_mask */
 331          0xffff,                /* dst_mask */
 332          FALSE),                /* pcrel_offset */
 333
 334   /* A 16 bit relocation without overflow.  */
 335   HOWTO (R_PPC64_ADDR16_LO,     /* type */
 336          0,                     /* rightshift */
 337          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 338          16,                    /* bitsize */
 339          FALSE,                 /* pc_relative */
 340          0,                     /* bitpos */
 341          complain_overflow_dont,/* complain_on_overflow */
 342          bfd_elf_generic_reloc, /* special_function */
 343          "R_PPC64_ADDR16_LO",   /* name */
 344          FALSE,                 /* partial_inplace */
 345          0,                     /* src_mask */
 346          0xffff,                /* dst_mask */
 347          FALSE),                /* pcrel_offset */
 348
 349   /* Bits 16-31 of an address.  */
 350   HOWTO (R_PPC64_ADDR16_HI,     /* type */
 351          16,                    /* rightshift */
 352          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 353          16,                    /* bitsize */
 354          FALSE,                 /* pc_relative */
 355          0,                     /* bitpos */
 356          complain_overflow_signed, /* complain_on_overflow */
 357          bfd_elf_generic_reloc, /* special_function */
 358          "R_PPC64_ADDR16_HI",   /* name */
 359          FALSE,                 /* partial_inplace */
 360          0,                     /* src_mask */
 361          0xffff,                /* dst_mask */
 362          FALSE),                /* pcrel_offset */
 363
 364   /* Bits 16-31 of an address, plus 1 if the contents of the low 16
 365      bits, treated as a signed number, is negative.  */
 366   HOWTO (R_PPC64_ADDR16_HA,     /* type */
 367          16,                    /* rightshift */
 368          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 369          16,                    /* bitsize */
 370          FALSE,                 /* pc_relative */
 371          0,                     /* bitpos */
 372          complain_overflow_signed, /* complain_on_overflow */
 373          ppc64_elf_ha_reloc,    /* special_function */
 374          "R_PPC64_ADDR16_HA",   /* name */
 375          FALSE,                 /* partial_inplace */
 376          0,                     /* src_mask */
 377          0xffff,                /* dst_mask */
 378          FALSE),                /* pcrel_offset */
 379
 380   /* An absolute 16 bit branch; the lower two bits must be zero.
 381      FIXME: we don't check that, we just clear them.  */
 382   HOWTO (R_PPC64_ADDR14,        /* type */
 383          0,                     /* rightshift */
 384          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 385          16,                    /* bitsize */
 386          FALSE,                 /* pc_relative */
 387          0,                     /* bitpos */
 388          complain_overflow_signed, /* complain_on_overflow */
 389          ppc64_elf_branch_reloc, /* special_function */
 390          "R_PPC64_ADDR14",      /* name */
 391          FALSE,                 /* partial_inplace */
 392          0,                     /* src_mask */
 393          0x0000fffc,            /* dst_mask */
 394          FALSE),                /* pcrel_offset */
 395
 396   /* An absolute 16 bit branch, for which bit 10 should be set to
 397      indicate that the branch is expected to be taken.  The lower two
 398      bits must be zero.  */
 399   HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
 400          0,                     /* rightshift */
 401          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 402          16,                    /* bitsize */
 403          FALSE,                 /* pc_relative */
 404          0,                     /* bitpos */
 405          complain_overflow_signed, /* complain_on_overflow */
 406          ppc64_elf_brtaken_reloc, /* special_function */
 407          "R_PPC64_ADDR14_BRTAKEN",/* name */
 408          FALSE,                 /* partial_inplace */
 409          0,                     /* src_mask */
 410          0x0000fffc,            /* dst_mask */
 411          FALSE),                /* pcrel_offset */
 412
 413   /* An absolute 16 bit branch, for which bit 10 should be set to
 414      indicate that the branch is not expected to be taken.  The lower
 415      two bits must be zero.  */
 416   HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
 417          0,                     /* rightshift */
 418          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 419          16,                    /* bitsize */
 420          FALSE,                 /* pc_relative */
 421          0,                     /* bitpos */
 422          complain_overflow_signed, /* complain_on_overflow */
 423          ppc64_elf_brtaken_reloc, /* special_function */
 424          "R_PPC64_ADDR14_BRNTAKEN",/* name */
 425          FALSE,                 /* partial_inplace */
 426          0,                     /* src_mask */
 427          0x0000fffc,            /* dst_mask */
 428          FALSE),                /* pcrel_offset */
 429
 430   /* A relative 26 bit branch; the lower two bits must be zero.  */
 431   HOWTO (R_PPC64_REL24,         /* type */
 432          0,                     /* rightshift */
 433          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 434          26,                    /* bitsize */
 435          TRUE,                  /* pc_relative */
 436          0,                     /* bitpos */
 437          complain_overflow_signed, /* complain_on_overflow */
 438          ppc64_elf_branch_reloc, /* special_function */
 439          "R_PPC64_REL24",       /* name */
 440          FALSE,                 /* partial_inplace */
 441          0,                     /* src_mask */
 442          0x03fffffc,            /* dst_mask */
 443          TRUE),                 /* pcrel_offset */
 444
 445   /* A relative 16 bit branch; the lower two bits must be zero.  */
 446   HOWTO (R_PPC64_REL14,         /* type */
 447          0,                     /* rightshift */
 448          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 449          16,                    /* bitsize */
 450          TRUE,                  /* pc_relative */
 451          0,                     /* bitpos */
 452          complain_overflow_signed, /* complain_on_overflow */
 453          ppc64_elf_branch_reloc, /* special_function */
 454          "R_PPC64_REL14",       /* name */
 455          FALSE,                 /* partial_inplace */
 456          0,                     /* src_mask */
 457          0x0000fffc,            /* dst_mask */
 458          TRUE),                 /* pcrel_offset */
 459
 460   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 461      the branch is expected to be taken.  The lower two bits must be
 462      zero.  */
 463   HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
 464          0,                     /* rightshift */
 465          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 466          16,                    /* bitsize */
 467          TRUE,                  /* pc_relative */
 468          0,                     /* bitpos */
 469          complain_overflow_signed, /* complain_on_overflow */
 470          ppc64_elf_brtaken_reloc, /* special_function */
 471          "R_PPC64_REL14_BRTAKEN", /* name */
 472          FALSE,                 /* partial_inplace */
 473          0,                     /* src_mask */
 474          0x0000fffc,            /* dst_mask */
 475          TRUE),                 /* pcrel_offset */
 476
 477   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 478      the branch is not expected to be taken.  The lower two bits must
 479      be zero.  */
 480   HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
 481          0,                     /* rightshift */
 482          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 483          16,                    /* bitsize */
 484          TRUE,                  /* pc_relative */
 485          0,                     /* bitpos */
 486          complain_overflow_signed, /* complain_on_overflow */
 487          ppc64_elf_brtaken_reloc, /* special_function */
 488          "R_PPC64_REL14_BRNTAKEN",/* name */
 489          FALSE,                 /* partial_inplace */
 490          0,                     /* src_mask */
 491          0x0000fffc,            /* dst_mask */
 492          TRUE),                 /* pcrel_offset */
 493
 494   /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
 495      symbol.  */
 496   HOWTO (R_PPC64_GOT16,         /* type */
 497          0,                     /* rightshift */
 498          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 499          16,                    /* bitsize */
 500          FALSE,                 /* pc_relative */
 501          0,                     /* bitpos */
 502          complain_overflow_signed, /* complain_on_overflow */
 503          ppc64_elf_unhandled_reloc, /* special_function */
 504          "R_PPC64_GOT16",       /* name */
 505          FALSE,                 /* partial_inplace */
 506          0,                     /* src_mask */
 507          0xffff,                /* dst_mask */
 508          FALSE),                /* pcrel_offset */
 509
 510   /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
 511      the symbol.  */
 512   HOWTO (R_PPC64_GOT16_LO,      /* type */
 513          0,                     /* rightshift */
 514          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 515          16,                    /* bitsize */
 516          FALSE,                 /* pc_relative */
 517          0,                     /* bitpos */
 518          complain_overflow_dont, /* complain_on_overflow */
 519          ppc64_elf_unhandled_reloc, /* special_function */
 520          "R_PPC64_GOT16_LO",    /* name */
 521          FALSE,                 /* partial_inplace */
 522          0,                     /* src_mask */
 523          0xffff,                /* dst_mask */
 524          FALSE),                /* pcrel_offset */
 525
 526   /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
 527      the symbol.  */
 528   HOWTO (R_PPC64_GOT16_HI,      /* type */
 529          16,                    /* rightshift */
 530          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 531          16,                    /* bitsize */
 532          FALSE,                 /* pc_relative */
 533          0,                     /* bitpos */
 534          complain_overflow_signed,/* complain_on_overflow */
 535          ppc64_elf_unhandled_reloc, /* special_function */
 536          "R_PPC64_GOT16_HI",    /* name */
 537          FALSE,                 /* partial_inplace */
 538          0,                     /* src_mask */
 539          0xffff,                /* dst_mask */
 540          FALSE),                /* pcrel_offset */
 541
 542   /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
 543      the symbol.  */
 544   HOWTO (R_PPC64_GOT16_HA,      /* type */
 545          16,                    /* rightshift */
 546          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 547          16,                    /* bitsize */
 548          FALSE,                 /* pc_relative */
 549          0,                     /* bitpos */
 550          complain_overflow_signed,/* complain_on_overflow */
 551          ppc64_elf_unhandled_reloc, /* special_function */
 552          "R_PPC64_GOT16_HA",    /* name */
 553          FALSE,                 /* partial_inplace */
 554          0,                     /* src_mask */
 555          0xffff,                /* dst_mask */
 556          FALSE),                /* pcrel_offset */
 557
 558   /* This is used only by the dynamic linker.  The symbol should exist
 559      both in the object being run and in some shared library.  The
 560      dynamic linker copies the data addressed by the symbol from the
 561      shared library into the object, because the object being
 562      run has to have the data at some particular address.  */
 563   HOWTO (R_PPC64_COPY,          /* type */
 564          0,                     /* rightshift */
 565          0,                     /* this one is variable size */
 566          0,                     /* bitsize */
 567          FALSE,                 /* pc_relative */
 568          0,                     /* bitpos */
 569          complain_overflow_dont, /* complain_on_overflow */
 570          ppc64_elf_unhandled_reloc, /* special_function */
 571          "R_PPC64_COPY",        /* name */
 572          FALSE,                 /* partial_inplace */
 573          0,                     /* src_mask */
 574          0,                     /* dst_mask */
 575          FALSE),                /* pcrel_offset */
 576
 577   /* Like R_PPC64_ADDR64, but used when setting global offset table
 578      entries.  */
 579   HOWTO (R_PPC64_GLOB_DAT,      /* type */
 580          0,                     /* rightshift */
 581          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 582          64,                    /* bitsize */
 583          FALSE,                 /* pc_relative */
 584          0,                     /* bitpos */
 585          complain_overflow_dont, /* complain_on_overflow */
 586          ppc64_elf_unhandled_reloc,  /* special_function */
 587          "R_PPC64_GLOB_DAT",    /* name */
 588          FALSE,                 /* partial_inplace */
 589          0,                     /* src_mask */
 590          ONES (64),             /* dst_mask */
 591          FALSE),                /* pcrel_offset */
 592
 593   /* Created by the link editor.  Marks a procedure linkage table
 594      entry for a symbol.  */
 595   HOWTO (R_PPC64_JMP_SLOT,      /* type */
 596          0,                     /* rightshift */
 597          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 598          0,                     /* bitsize */
 599          FALSE,                 /* pc_relative */
 600          0,                     /* bitpos */
 601          complain_overflow_dont, /* complain_on_overflow */
 602          ppc64_elf_unhandled_reloc, /* special_function */
 603          "R_PPC64_JMP_SLOT",    /* name */
 604          FALSE,                 /* partial_inplace */
 605          0,                     /* src_mask */
 606          0,                     /* dst_mask */
 607          FALSE),                /* pcrel_offset */
 608
 609   /* Used only by the dynamic linker.  When the object is run, this
 610      doubleword64 is set to the load address of the object, plus the
 611      addend.  */
 612   HOWTO (R_PPC64_RELATIVE,      /* type */
 613          0,                     /* rightshift */
 614          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 615          64,                    /* bitsize */
 616          FALSE,                 /* pc_relative */
 617          0,                     /* bitpos */
 618          complain_overflow_dont, /* complain_on_overflow */
 619          bfd_elf_generic_reloc, /* special_function */
 620          "R_PPC64_RELATIVE",    /* name */
 621          FALSE,                 /* partial_inplace */
 622          0,                     /* src_mask */
 623          ONES (64),             /* dst_mask */
 624          FALSE),                /* pcrel_offset */
 625
 626   /* Like R_PPC64_ADDR32, but may be unaligned.  */
 627   HOWTO (R_PPC64_UADDR32,       /* type */
 628          0,                     /* rightshift */
 629          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 630          32,                    /* bitsize */
 631          FALSE,                 /* pc_relative */
 632          0,                     /* bitpos */
 633          complain_overflow_bitfield, /* complain_on_overflow */
 634          bfd_elf_generic_reloc, /* special_function */
 635          "R_PPC64_UADDR32",     /* name */
 636          FALSE,                 /* partial_inplace */
 637          0,                     /* src_mask */
 638          0xffffffff,            /* dst_mask */
 639          FALSE),                /* pcrel_offset */
 640
 641   /* Like R_PPC64_ADDR16, but may be unaligned.  */
 642   HOWTO (R_PPC64_UADDR16,       /* type */
 643          0,                     /* rightshift */
 644          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 645          16,                    /* bitsize */
 646          FALSE,                 /* pc_relative */
 647          0,                     /* bitpos */
 648          complain_overflow_bitfield, /* complain_on_overflow */
 649          bfd_elf_generic_reloc, /* special_function */
 650          "R_PPC64_UADDR16",     /* name */
 651          FALSE,                 /* partial_inplace */
 652          0,                     /* src_mask */
 653          0xffff,                /* dst_mask */
 654          FALSE),                /* pcrel_offset */
 655
 656   /* 32-bit PC relative.  */
 657   HOWTO (R_PPC64_REL32,         /* type */
 658          0,                     /* rightshift */
 659          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 660          32,                    /* bitsize */
 661          TRUE,                  /* pc_relative */
 662          0,                     /* bitpos */
 663          complain_overflow_signed, /* complain_on_overflow */
 664          bfd_elf_generic_reloc, /* special_function */
 665          "R_PPC64_REL32",       /* name */
 666          FALSE,                 /* partial_inplace */
 667          0,                     /* src_mask */
 668          0xffffffff,            /* dst_mask */
 669          TRUE),                 /* pcrel_offset */
 670
 671   /* 32-bit relocation to the symbol's procedure linkage table.  */
 672   HOWTO (R_PPC64_PLT32,         /* type */
 673          0,                     /* rightshift */
 674          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 675          32,                    /* bitsize */
 676          FALSE,                 /* pc_relative */
 677          0,                     /* bitpos */
 678          complain_overflow_bitfield, /* complain_on_overflow */
 679          ppc64_elf_unhandled_reloc, /* special_function */
 680          "R_PPC64_PLT32",       /* name */
 681          FALSE,                 /* partial_inplace */
 682          0,                     /* src_mask */
 683          0xffffffff,            /* dst_mask */
 684          FALSE),                /* pcrel_offset */
 685
 686   /* 32-bit PC relative relocation to the symbol's procedure linkage table.
 687      FIXME: R_PPC64_PLTREL32 not supported.  */
 688   HOWTO (R_PPC64_PLTREL32,      /* type */
 689          0,                     /* rightshift */
 690          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 691          32,                    /* bitsize */
 692          TRUE,                  /* pc_relative */
 693          0,                     /* bitpos */
 694          complain_overflow_signed, /* complain_on_overflow */
 695          ppc64_elf_unhandled_reloc, /* special_function */
 696          "R_PPC64_PLTREL32",    /* name */
 697          FALSE,                 /* partial_inplace */
 698          0,                     /* src_mask */
 699          0xffffffff,            /* dst_mask */
 700          TRUE),                 /* pcrel_offset */
 701
 702   /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
 703      the symbol.  */
 704   HOWTO (R_PPC64_PLT16_LO,      /* type */
 705          0,                     /* rightshift */
 706          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 707          16,                    /* bitsize */
 708          FALSE,                 /* pc_relative */
 709          0,                     /* bitpos */
 710          complain_overflow_dont, /* complain_on_overflow */
 711          ppc64_elf_unhandled_reloc, /* special_function */
 712          "R_PPC64_PLT16_LO",    /* name */
 713          FALSE,                 /* partial_inplace */
 714          0,                     /* src_mask */
 715          0xffff,                /* dst_mask */
 716          FALSE),                /* pcrel_offset */
 717
 718   /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
 719      the symbol.  */
 720   HOWTO (R_PPC64_PLT16_HI,      /* type */
 721          16,                    /* rightshift */
 722          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 723          16,                    /* bitsize */
 724          FALSE,                 /* pc_relative */
 725          0,                     /* bitpos */
 726          complain_overflow_signed, /* complain_on_overflow */
 727          ppc64_elf_unhandled_reloc, /* special_function */
 728          "R_PPC64_PLT16_HI",    /* name */
 729          FALSE,                 /* partial_inplace */
 730          0,                     /* src_mask */
 731          0xffff,                /* dst_mask */
 732          FALSE),                /* pcrel_offset */
 733
 734   /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
 735      the symbol.  */
 736   HOWTO (R_PPC64_PLT16_HA,      /* type */
 737          16,                    /* rightshift */
 738          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 739          16,                    /* bitsize */
 740          FALSE,                 /* pc_relative */
 741          0,                     /* bitpos */
 742          complain_overflow_signed, /* complain_on_overflow */
 743          ppc64_elf_unhandled_reloc, /* special_function */
 744          "R_PPC64_PLT16_HA",    /* name */
 745          FALSE,                 /* partial_inplace */
 746          0,                     /* src_mask */
 747          0xffff,                /* dst_mask */
 748          FALSE),                /* pcrel_offset */
 749
 750   /* 16-bit section relative relocation.  */
 751   HOWTO (R_PPC64_SECTOFF,       /* type */
 752          0,                     /* rightshift */
 753          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 754          16,                    /* bitsize */
 755          FALSE,                 /* pc_relative */
 756          0,                     /* bitpos */
 757          complain_overflow_signed, /* complain_on_overflow */
 758          ppc64_elf_sectoff_reloc, /* special_function */
 759          "R_PPC64_SECTOFF",     /* name */
 760          FALSE,                 /* partial_inplace */
 761          0,                     /* src_mask */
 762          0xffff,                /* dst_mask */
 763          FALSE),                /* pcrel_offset */
 764
 765   /* Like R_PPC64_SECTOFF, but no overflow warning.  */
 766   HOWTO (R_PPC64_SECTOFF_LO,    /* type */
 767          0,                     /* rightshift */
 768          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 769          16,                    /* bitsize */
 770          FALSE,                 /* pc_relative */
 771          0,                     /* bitpos */
 772          complain_overflow_dont, /* complain_on_overflow */
 773          ppc64_elf_sectoff_reloc, /* special_function */
 774          "R_PPC64_SECTOFF_LO",  /* name */
 775          FALSE,                 /* partial_inplace */
 776          0,                     /* src_mask */
 777          0xffff,                /* dst_mask */
 778          FALSE),                /* pcrel_offset */
 779
 780   /* 16-bit upper half section relative relocation.  */
 781   HOWTO (R_PPC64_SECTOFF_HI,    /* type */
 782          16,                    /* rightshift */
 783          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 784          16,                    /* bitsize */
 785          FALSE,                 /* pc_relative */
 786          0,                     /* bitpos */
 787          complain_overflow_signed, /* complain_on_overflow */
 788          ppc64_elf_sectoff_reloc, /* special_function */
 789          "R_PPC64_SECTOFF_HI",  /* name */
 790          FALSE,                 /* partial_inplace */
 791          0,                     /* src_mask */
 792          0xffff,                /* dst_mask */
 793          FALSE),                /* pcrel_offset */
 794
 795   /* 16-bit upper half adjusted section relative relocation.  */
 796   HOWTO (R_PPC64_SECTOFF_HA,    /* type */
 797          16,                    /* rightshift */
 798          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 799          16,                    /* bitsize */
 800          FALSE,                 /* pc_relative */
 801          0,                     /* bitpos */
 802          complain_overflow_signed, /* complain_on_overflow */
 803          ppc64_elf_sectoff_ha_reloc, /* special_function */
 804          "R_PPC64_SECTOFF_HA",  /* name */
 805          FALSE,                 /* partial_inplace */
 806          0,                     /* src_mask */
 807          0xffff,                /* dst_mask */
 808          FALSE),                /* pcrel_offset */
 809
 810   /* Like R_PPC64_REL24 without touching the two least significant bits.  */
 811   HOWTO (R_PPC64_REL30,         /* type */
 812          2,                     /* rightshift */
 813          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 814          30,                    /* bitsize */
 815          TRUE,                  /* pc_relative */
 816          0,                     /* bitpos */
 817          complain_overflow_dont, /* complain_on_overflow */
 818          bfd_elf_generic_reloc, /* special_function */
 819          "R_PPC64_REL30",       /* name */
 820          FALSE,                 /* partial_inplace */
 821          0,                     /* src_mask */
 822          0xfffffffc,            /* dst_mask */
 823          TRUE),                 /* pcrel_offset */
 824
 825   /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI.  */
 826
 827   /* A standard 64-bit relocation.  */
 828   HOWTO (R_PPC64_ADDR64,        /* type */
 829          0,                     /* rightshift */
 830          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 831          64,                    /* bitsize */
 832          FALSE,                 /* pc_relative */
 833          0,                     /* bitpos */
 834          complain_overflow_dont, /* complain_on_overflow */
 835          bfd_elf_generic_reloc, /* special_function */
 836          "R_PPC64_ADDR64",      /* name */
 837          FALSE,                 /* partial_inplace */
 838          0,                     /* src_mask */
 839          ONES (64),             /* dst_mask */
 840          FALSE),                /* pcrel_offset */
 841
 842   /* The bits 32-47 of an address.  */
 843   HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
 844          32,                    /* rightshift */
 845          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 846          16,                    /* bitsize */
 847          FALSE,                 /* pc_relative */
 848          0,                     /* bitpos */
 849          complain_overflow_dont, /* complain_on_overflow */
 850          bfd_elf_generic_reloc, /* special_function */
 851          "R_PPC64_ADDR16_HIGHER", /* name */
 852          FALSE,                 /* partial_inplace */
 853          0,                     /* src_mask */
 854          0xffff,                /* dst_mask */
 855          FALSE),                /* pcrel_offset */
 856
 857   /* The bits 32-47 of an address, plus 1 if the contents of the low
 858      16 bits, treated as a signed number, is negative.  */
 859   HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
 860          32,                    /* rightshift */
 861          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 862          16,                    /* bitsize */
 863          FALSE,                 /* pc_relative */
 864          0,                     /* bitpos */
 865          complain_overflow_dont, /* complain_on_overflow */
 866          ppc64_elf_ha_reloc,    /* special_function */
 867          "R_PPC64_ADDR16_HIGHERA", /* name */
 868          FALSE,                 /* partial_inplace */
 869          0,                     /* src_mask */
 870          0xffff,                /* dst_mask */
 871          FALSE),                /* pcrel_offset */
 872
 873   /* The bits 48-63 of an address.  */
 874   HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
 875          48,                    /* rightshift */
 876          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 877          16,                    /* bitsize */
 878          FALSE,                 /* pc_relative */
 879          0,                     /* bitpos */
 880          complain_overflow_dont, /* complain_on_overflow */
 881          bfd_elf_generic_reloc, /* special_function */
 882          "R_PPC64_ADDR16_HIGHEST", /* name */
 883          FALSE,                 /* partial_inplace */
 884          0,                     /* src_mask */
 885          0xffff,                /* dst_mask */
 886          FALSE),                /* pcrel_offset */
 887
 888   /* The bits 48-63 of an address, plus 1 if the contents of the low
 889      16 bits, treated as a signed number, is negative.  */
 890   HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
 891          48,                    /* rightshift */
 892          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 893          16,                    /* bitsize */
 894          FALSE,                 /* pc_relative */
 895          0,                     /* bitpos */
 896          complain_overflow_dont, /* complain_on_overflow */
 897          ppc64_elf_ha_reloc,    /* special_function */
 898          "R_PPC64_ADDR16_HIGHESTA", /* name */
 899          FALSE,                 /* partial_inplace */
 900          0,                     /* src_mask */
 901          0xffff,                /* dst_mask */
 902          FALSE),                /* pcrel_offset */
 903
 904   /* Like ADDR64, but may be unaligned.  */
 905   HOWTO (R_PPC64_UADDR64,       /* type */
 906          0,                     /* rightshift */
 907          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 908          64,                    /* bitsize */
 909          FALSE,                 /* pc_relative */
 910          0,                     /* bitpos */
 911          complain_overflow_dont, /* complain_on_overflow */
 912          bfd_elf_generic_reloc, /* special_function */
 913          "R_PPC64_UADDR64",     /* name */
 914          FALSE,                 /* partial_inplace */
 915          0,                     /* src_mask */
 916          ONES (64),             /* dst_mask */
 917          FALSE),                /* pcrel_offset */
 918
 919   /* 64-bit relative relocation.  */
 920   HOWTO (R_PPC64_REL64,         /* type */
 921          0,                     /* rightshift */
 922          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 923          64,                    /* bitsize */
 924          TRUE,                  /* pc_relative */
 925          0,                     /* bitpos */
 926          complain_overflow_dont, /* complain_on_overflow */
 927          bfd_elf_generic_reloc, /* special_function */
 928          "R_PPC64_REL64",       /* name */
 929          FALSE,                 /* partial_inplace */
 930          0,                     /* src_mask */
 931          ONES (64),             /* dst_mask */
 932          TRUE),                 /* pcrel_offset */
 933
 934   /* 64-bit relocation to the symbol's procedure linkage table.  */
 935   HOWTO (R_PPC64_PLT64,         /* type */
 936          0,                     /* rightshift */
 937          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 938          64,                    /* bitsize */
 939          FALSE,                 /* pc_relative */
 940          0,                     /* bitpos */
 941          complain_overflow_dont, /* complain_on_overflow */
 942          ppc64_elf_unhandled_reloc, /* special_function */
 943          "R_PPC64_PLT64",       /* name */
 944          FALSE,                 /* partial_inplace */
 945          0,                     /* src_mask */
 946          ONES (64),             /* dst_mask */
 947          FALSE),                /* pcrel_offset */
 948
 949   /* 64-bit PC relative relocation to the symbol's procedure linkage
 950      table.  */
 951   /* FIXME: R_PPC64_PLTREL64 not supported.  */
 952   HOWTO (R_PPC64_PLTREL64,      /* type */
 953          0,                     /* rightshift */
 954          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 955          64,                    /* bitsize */
 956          TRUE,                  /* pc_relative */
 957          0,                     /* bitpos */
 958          complain_overflow_dont, /* complain_on_overflow */
 959          ppc64_elf_unhandled_reloc, /* special_function */
 960          "R_PPC64_PLTREL64",    /* name */
 961          FALSE,                 /* partial_inplace */
 962          0,                     /* src_mask */
 963          ONES (64),             /* dst_mask */
 964          TRUE),                 /* pcrel_offset */
 965
 966   /* 16 bit TOC-relative relocation.  */
 967
 968   /* R_PPC64_TOC16        47       half16*      S + A - .TOC.  */
 969   HOWTO (R_PPC64_TOC16,         /* type */
 970          0,                     /* rightshift */
 971          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 972          16,                    /* bitsize */
 973          FALSE,                 /* pc_relative */
 974          0,                     /* bitpos */
 975          complain_overflow_signed, /* complain_on_overflow */
 976          ppc64_elf_toc_reloc,   /* special_function */
 977          "R_PPC64_TOC16",       /* name */
 978          FALSE,                 /* partial_inplace */
 979          0,                     /* src_mask */
 980          0xffff,                /* dst_mask */
 981          FALSE),                /* pcrel_offset */
 982
 983   /* 16 bit TOC-relative relocation without overflow.  */
 984
 985   /* R_PPC64_TOC16_LO     48       half16        #lo (S + A - .TOC.)  */
 986   HOWTO (R_PPC64_TOC16_LO,      /* type */
 987          0,                     /* rightshift */
 988          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 989          16,                    /* bitsize */
 990          FALSE,                 /* pc_relative */
 991          0,                     /* bitpos */
 992          complain_overflow_dont, /* complain_on_overflow */
 993          ppc64_elf_toc_reloc,   /* special_function */
 994          "R_PPC64_TOC16_LO",    /* name */
 995          FALSE,                 /* partial_inplace */
 996          0,                     /* src_mask */
 997          0xffff,                /* dst_mask */
 998          FALSE),                /* pcrel_offset */
 999
1000   /* 16 bit TOC-relative relocation, high 16 bits.  */
1001
1002   /* R_PPC64_TOC16_HI     49       half16        #hi (S + A - .TOC.)  */
1003   HOWTO (R_PPC64_TOC16_HI,      /* type */
1004          16,                    /* rightshift */
1005          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1006          16,                    /* bitsize */
1007          FALSE,                 /* pc_relative */
1008          0,                     /* bitpos */
1009          complain_overflow_signed, /* complain_on_overflow */
1010          ppc64_elf_toc_reloc,   /* special_function */
1011          "R_PPC64_TOC16_HI",    /* name */
1012          FALSE,                 /* partial_inplace */
1013          0,                     /* src_mask */
1014          0xffff,                /* dst_mask */
1015          FALSE),                /* pcrel_offset */
1016
1017   /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
1018      contents of the low 16 bits, treated as a signed number, is
1019      negative.  */
1020
1021   /* R_PPC64_TOC16_HA     50       half16        #ha (S + A - .TOC.)  */
1022   HOWTO (R_PPC64_TOC16_HA,      /* type */
1023          16,                    /* rightshift */
1024          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1025          16,                    /* bitsize */
1026          FALSE,                 /* pc_relative */
1027          0,                     /* bitpos */
1028          complain_overflow_signed, /* complain_on_overflow */
1029          ppc64_elf_toc_ha_reloc, /* special_function */
1030          "R_PPC64_TOC16_HA",    /* name */
1031          FALSE,                 /* partial_inplace */
1032          0,                     /* src_mask */
1033          0xffff,                /* dst_mask */
1034          FALSE),                /* pcrel_offset */
1035
1036   /* 64-bit relocation; insert value of TOC base (.TOC.).  */
1037
1038   /* R_PPC64_TOC                  51       doubleword64  .TOC.  */
1039   HOWTO (R_PPC64_TOC,           /* type */
1040          0,                     /* rightshift */
1041          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1042          64,                    /* bitsize */
1043          FALSE,                 /* pc_relative */
1044          0,                     /* bitpos */
1045          complain_overflow_dont, /* complain_on_overflow */
1046          ppc64_elf_toc64_reloc, /* special_function */
1047          "R_PPC64_TOC",         /* name */
1048          FALSE,                 /* partial_inplace */
1049          0,                     /* src_mask */
1050          ONES (64),             /* dst_mask */
1051          FALSE),                /* pcrel_offset */
1052
1053   /* Like R_PPC64_GOT16, but also informs the link editor that the
1054      value to relocate may (!) refer to a PLT entry which the link
1055      editor (a) may replace with the symbol value.  If the link editor
1056      is unable to fully resolve the symbol, it may (b) create a PLT
1057      entry and store the address to the new PLT entry in the GOT.
1058      This permits lazy resolution of function symbols at run time.
1059      The link editor may also skip all of this and just (c) emit a
1060      R_PPC64_GLOB_DAT to tie the symbol to the GOT entry.  */
1061   /* FIXME: R_PPC64_PLTGOT16 not implemented.  */
1062     HOWTO (R_PPC64_PLTGOT16,    /* type */
1063          0,                     /* rightshift */
1064          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1065          16,                    /* bitsize */
1066          FALSE,                 /* pc_relative */
1067          0,                     /* bitpos */
1068          complain_overflow_signed, /* complain_on_overflow */
1069          ppc64_elf_unhandled_reloc, /* special_function */
1070          "R_PPC64_PLTGOT16",    /* name */
1071          FALSE,                 /* partial_inplace */
1072          0,                     /* src_mask */
1073          0xffff,                /* dst_mask */
1074          FALSE),                /* pcrel_offset */
1075
1076   /* Like R_PPC64_PLTGOT16, but without overflow.  */
1077   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1078   HOWTO (R_PPC64_PLTGOT16_LO,   /* type */
1079          0,                     /* rightshift */
1080          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1081          16,                    /* bitsize */
1082          FALSE,                 /* pc_relative */
1083          0,                     /* bitpos */
1084          complain_overflow_dont, /* complain_on_overflow */
1085          ppc64_elf_unhandled_reloc, /* special_function */
1086          "R_PPC64_PLTGOT16_LO", /* name */
1087          FALSE,                 /* partial_inplace */
1088          0,                     /* src_mask */
1089          0xffff,                /* dst_mask */
1090          FALSE),                /* pcrel_offset */
1091
1092   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address.  */
1093   /* FIXME: R_PPC64_PLTGOT16_HI not implemented.  */
1094   HOWTO (R_PPC64_PLTGOT16_HI,   /* type */
1095          16,                    /* rightshift */
1096          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1097          16,                    /* bitsize */
1098          FALSE,                 /* pc_relative */
1099          0,                     /* bitpos */
1100          complain_overflow_signed, /* complain_on_overflow */
1101          ppc64_elf_unhandled_reloc, /* special_function */
1102          "R_PPC64_PLTGOT16_HI", /* name */
1103          FALSE,                 /* partial_inplace */
1104          0,                     /* src_mask */
1105          0xffff,                /* dst_mask */
1106          FALSE),                /* pcrel_offset */
1107
1108   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1109      1 if the contents of the low 16 bits, treated as a signed number,
1110      is negative.  */
1111   /* FIXME: R_PPC64_PLTGOT16_HA not implemented.  */
1112   HOWTO (R_PPC64_PLTGOT16_HA,   /* type */
1113          16,                    /* rightshift */
1114          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1115          16,                    /* bitsize */
1116          FALSE,                 /* pc_relative */
1117          0,                     /* bitpos */
1118          complain_overflow_signed, /* complain_on_overflow */
1119          ppc64_elf_unhandled_reloc, /* special_function */
1120          "R_PPC64_PLTGOT16_HA", /* name */
1121          FALSE,                 /* partial_inplace */
1122          0,                     /* src_mask */
1123          0xffff,                /* dst_mask */
1124          FALSE),                /* pcrel_offset */
1125
1126   /* Like R_PPC64_ADDR16, but for instructions with a DS field.  */
1127   HOWTO (R_PPC64_ADDR16_DS,     /* type */
1128          0,                     /* rightshift */
1129          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1130          16,                    /* bitsize */
1131          FALSE,                 /* pc_relative */
1132          0,                     /* bitpos */
1133          complain_overflow_signed, /* complain_on_overflow */
1134          bfd_elf_generic_reloc, /* special_function */
1135          "R_PPC64_ADDR16_DS",   /* name */
1136          FALSE,                 /* partial_inplace */
1137          0,                     /* src_mask */
1138          0xfffc,                /* dst_mask */
1139          FALSE),                /* pcrel_offset */
1140
1141   /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field.  */
1142   HOWTO (R_PPC64_ADDR16_LO_DS,  /* type */
1143          0,                     /* rightshift */
1144          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1145          16,                    /* bitsize */
1146          FALSE,                 /* pc_relative */
1147          0,                     /* bitpos */
1148          complain_overflow_dont,/* complain_on_overflow */
1149          bfd_elf_generic_reloc, /* special_function */
1150          "R_PPC64_ADDR16_LO_DS",/* name */
1151          FALSE,                 /* partial_inplace */
1152          0,                     /* src_mask */
1153          0xfffc,                /* dst_mask */
1154          FALSE),                /* pcrel_offset */
1155
1156   /* Like R_PPC64_GOT16, but for instructions with a DS field.  */
1157   HOWTO (R_PPC64_GOT16_DS,      /* type */
1158          0,                     /* rightshift */
1159          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1160          16,                    /* bitsize */
1161          FALSE,                 /* pc_relative */
1162          0,                     /* bitpos */
1163          complain_overflow_signed, /* complain_on_overflow */
1164          ppc64_elf_unhandled_reloc, /* special_function */
1165          "R_PPC64_GOT16_DS",    /* name */
1166          FALSE,                 /* partial_inplace */
1167          0,                     /* src_mask */
1168          0xfffc,                /* dst_mask */
1169          FALSE),                /* pcrel_offset */
1170
1171   /* Like R_PPC64_GOT16_LO, but for instructions with a DS field.  */
1172   HOWTO (R_PPC64_GOT16_LO_DS,   /* type */
1173          0,                     /* rightshift */
1174          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1175          16,                    /* bitsize */
1176          FALSE,                 /* pc_relative */
1177          0,                     /* bitpos */
1178          complain_overflow_dont, /* complain_on_overflow */
1179          ppc64_elf_unhandled_reloc, /* special_function */
1180          "R_PPC64_GOT16_LO_DS", /* name */
1181          FALSE,                 /* partial_inplace */
1182          0,                     /* src_mask */
1183          0xfffc,                /* dst_mask */
1184          FALSE),                /* pcrel_offset */
1185
1186   /* Like R_PPC64_PLT16_LO, but for instructions with a DS field.  */
1187   HOWTO (R_PPC64_PLT16_LO_DS,   /* type */
1188          0,                     /* rightshift */
1189          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1190          16,                    /* bitsize */
1191          FALSE,                 /* pc_relative */
1192          0,                     /* bitpos */
1193          complain_overflow_dont, /* complain_on_overflow */
1194          ppc64_elf_unhandled_reloc, /* special_function */
1195          "R_PPC64_PLT16_LO_DS", /* name */
1196          FALSE,                 /* partial_inplace */
1197          0,                     /* src_mask */
1198          0xfffc,                /* dst_mask */
1199          FALSE),                /* pcrel_offset */
1200
1201   /* Like R_PPC64_SECTOFF, but for instructions with a DS field.  */
1202   HOWTO (R_PPC64_SECTOFF_DS,    /* type */
1203          0,                     /* rightshift */
1204          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1205          16,                    /* bitsize */
1206          FALSE,                 /* pc_relative */
1207          0,                     /* bitpos */
1208          complain_overflow_signed, /* complain_on_overflow */
1209          ppc64_elf_sectoff_reloc, /* special_function */
1210          "R_PPC64_SECTOFF_DS",  /* name */
1211          FALSE,                 /* partial_inplace */
1212          0,                     /* src_mask */
1213          0xfffc,                /* dst_mask */
1214          FALSE),                /* pcrel_offset */
1215
1216   /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field.  */
1217   HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1218          0,                     /* rightshift */
1219          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1220          16,                    /* bitsize */
1221          FALSE,                 /* pc_relative */
1222          0,                     /* bitpos */
1223          complain_overflow_dont, /* complain_on_overflow */
1224          ppc64_elf_sectoff_reloc, /* special_function */
1225          "R_PPC64_SECTOFF_LO_DS",/* name */
1226          FALSE,                 /* partial_inplace */
1227          0,                     /* src_mask */
1228          0xfffc,                /* dst_mask */
1229          FALSE),                /* pcrel_offset */
1230
1231   /* Like R_PPC64_TOC16, but for instructions with a DS field.  */
1232   HOWTO (R_PPC64_TOC16_DS,      /* type */
1233          0,                     /* rightshift */
1234          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1235          16,                    /* bitsize */
1236          FALSE,                 /* pc_relative */
1237          0,                     /* bitpos */
1238          complain_overflow_signed, /* complain_on_overflow */
1239          ppc64_elf_toc_reloc,   /* special_function */
1240          "R_PPC64_TOC16_DS",    /* name */
1241          FALSE,                 /* partial_inplace */
1242          0,                     /* src_mask */
1243          0xfffc,                /* dst_mask */
1244          FALSE),                /* pcrel_offset */
1245
1246   /* Like R_PPC64_TOC16_LO, but for instructions with a DS field.  */
1247   HOWTO (R_PPC64_TOC16_LO_DS,   /* type */
1248          0,                     /* rightshift */
1249          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1250          16,                    /* bitsize */
1251          FALSE,                 /* pc_relative */
1252          0,                     /* bitpos */
1253          complain_overflow_dont, /* complain_on_overflow */
1254          ppc64_elf_toc_reloc,   /* special_function */
1255          "R_PPC64_TOC16_LO_DS", /* name */
1256          FALSE,                 /* partial_inplace */
1257          0,                     /* src_mask */
1258          0xfffc,                /* dst_mask */
1259          FALSE),                /* pcrel_offset */
1260
1261   /* Like R_PPC64_PLTGOT16, but for instructions with a DS field.  */
1262   /* FIXME: R_PPC64_PLTGOT16_DS not implemented.  */
1263   HOWTO (R_PPC64_PLTGOT16_DS,   /* type */
1264          0,                     /* rightshift */
1265          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1266          16,                    /* bitsize */
1267          FALSE,                 /* pc_relative */
1268          0,                     /* bitpos */
1269          complain_overflow_signed, /* complain_on_overflow */
1270          ppc64_elf_unhandled_reloc, /* special_function */
1271          "R_PPC64_PLTGOT16_DS", /* name */
1272          FALSE,                 /* partial_inplace */
1273          0,                     /* src_mask */
1274          0xfffc,                /* dst_mask */
1275          FALSE),                /* pcrel_offset */
1276
1277   /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field.  */
1278   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1279   HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1280          0,                     /* rightshift */
1281          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1282          16,                    /* bitsize */
1283          FALSE,                 /* pc_relative */
1284          0,                     /* bitpos */
1285          complain_overflow_dont, /* complain_on_overflow */
1286          ppc64_elf_unhandled_reloc, /* special_function */
1287          "R_PPC64_PLTGOT16_LO_DS",/* name */
1288          FALSE,                 /* partial_inplace */
1289          0,                     /* src_mask */
1290          0xfffc,                /* dst_mask */
1291          FALSE),                /* pcrel_offset */
1292
1293   /* Marker relocs for TLS.  */
1294   HOWTO (R_PPC64_TLS,
1295          0,                     /* rightshift */
1296          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1297          32,                    /* bitsize */
1298          FALSE,                 /* pc_relative */
1299          0,                     /* bitpos */
1300          complain_overflow_dont, /* complain_on_overflow */
1301          bfd_elf_generic_reloc, /* special_function */
1302          "R_PPC64_TLS",         /* name */
1303          FALSE,                 /* partial_inplace */
1304          0,                     /* src_mask */
1305          0,                     /* dst_mask */
1306          FALSE),                /* pcrel_offset */
1307
1308   HOWTO (R_PPC64_TLSGD,
1309          0,                     /* rightshift */
1310          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1311          32,                    /* bitsize */
1312          FALSE,                 /* pc_relative */
1313          0,                     /* bitpos */
1314          complain_overflow_dont, /* complain_on_overflow */
1315          bfd_elf_generic_reloc, /* special_function */
1316          "R_PPC64_TLSGD",       /* name */
1317          FALSE,                 /* partial_inplace */
1318          0,                     /* src_mask */
1319          0,                     /* dst_mask */
1320          FALSE),                /* pcrel_offset */
1321
1322   HOWTO (R_PPC64_TLSLD,
1323          0,                     /* rightshift */
1324          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1325          32,                    /* bitsize */
1326          FALSE,                 /* pc_relative */
1327          0,                     /* bitpos */
1328          complain_overflow_dont, /* complain_on_overflow */
1329          bfd_elf_generic_reloc, /* special_function */
1330          "R_PPC64_TLSLD",       /* name */
1331          FALSE,                 /* partial_inplace */
1332          0,                     /* src_mask */
1333          0,                     /* dst_mask */
1334          FALSE),                /* pcrel_offset */
1335
1336   HOWTO (R_PPC64_TOCSAVE,
1337          0,                     /* rightshift */
1338          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1339          32,                    /* bitsize */
1340          FALSE,                 /* pc_relative */
1341          0,                     /* bitpos */
1342          complain_overflow_dont, /* complain_on_overflow */
1343          bfd_elf_generic_reloc, /* special_function */
1344          "R_PPC64_TOCSAVE",     /* name */
1345          FALSE,                 /* partial_inplace */
1346          0,                     /* src_mask */
1347          0,                     /* dst_mask */
1348          FALSE),                /* pcrel_offset */
1349
1350   /* Computes the load module index of the load module that contains the
1351      definition of its TLS sym.  */
1352   HOWTO (R_PPC64_DTPMOD64,
1353          0,                     /* rightshift */
1354          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1355          64,                    /* bitsize */
1356          FALSE,                 /* pc_relative */
1357          0,                     /* bitpos */
1358          complain_overflow_dont, /* complain_on_overflow */
1359          ppc64_elf_unhandled_reloc, /* special_function */
1360          "R_PPC64_DTPMOD64",    /* name */
1361          FALSE,                 /* partial_inplace */
1362          0,                     /* src_mask */
1363          ONES (64),             /* dst_mask */
1364          FALSE),                /* pcrel_offset */
1365
1366   /* Computes a dtv-relative displacement, the difference between the value
1367      of sym+add and the base address of the thread-local storage block that
1368      contains the definition of sym, minus 0x8000.  */
1369   HOWTO (R_PPC64_DTPREL64,
1370          0,                     /* rightshift */
1371          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1372          64,                    /* bitsize */
1373          FALSE,                 /* pc_relative */
1374          0,                     /* bitpos */
1375          complain_overflow_dont, /* complain_on_overflow */
1376          ppc64_elf_unhandled_reloc, /* special_function */
1377          "R_PPC64_DTPREL64",    /* name */
1378          FALSE,                 /* partial_inplace */
1379          0,                     /* src_mask */
1380          ONES (64),             /* dst_mask */
1381          FALSE),                /* pcrel_offset */
1382
1383   /* A 16 bit dtprel reloc.  */
1384   HOWTO (R_PPC64_DTPREL16,
1385          0,                     /* rightshift */
1386          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1387          16,                    /* bitsize */
1388          FALSE,                 /* pc_relative */
1389          0,                     /* bitpos */
1390          complain_overflow_signed, /* complain_on_overflow */
1391          ppc64_elf_unhandled_reloc, /* special_function */
1392          "R_PPC64_DTPREL16",    /* name */
1393          FALSE,                 /* partial_inplace */
1394          0,                     /* src_mask */
1395          0xffff,                /* dst_mask */
1396          FALSE),                /* pcrel_offset */
1397
1398   /* Like DTPREL16, but no overflow.  */
1399   HOWTO (R_PPC64_DTPREL16_LO,
1400          0,                     /* rightshift */
1401          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1402          16,                    /* bitsize */
1403          FALSE,                 /* pc_relative */
1404          0,                     /* bitpos */
1405          complain_overflow_dont, /* complain_on_overflow */
1406          ppc64_elf_unhandled_reloc, /* special_function */
1407          "R_PPC64_DTPREL16_LO", /* name */
1408          FALSE,                 /* partial_inplace */
1409          0,                     /* src_mask */
1410          0xffff,                /* dst_mask */
1411          FALSE),                /* pcrel_offset */
1412
1413   /* Like DTPREL16_LO, but next higher group of 16 bits.  */
1414   HOWTO (R_PPC64_DTPREL16_HI,
1415          16,                    /* rightshift */
1416          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1417          16,                    /* bitsize */
1418          FALSE,                 /* pc_relative */
1419          0,                     /* bitpos */
1420          complain_overflow_signed, /* complain_on_overflow */
1421          ppc64_elf_unhandled_reloc, /* special_function */
1422          "R_PPC64_DTPREL16_HI", /* name */
1423          FALSE,                 /* partial_inplace */
1424          0,                     /* src_mask */
1425          0xffff,                /* dst_mask */
1426          FALSE),                /* pcrel_offset */
1427
1428   /* Like DTPREL16_HI, but adjust for low 16 bits.  */
1429   HOWTO (R_PPC64_DTPREL16_HA,
1430          16,                    /* rightshift */
1431          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1432          16,                    /* bitsize */
1433          FALSE,                 /* pc_relative */
1434          0,                     /* bitpos */
1435          complain_overflow_signed, /* complain_on_overflow */
1436          ppc64_elf_unhandled_reloc, /* special_function */
1437          "R_PPC64_DTPREL16_HA", /* name */
1438          FALSE,                 /* partial_inplace */
1439          0,                     /* src_mask */
1440          0xffff,                /* dst_mask */
1441          FALSE),                /* pcrel_offset */
1442
1443   /* Like DTPREL16_HI, but next higher group of 16 bits.  */
1444   HOWTO (R_PPC64_DTPREL16_HIGHER,
1445          32,                    /* rightshift */
1446          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1447          16,                    /* bitsize */
1448          FALSE,                 /* pc_relative */
1449          0,                     /* bitpos */
1450          complain_overflow_dont, /* complain_on_overflow */
1451          ppc64_elf_unhandled_reloc, /* special_function */
1452          "R_PPC64_DTPREL16_HIGHER", /* name */
1453          FALSE,                 /* partial_inplace */
1454          0,                     /* src_mask */
1455          0xffff,                /* dst_mask */
1456          FALSE),                /* pcrel_offset */
1457
1458   /* Like DTPREL16_HIGHER, but adjust for low 16 bits.  */
1459   HOWTO (R_PPC64_DTPREL16_HIGHERA,
1460          32,                    /* rightshift */
1461          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1462          16,                    /* bitsize */
1463          FALSE,                 /* pc_relative */
1464          0,                     /* bitpos */
1465          complain_overflow_dont, /* complain_on_overflow */
1466          ppc64_elf_unhandled_reloc, /* special_function */
1467          "R_PPC64_DTPREL16_HIGHERA", /* name */
1468          FALSE,                 /* partial_inplace */
1469          0,                     /* src_mask */
1470          0xffff,                /* dst_mask */
1471          FALSE),                /* pcrel_offset */
1472
1473   /* Like DTPREL16_HIGHER, but next higher group of 16 bits.  */
1474   HOWTO (R_PPC64_DTPREL16_HIGHEST,
1475          48,                    /* rightshift */
1476          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1477          16,                    /* bitsize */
1478          FALSE,                 /* pc_relative */
1479          0,                     /* bitpos */
1480          complain_overflow_dont, /* complain_on_overflow */
1481          ppc64_elf_unhandled_reloc, /* special_function */
1482          "R_PPC64_DTPREL16_HIGHEST", /* name */
1483          FALSE,                 /* partial_inplace */
1484          0,                     /* src_mask */
1485          0xffff,                /* dst_mask */
1486          FALSE),                /* pcrel_offset */
1487
1488   /* Like DTPREL16_HIGHEST, but adjust for low 16 bits.  */
1489   HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1490          48,                    /* rightshift */
1491          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1492          16,                    /* bitsize */
1493          FALSE,                 /* pc_relative */
1494          0,                     /* bitpos */
1495          complain_overflow_dont, /* complain_on_overflow */
1496          ppc64_elf_unhandled_reloc, /* special_function */
1497          "R_PPC64_DTPREL16_HIGHESTA", /* name */
1498          FALSE,                 /* partial_inplace */
1499          0,                     /* src_mask */
1500          0xffff,                /* dst_mask */
1501          FALSE),                /* pcrel_offset */
1502
1503   /* Like DTPREL16, but for insns with a DS field.  */
1504   HOWTO (R_PPC64_DTPREL16_DS,
1505          0,                     /* rightshift */
1506          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1507          16,                    /* bitsize */
1508          FALSE,                 /* pc_relative */
1509          0,                     /* bitpos */
1510          complain_overflow_signed, /* complain_on_overflow */
1511          ppc64_elf_unhandled_reloc, /* special_function */
1512          "R_PPC64_DTPREL16_DS", /* name */
1513          FALSE,                 /* partial_inplace */
1514          0,                     /* src_mask */
1515          0xfffc,                /* dst_mask */
1516          FALSE),                /* pcrel_offset */
1517
1518   /* Like DTPREL16_DS, but no overflow.  */
1519   HOWTO (R_PPC64_DTPREL16_LO_DS,
1520          0,                     /* rightshift */
1521          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1522          16,                    /* bitsize */
1523          FALSE,                 /* pc_relative */
1524          0,                     /* bitpos */
1525          complain_overflow_dont, /* complain_on_overflow */
1526          ppc64_elf_unhandled_reloc, /* special_function */
1527          "R_PPC64_DTPREL16_LO_DS", /* name */
1528          FALSE,                 /* partial_inplace */
1529          0,                     /* src_mask */
1530          0xfffc,                /* dst_mask */
1531          FALSE),                /* pcrel_offset */
1532
1533   /* Computes a tp-relative displacement, the difference between the value of
1534      sym+add and the value of the thread pointer (r13).  */
1535   HOWTO (R_PPC64_TPREL64,
1536          0,                     /* rightshift */
1537          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1538          64,                    /* bitsize */
1539          FALSE,                 /* pc_relative */
1540          0,                     /* bitpos */
1541          complain_overflow_dont, /* complain_on_overflow */
1542          ppc64_elf_unhandled_reloc, /* special_function */
1543          "R_PPC64_TPREL64",     /* name */
1544          FALSE,                 /* partial_inplace */
1545          0,                     /* src_mask */
1546          ONES (64),             /* dst_mask */
1547          FALSE),                /* pcrel_offset */
1548
1549   /* A 16 bit tprel reloc.  */
1550   HOWTO (R_PPC64_TPREL16,
1551          0,                     /* rightshift */
1552          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1553          16,                    /* bitsize */
1554          FALSE,                 /* pc_relative */
1555          0,                     /* bitpos */
1556          complain_overflow_signed, /* complain_on_overflow */
1557          ppc64_elf_unhandled_reloc, /* special_function */
1558          "R_PPC64_TPREL16",     /* name */
1559          FALSE,                 /* partial_inplace */
1560          0,                     /* src_mask */
1561          0xffff,                /* dst_mask */
1562          FALSE),                /* pcrel_offset */
1563
1564   /* Like TPREL16, but no overflow.  */
1565   HOWTO (R_PPC64_TPREL16_LO,
1566          0,                     /* rightshift */
1567          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1568          16,                    /* bitsize */
1569          FALSE,                 /* pc_relative */
1570          0,                     /* bitpos */
1571          complain_overflow_dont, /* complain_on_overflow */
1572          ppc64_elf_unhandled_reloc, /* special_function */
1573          "R_PPC64_TPREL16_LO",  /* name */
1574          FALSE,                 /* partial_inplace */
1575          0,                     /* src_mask */
1576          0xffff,                /* dst_mask */
1577          FALSE),                /* pcrel_offset */
1578
1579   /* Like TPREL16_LO, but next higher group of 16 bits.  */
1580   HOWTO (R_PPC64_TPREL16_HI,
1581          16,                    /* rightshift */
1582          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1583          16,                    /* bitsize */
1584          FALSE,                 /* pc_relative */
1585          0,                     /* bitpos */
1586          complain_overflow_signed, /* complain_on_overflow */
1587          ppc64_elf_unhandled_reloc, /* special_function */
1588          "R_PPC64_TPREL16_HI",  /* name */
1589          FALSE,                 /* partial_inplace */
1590          0,                     /* src_mask */
1591          0xffff,                /* dst_mask */
1592          FALSE),                /* pcrel_offset */
1593
1594   /* Like TPREL16_HI, but adjust for low 16 bits.  */
1595   HOWTO (R_PPC64_TPREL16_HA,
1596          16,                    /* rightshift */
1597          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1598          16,                    /* bitsize */
1599          FALSE,                 /* pc_relative */
1600          0,                     /* bitpos */
1601          complain_overflow_signed, /* complain_on_overflow */
1602          ppc64_elf_unhandled_reloc, /* special_function */
1603          "R_PPC64_TPREL16_HA",  /* name */
1604          FALSE,                 /* partial_inplace */
1605          0,                     /* src_mask */
1606          0xffff,                /* dst_mask */
1607          FALSE),                /* pcrel_offset */
1608
1609   /* Like TPREL16_HI, but next higher group of 16 bits.  */
1610   HOWTO (R_PPC64_TPREL16_HIGHER,
1611          32,                    /* rightshift */
1612          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1613          16,                    /* bitsize */
1614          FALSE,                 /* pc_relative */
1615          0,                     /* bitpos */
1616          complain_overflow_dont, /* complain_on_overflow */
1617          ppc64_elf_unhandled_reloc, /* special_function */
1618          "R_PPC64_TPREL16_HIGHER",      /* name */
1619          FALSE,                 /* partial_inplace */
1620          0,                     /* src_mask */
1621          0xffff,                /* dst_mask */
1622          FALSE),                /* pcrel_offset */
1623
1624   /* Like TPREL16_HIGHER, but adjust for low 16 bits.  */
1625   HOWTO (R_PPC64_TPREL16_HIGHERA,
1626          32,                    /* rightshift */
1627          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1628          16,                    /* bitsize */
1629          FALSE,                 /* pc_relative */
1630          0,                     /* bitpos */
1631          complain_overflow_dont, /* complain_on_overflow */
1632          ppc64_elf_unhandled_reloc, /* special_function */
1633          "R_PPC64_TPREL16_HIGHERA", /* name */
1634          FALSE,                 /* partial_inplace */
1635          0,                     /* src_mask */
1636          0xffff,                /* dst_mask */
1637          FALSE),                /* pcrel_offset */
1638
1639   /* Like TPREL16_HIGHER, but next higher group of 16 bits.  */
1640   HOWTO (R_PPC64_TPREL16_HIGHEST,
1641          48,                    /* rightshift */
1642          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1643          16,                    /* bitsize */
1644          FALSE,                 /* pc_relative */
1645          0,                     /* bitpos */
1646          complain_overflow_dont, /* complain_on_overflow */
1647          ppc64_elf_unhandled_reloc, /* special_function */
1648          "R_PPC64_TPREL16_HIGHEST", /* name */
1649          FALSE,                 /* partial_inplace */
1650          0,                     /* src_mask */
1651          0xffff,                /* dst_mask */
1652          FALSE),                /* pcrel_offset */
1653
1654   /* Like TPREL16_HIGHEST, but adjust for low 16 bits.  */
1655   HOWTO (R_PPC64_TPREL16_HIGHESTA,
1656          48,                    /* rightshift */
1657          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1658          16,                    /* bitsize */
1659          FALSE,                 /* pc_relative */
1660          0,                     /* bitpos */
1661          complain_overflow_dont, /* complain_on_overflow */
1662          ppc64_elf_unhandled_reloc, /* special_function */
1663          "R_PPC64_TPREL16_HIGHESTA", /* name */
1664          FALSE,                 /* partial_inplace */
1665          0,                     /* src_mask */
1666          0xffff,                /* dst_mask */
1667          FALSE),                /* pcrel_offset */
1668
1669   /* Like TPREL16, but for insns with a DS field.  */
1670   HOWTO (R_PPC64_TPREL16_DS,
1671          0,                     /* rightshift */
1672          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1673          16,                    /* bitsize */
1674          FALSE,                 /* pc_relative */
1675          0,                     /* bitpos */
1676          complain_overflow_signed, /* complain_on_overflow */
1677          ppc64_elf_unhandled_reloc, /* special_function */
1678          "R_PPC64_TPREL16_DS",  /* name */
1679          FALSE,                 /* partial_inplace */
1680          0,                     /* src_mask */
1681          0xfffc,                /* dst_mask */
1682          FALSE),                /* pcrel_offset */
1683
1684   /* Like TPREL16_DS, but no overflow.  */
1685   HOWTO (R_PPC64_TPREL16_LO_DS,
1686          0,                     /* rightshift */
1687          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1688          16,                    /* bitsize */
1689          FALSE,                 /* pc_relative */
1690          0,                     /* bitpos */
1691          complain_overflow_dont, /* complain_on_overflow */
1692          ppc64_elf_unhandled_reloc, /* special_function */
1693          "R_PPC64_TPREL16_LO_DS", /* name */
1694          FALSE,                 /* partial_inplace */
1695          0,                     /* src_mask */
1696          0xfffc,                /* dst_mask */
1697          FALSE),                /* pcrel_offset */
1698
1699   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1700      with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1701      to the first entry relative to the TOC base (r2).  */
1702   HOWTO (R_PPC64_GOT_TLSGD16,
1703          0,                     /* rightshift */
1704          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1705          16,                    /* bitsize */
1706          FALSE,                 /* pc_relative */
1707          0,                     /* bitpos */
1708          complain_overflow_signed, /* complain_on_overflow */
1709          ppc64_elf_unhandled_reloc, /* special_function */
1710          "R_PPC64_GOT_TLSGD16", /* name */
1711          FALSE,                 /* partial_inplace */
1712          0,                     /* src_mask */
1713          0xffff,                /* dst_mask */
1714          FALSE),                /* pcrel_offset */
1715
1716   /* Like GOT_TLSGD16, but no overflow.  */
1717   HOWTO (R_PPC64_GOT_TLSGD16_LO,
1718          0,                     /* rightshift */
1719          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1720          16,                    /* bitsize */
1721          FALSE,                 /* pc_relative */
1722          0,                     /* bitpos */
1723          complain_overflow_dont, /* complain_on_overflow */
1724          ppc64_elf_unhandled_reloc, /* special_function */
1725          "R_PPC64_GOT_TLSGD16_LO", /* name */
1726          FALSE,                 /* partial_inplace */
1727          0,                     /* src_mask */
1728          0xffff,                /* dst_mask */
1729          FALSE),                /* pcrel_offset */
1730
1731   /* Like GOT_TLSGD16_LO, but next higher group of 16 bits.  */
1732   HOWTO (R_PPC64_GOT_TLSGD16_HI,
1733          16,                    /* rightshift */
1734          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1735          16,                    /* bitsize */
1736          FALSE,                 /* pc_relative */
1737          0,                     /* bitpos */
1738          complain_overflow_signed, /* complain_on_overflow */
1739          ppc64_elf_unhandled_reloc, /* special_function */
1740          "R_PPC64_GOT_TLSGD16_HI", /* name */
1741          FALSE,                 /* partial_inplace */
1742          0,                     /* src_mask */
1743          0xffff,                /* dst_mask */
1744          FALSE),                /* pcrel_offset */
1745
1746   /* Like GOT_TLSGD16_HI, but adjust for low 16 bits.  */
1747   HOWTO (R_PPC64_GOT_TLSGD16_HA,
1748          16,                    /* rightshift */
1749          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1750          16,                    /* bitsize */
1751          FALSE,                 /* pc_relative */
1752          0,                     /* bitpos */
1753          complain_overflow_signed, /* complain_on_overflow */
1754          ppc64_elf_unhandled_reloc, /* special_function */
1755          "R_PPC64_GOT_TLSGD16_HA", /* name */
1756          FALSE,                 /* partial_inplace */
1757          0,                     /* src_mask */
1758          0xffff,                /* dst_mask */
1759          FALSE),                /* pcrel_offset */
1760
1761   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1762      with values (sym+add)@dtpmod and zero, and computes the offset to the
1763      first entry relative to the TOC base (r2).  */
1764   HOWTO (R_PPC64_GOT_TLSLD16,
1765          0,                     /* rightshift */
1766          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1767          16,                    /* bitsize */
1768          FALSE,                 /* pc_relative */
1769          0,                     /* bitpos */
1770          complain_overflow_signed, /* complain_on_overflow */
1771          ppc64_elf_unhandled_reloc, /* special_function */
1772          "R_PPC64_GOT_TLSLD16", /* name */
1773          FALSE,                 /* partial_inplace */
1774          0,                     /* src_mask */
1775          0xffff,                /* dst_mask */
1776          FALSE),                /* pcrel_offset */
1777
1778   /* Like GOT_TLSLD16, but no overflow.  */
1779   HOWTO (R_PPC64_GOT_TLSLD16_LO,
1780          0,                     /* rightshift */
1781          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1782          16,                    /* bitsize */
1783          FALSE,                 /* pc_relative */
1784          0,                     /* bitpos */
1785          complain_overflow_dont, /* complain_on_overflow */
1786          ppc64_elf_unhandled_reloc, /* special_function */
1787          "R_PPC64_GOT_TLSLD16_LO", /* name */
1788          FALSE,                 /* partial_inplace */
1789          0,                     /* src_mask */
1790          0xffff,                /* dst_mask */
1791          FALSE),                /* pcrel_offset */
1792
1793   /* Like GOT_TLSLD16_LO, but next higher group of 16 bits.  */
1794   HOWTO (R_PPC64_GOT_TLSLD16_HI,
1795          16,                    /* rightshift */
1796          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1797          16,                    /* bitsize */
1798          FALSE,                 /* pc_relative */
1799          0,                     /* bitpos */
1800          complain_overflow_signed, /* complain_on_overflow */
1801          ppc64_elf_unhandled_reloc, /* special_function */
1802          "R_PPC64_GOT_TLSLD16_HI", /* name */
1803          FALSE,                 /* partial_inplace */
1804          0,                     /* src_mask */
1805          0xffff,                /* dst_mask */
1806          FALSE),                /* pcrel_offset */
1807
1808   /* Like GOT_TLSLD16_HI, but adjust for low 16 bits.  */
1809   HOWTO (R_PPC64_GOT_TLSLD16_HA,
1810          16,                    /* rightshift */
1811          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1812          16,                    /* bitsize */
1813          FALSE,                 /* pc_relative */
1814          0,                     /* bitpos */
1815          complain_overflow_signed, /* complain_on_overflow */
1816          ppc64_elf_unhandled_reloc, /* special_function */
1817          "R_PPC64_GOT_TLSLD16_HA", /* name */
1818          FALSE,                 /* partial_inplace */
1819          0,                     /* src_mask */
1820          0xffff,                /* dst_mask */
1821          FALSE),                /* pcrel_offset */
1822
1823   /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1824      the offset to the entry relative to the TOC base (r2).  */
1825   HOWTO (R_PPC64_GOT_DTPREL16_DS,
1826          0,                     /* rightshift */
1827          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1828          16,                    /* bitsize */
1829          FALSE,                 /* pc_relative */
1830          0,                     /* bitpos */
1831          complain_overflow_signed, /* complain_on_overflow */
1832          ppc64_elf_unhandled_reloc, /* special_function */
1833          "R_PPC64_GOT_DTPREL16_DS", /* name */
1834          FALSE,                 /* partial_inplace */
1835          0,                     /* src_mask */
1836          0xfffc,                /* dst_mask */
1837          FALSE),                /* pcrel_offset */
1838
1839   /* Like GOT_DTPREL16_DS, but no overflow.  */
1840   HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1841          0,                     /* rightshift */
1842          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1843          16,                    /* bitsize */
1844          FALSE,                 /* pc_relative */
1845          0,                     /* bitpos */
1846          complain_overflow_dont, /* complain_on_overflow */
1847          ppc64_elf_unhandled_reloc, /* special_function */
1848          "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1849          FALSE,                 /* partial_inplace */
1850          0,                     /* src_mask */
1851          0xfffc,                /* dst_mask */
1852          FALSE),                /* pcrel_offset */
1853
1854   /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits.  */
1855   HOWTO (R_PPC64_GOT_DTPREL16_HI,
1856          16,                    /* rightshift */
1857          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1858          16,                    /* bitsize */
1859          FALSE,                 /* pc_relative */
1860          0,                     /* bitpos */
1861          complain_overflow_signed, /* complain_on_overflow */
1862          ppc64_elf_unhandled_reloc, /* special_function */
1863          "R_PPC64_GOT_DTPREL16_HI", /* name */
1864          FALSE,                 /* partial_inplace */
1865          0,                     /* src_mask */
1866          0xffff,                /* dst_mask */
1867          FALSE),                /* pcrel_offset */
1868
1869   /* Like GOT_DTPREL16_HI, but adjust for low 16 bits.  */
1870   HOWTO (R_PPC64_GOT_DTPREL16_HA,
1871          16,                    /* rightshift */
1872          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1873          16,                    /* bitsize */
1874          FALSE,                 /* pc_relative */
1875          0,                     /* bitpos */
1876          complain_overflow_signed, /* complain_on_overflow */
1877          ppc64_elf_unhandled_reloc, /* special_function */
1878          "R_PPC64_GOT_DTPREL16_HA", /* name */
1879          FALSE,                 /* partial_inplace */
1880          0,                     /* src_mask */
1881          0xffff,                /* dst_mask */
1882          FALSE),                /* pcrel_offset */
1883
1884   /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1885      offset to the entry relative to the TOC base (r2).  */
1886   HOWTO (R_PPC64_GOT_TPREL16_DS,
1887          0,                     /* rightshift */
1888          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1889          16,                    /* bitsize */
1890          FALSE,                 /* pc_relative */
1891          0,                     /* bitpos */
1892          complain_overflow_signed, /* complain_on_overflow */
1893          ppc64_elf_unhandled_reloc, /* special_function */
1894          "R_PPC64_GOT_TPREL16_DS", /* name */
1895          FALSE,                 /* partial_inplace */
1896          0,                     /* src_mask */
1897          0xfffc,                /* dst_mask */
1898          FALSE),                /* pcrel_offset */
1899
1900   /* Like GOT_TPREL16_DS, but no overflow.  */
1901   HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1902          0,                     /* rightshift */
1903          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1904          16,                    /* bitsize */
1905          FALSE,                 /* pc_relative */
1906          0,                     /* bitpos */
1907          complain_overflow_dont, /* complain_on_overflow */
1908          ppc64_elf_unhandled_reloc, /* special_function */
1909          "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1910          FALSE,                 /* partial_inplace */
1911          0,                     /* src_mask */
1912          0xfffc,                /* dst_mask */
1913          FALSE),                /* pcrel_offset */
1914
1915   /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits.  */
1916   HOWTO (R_PPC64_GOT_TPREL16_HI,
1917          16,                    /* rightshift */
1918          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1919          16,                    /* bitsize */
1920          FALSE,                 /* pc_relative */
1921          0,                     /* bitpos */
1922          complain_overflow_signed, /* complain_on_overflow */
1923          ppc64_elf_unhandled_reloc, /* special_function */
1924          "R_PPC64_GOT_TPREL16_HI", /* name */
1925          FALSE,                 /* partial_inplace */
1926          0,                     /* src_mask */
1927          0xffff,                /* dst_mask */
1928          FALSE),                /* pcrel_offset */
1929
1930   /* Like GOT_TPREL16_HI, but adjust for low 16 bits.  */
1931   HOWTO (R_PPC64_GOT_TPREL16_HA,
1932          16,                    /* rightshift */
1933          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1934          16,                    /* bitsize */
1935          FALSE,                 /* pc_relative */
1936          0,                     /* bitpos */
1937          complain_overflow_signed, /* complain_on_overflow */
1938          ppc64_elf_unhandled_reloc, /* special_function */
1939          "R_PPC64_GOT_TPREL16_HA", /* name */
1940          FALSE,                 /* partial_inplace */
1941          0,                     /* src_mask */
1942          0xffff,                /* dst_mask */
1943          FALSE),                /* pcrel_offset */
1944
1945   HOWTO (R_PPC64_JMP_IREL,      /* type */
1946          0,                     /* rightshift */
1947          0,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1948          0,                     /* bitsize */
1949          FALSE,                 /* pc_relative */
1950          0,                     /* bitpos */
1951          complain_overflow_dont, /* complain_on_overflow */
1952          ppc64_elf_unhandled_reloc, /* special_function */
1953          "R_PPC64_JMP_IREL",    /* name */
1954          FALSE,                 /* partial_inplace */
1955          0,                     /* src_mask */
1956          0,                     /* dst_mask */
1957          FALSE),                /* pcrel_offset */
1958
1959   HOWTO (R_PPC64_IRELATIVE,     /* type */
1960          0,                     /* rightshift */
1961          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1962          64,                    /* bitsize */
1963          FALSE,                 /* pc_relative */
1964          0,                     /* bitpos */
1965          complain_overflow_dont, /* complain_on_overflow */
1966          bfd_elf_generic_reloc, /* special_function */
1967          "R_PPC64_IRELATIVE",   /* name */
1968          FALSE,                 /* partial_inplace */
1969          0,                     /* src_mask */
1970          ONES (64),             /* dst_mask */
1971          FALSE),                /* pcrel_offset */
1972
1973   /* A 16 bit relative relocation.  */
1974   HOWTO (R_PPC64_REL16,         /* type */
1975          0,                     /* rightshift */
1976          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1977          16,                    /* bitsize */
1978          TRUE,                  /* pc_relative */
1979          0,                     /* bitpos */
1980          complain_overflow_signed, /* complain_on_overflow */
1981          bfd_elf_generic_reloc, /* special_function */
1982          "R_PPC64_REL16",       /* name */
1983          FALSE,                 /* partial_inplace */
1984          0,                     /* src_mask */
1985          0xffff,                /* dst_mask */
1986          TRUE),                 /* pcrel_offset */
1987
1988   /* A 16 bit relative relocation without overflow.  */
1989   HOWTO (R_PPC64_REL16_LO,      /* type */
1990          0,                     /* rightshift */
1991          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1992          16,                    /* bitsize */
1993          TRUE,                  /* pc_relative */
1994          0,                     /* bitpos */
1995          complain_overflow_dont,/* complain_on_overflow */
1996          bfd_elf_generic_reloc, /* special_function */
1997          "R_PPC64_REL16_LO",    /* name */
1998          FALSE,                 /* partial_inplace */
1999          0,                     /* src_mask */
2000          0xffff,                /* dst_mask */
2001          TRUE),                 /* pcrel_offset */
2002
2003   /* The high order 16 bits of a relative address.  */
2004   HOWTO (R_PPC64_REL16_HI,      /* type */
2005          16,                    /* rightshift */
2006          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2007          16,                    /* bitsize */
2008          TRUE,                  /* pc_relative */
2009          0,                     /* bitpos */
2010          complain_overflow_signed, /* complain_on_overflow */
2011          bfd_elf_generic_reloc, /* special_function */
2012          "R_PPC64_REL16_HI",    /* name */
2013          FALSE,                 /* partial_inplace */
2014          0,                     /* src_mask */
2015          0xffff,                /* dst_mask */
2016          TRUE),                 /* pcrel_offset */
2017
2018   /* The high order 16 bits of a relative address, plus 1 if the contents of
2019      the low 16 bits, treated as a signed number, is negative.  */
2020   HOWTO (R_PPC64_REL16_HA,      /* type */
2021          16,                    /* rightshift */
2022          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2023          16,                    /* bitsize */
2024          TRUE,                  /* pc_relative */
2025          0,                     /* bitpos */
2026          complain_overflow_signed, /* complain_on_overflow */
2027          ppc64_elf_ha_reloc,    /* special_function */
2028          "R_PPC64_REL16_HA",    /* name */
2029          FALSE,                 /* partial_inplace */
2030          0,                     /* src_mask */
2031          0xffff,                /* dst_mask */
2032          TRUE),                 /* pcrel_offset */
2033
2034   /* Like R_PPC64_REL16_HA but for split field in addpcis.  */
2035   HOWTO (R_PPC64_REL16DX_HA,    /* type */
2036          16,                    /* rightshift */
2037          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2038          16,                    /* bitsize */
2039          TRUE,                  /* pc_relative */
2040          0,                     /* bitpos */
2041          complain_overflow_signed, /* complain_on_overflow */
2042          ppc64_elf_ha_reloc,    /* special_function */
2043          "R_PPC64_REL16DX_HA",  /* name */
2044          FALSE,                 /* partial_inplace */
2045          0,                     /* src_mask */
2046          0x1fffc1,              /* dst_mask */
2047          TRUE),                 /* pcrel_offset */
2048
2049   /* A split-field reloc for addpcis, non-relative (gas internal use only).  */
2050   HOWTO (R_PPC64_16DX_HA,       /* type */
2051          16,                    /* rightshift */
2052          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2053          16,                    /* bitsize */
2054          FALSE,                 /* pc_relative */
2055          0,                     /* bitpos */
2056          complain_overflow_signed, /* complain_on_overflow */
2057          ppc64_elf_ha_reloc,    /* special_function */
2058          "R_PPC64_16DX_HA",     /* name */
2059          FALSE,                 /* partial_inplace */
2060          0,                     /* src_mask */
2061          0x1fffc1,              /* dst_mask */
2062          FALSE),                /* pcrel_offset */
2063
2064   /* Like R_PPC64_ADDR16_HI, but no overflow.  */
2065   HOWTO (R_PPC64_ADDR16_HIGH,   /* type */
2066          16,                    /* rightshift */
2067          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2068          16,                    /* bitsize */
2069          FALSE,                 /* pc_relative */
2070          0,                     /* bitpos */
2071          complain_overflow_dont, /* complain_on_overflow */
2072          bfd_elf_generic_reloc, /* special_function */
2073          "R_PPC64_ADDR16_HIGH", /* name */
2074          FALSE,                 /* partial_inplace */
2075          0,                     /* src_mask */
2076          0xffff,                /* dst_mask */
2077          FALSE),                /* pcrel_offset */
2078
2079   /* Like R_PPC64_ADDR16_HA, but no overflow.  */
2080   HOWTO (R_PPC64_ADDR16_HIGHA,  /* type */
2081          16,                    /* rightshift */
2082          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2083          16,                    /* bitsize */
2084          FALSE,                 /* pc_relative */
2085          0,                     /* bitpos */
2086          complain_overflow_dont, /* complain_on_overflow */
2087          ppc64_elf_ha_reloc,    /* special_function */
2088          "R_PPC64_ADDR16_HIGHA",        /* name */
2089          FALSE,                 /* partial_inplace */
2090          0,                     /* src_mask */
2091          0xffff,                /* dst_mask */
2092          FALSE),                /* pcrel_offset */
2093
2094   /* Like R_PPC64_DTPREL16_HI, but no overflow.  */
2095   HOWTO (R_PPC64_DTPREL16_HIGH,
2096          16,                    /* rightshift */
2097          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2098          16,                    /* bitsize */
2099          FALSE,                 /* pc_relative */
2100          0,                     /* bitpos */
2101          complain_overflow_dont, /* complain_on_overflow */
2102          ppc64_elf_unhandled_reloc, /* special_function */
2103          "R_PPC64_DTPREL16_HIGH", /* name */
2104          FALSE,                 /* partial_inplace */
2105          0,                     /* src_mask */
2106          0xffff,                /* dst_mask */
2107          FALSE),                /* pcrel_offset */
2108
2109   /* Like R_PPC64_DTPREL16_HA, but no overflow.  */
2110   HOWTO (R_PPC64_DTPREL16_HIGHA,
2111          16,                    /* rightshift */
2112          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2113          16,                    /* bitsize */
2114          FALSE,                 /* pc_relative */
2115          0,                     /* bitpos */
2116          complain_overflow_dont, /* complain_on_overflow */
2117          ppc64_elf_unhandled_reloc, /* special_function */
2118          "R_PPC64_DTPREL16_HIGHA", /* name */
2119          FALSE,                 /* partial_inplace */
2120          0,                     /* src_mask */
2121          0xffff,                /* dst_mask */
2122          FALSE),                /* pcrel_offset */
2123
2124   /* Like R_PPC64_TPREL16_HI, but no overflow.  */
2125   HOWTO (R_PPC64_TPREL16_HIGH,
2126          16,                    /* rightshift */
2127          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2128          16,                    /* bitsize */
2129          FALSE,                 /* pc_relative */
2130          0,                     /* bitpos */
2131          complain_overflow_dont, /* complain_on_overflow */
2132          ppc64_elf_unhandled_reloc, /* special_function */
2133          "R_PPC64_TPREL16_HIGH",        /* name */
2134          FALSE,                 /* partial_inplace */
2135          0,                     /* src_mask */
2136          0xffff,                /* dst_mask */
2137          FALSE),                /* pcrel_offset */
2138
2139   /* Like R_PPC64_TPREL16_HA, but no overflow.  */
2140   HOWTO (R_PPC64_TPREL16_HIGHA,
2141          16,                    /* rightshift */
2142          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2143          16,                    /* bitsize */
2144          FALSE,                 /* pc_relative */
2145          0,                     /* bitpos */
2146          complain_overflow_dont, /* complain_on_overflow */
2147          ppc64_elf_unhandled_reloc, /* special_function */
2148          "R_PPC64_TPREL16_HIGHA",       /* name */
2149          FALSE,                 /* partial_inplace */
2150          0,                     /* src_mask */
2151          0xffff,                /* dst_mask */
2152          FALSE),                /* pcrel_offset */
2153
2154   /* Marker reloc on ELFv2 large-model function entry.  */
2155   HOWTO (R_PPC64_ENTRY,
2156          0,                     /* rightshift */
2157          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2158          32,                    /* bitsize */
2159          FALSE,                 /* pc_relative */
2160          0,                     /* bitpos */
2161          complain_overflow_dont, /* complain_on_overflow */
2162          bfd_elf_generic_reloc, /* special_function */
2163          "R_PPC64_ENTRY",       /* name */
2164          FALSE,                 /* partial_inplace */
2165          0,                     /* src_mask */
2166          0,                     /* dst_mask */
2167          FALSE),                /* pcrel_offset */
2168
2169   /* Like ADDR64, but use local entry point of function.  */
2170   HOWTO (R_PPC64_ADDR64_LOCAL,  /* type */
2171          0,                     /* rightshift */
2172          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2173          64,                    /* bitsize */
2174          FALSE,                 /* pc_relative */
2175          0,                     /* bitpos */
2176          complain_overflow_dont, /* complain_on_overflow */
2177          bfd_elf_generic_reloc, /* special_function */
2178          "R_PPC64_ADDR64_LOCAL", /* name */
2179          FALSE,                 /* partial_inplace */
2180          0,                     /* src_mask */
2181          ONES (64),             /* dst_mask */
2182          FALSE),                /* pcrel_offset */
2183
2184   /* GNU extension to record C++ vtable hierarchy.  */
2185   HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2186          0,                     /* rightshift */
2187          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2188          0,                     /* bitsize */
2189          FALSE,                 /* pc_relative */
2190          0,                     /* bitpos */
2191          complain_overflow_dont, /* complain_on_overflow */
2192          NULL,                  /* special_function */
2193          "R_PPC64_GNU_VTINHERIT", /* name */
2194          FALSE,                 /* partial_inplace */
2195          0,                     /* src_mask */
2196          0,                     /* dst_mask */
2197          FALSE),                /* pcrel_offset */
2198
2199   /* GNU extension to record C++ vtable member usage.  */
2200   HOWTO (R_PPC64_GNU_VTENTRY,   /* type */
2201          0,                     /* rightshift */
2202          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2203          0,                     /* bitsize */
2204          FALSE,                 /* pc_relative */
2205          0,                     /* bitpos */
2206          complain_overflow_dont, /* complain_on_overflow */
2207          NULL,                  /* special_function */
2208          "R_PPC64_GNU_VTENTRY", /* name */
2209          FALSE,                 /* partial_inplace */
2210          0,                     /* src_mask */
2211          0,                     /* dst_mask */
2212          FALSE),                /* pcrel_offset */
2213 };
2214
2215 \f
2216 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2217    be done.  */
2218
2219 static void
2220 ppc_howto_init (void)
2221 {
2222   unsigned int i, type;
2223
2224   for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2225     {
2226       type = ppc64_elf_howto_raw[i].type;
2227       BFD_ASSERT (type < ARRAY_SIZE (ppc64_elf_howto_table));
2228       ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2229     }
2230 }
2231
2232 static reloc_howto_type *
2233 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2234                              bfd_reloc_code_real_type code)
2235 {
2236   enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2237
2238   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2239     /* Initialize howto table if needed.  */
2240     ppc_howto_init ();
2241
2242   switch (code)
2243     {
2244     default:
2245       return NULL;
2246
2247     case BFD_RELOC_NONE:                        r = R_PPC64_NONE;
2248       break;
2249     case BFD_RELOC_32:                          r = R_PPC64_ADDR32;
2250       break;
2251     case BFD_RELOC_PPC_BA26:                    r = R_PPC64_ADDR24;
2252       break;
2253     case BFD_RELOC_16:                          r = R_PPC64_ADDR16;
2254       break;
2255     case BFD_RELOC_LO16:                        r = R_PPC64_ADDR16_LO;
2256       break;
2257     case BFD_RELOC_HI16:                        r = R_PPC64_ADDR16_HI;
2258       break;
2259     case BFD_RELOC_PPC64_ADDR16_HIGH:           r = R_PPC64_ADDR16_HIGH;
2260       break;
2261     case BFD_RELOC_HI16_S:                      r = R_PPC64_ADDR16_HA;
2262       break;
2263     case BFD_RELOC_PPC64_ADDR16_HIGHA:          r = R_PPC64_ADDR16_HIGHA;
2264       break;
2265     case BFD_RELOC_PPC_BA16:                    r = R_PPC64_ADDR14;
2266       break;
2267     case BFD_RELOC_PPC_BA16_BRTAKEN:            r = R_PPC64_ADDR14_BRTAKEN;
2268       break;
2269     case BFD_RELOC_PPC_BA16_BRNTAKEN:           r = R_PPC64_ADDR14_BRNTAKEN;
2270       break;
2271     case BFD_RELOC_PPC_B26:                     r = R_PPC64_REL24;
2272       break;
2273     case BFD_RELOC_PPC_B16:                     r = R_PPC64_REL14;
2274       break;
2275     case BFD_RELOC_PPC_B16_BRTAKEN:             r = R_PPC64_REL14_BRTAKEN;
2276       break;
2277     case BFD_RELOC_PPC_B16_BRNTAKEN:            r = R_PPC64_REL14_BRNTAKEN;
2278       break;
2279     case BFD_RELOC_16_GOTOFF:                   r = R_PPC64_GOT16;
2280       break;
2281     case BFD_RELOC_LO16_GOTOFF:                 r = R_PPC64_GOT16_LO;
2282       break;
2283     case BFD_RELOC_HI16_GOTOFF:                 r = R_PPC64_GOT16_HI;
2284       break;
2285     case BFD_RELOC_HI16_S_GOTOFF:               r = R_PPC64_GOT16_HA;
2286       break;
2287     case BFD_RELOC_PPC_COPY:                    r = R_PPC64_COPY;
2288       break;
2289     case BFD_RELOC_PPC_GLOB_DAT:                r = R_PPC64_GLOB_DAT;
2290       break;
2291     case BFD_RELOC_32_PCREL:                    r = R_PPC64_REL32;
2292       break;
2293     case BFD_RELOC_32_PLTOFF:                   r = R_PPC64_PLT32;
2294       break;
2295     case BFD_RELOC_32_PLT_PCREL:                r = R_PPC64_PLTREL32;
2296       break;
2297     case BFD_RELOC_LO16_PLTOFF:                 r = R_PPC64_PLT16_LO;
2298       break;
2299     case BFD_RELOC_HI16_PLTOFF:                 r = R_PPC64_PLT16_HI;
2300       break;
2301     case BFD_RELOC_HI16_S_PLTOFF:               r = R_PPC64_PLT16_HA;
2302       break;
2303     case BFD_RELOC_16_BASEREL:                  r = R_PPC64_SECTOFF;
2304       break;
2305     case BFD_RELOC_LO16_BASEREL:                r = R_PPC64_SECTOFF_LO;
2306       break;
2307     case BFD_RELOC_HI16_BASEREL:                r = R_PPC64_SECTOFF_HI;
2308       break;
2309     case BFD_RELOC_HI16_S_BASEREL:              r = R_PPC64_SECTOFF_HA;
2310       break;
2311     case BFD_RELOC_CTOR:                        r = R_PPC64_ADDR64;
2312       break;
2313     case BFD_RELOC_64:                          r = R_PPC64_ADDR64;
2314       break;
2315     case BFD_RELOC_PPC64_HIGHER:                r = R_PPC64_ADDR16_HIGHER;
2316       break;
2317     case BFD_RELOC_PPC64_HIGHER_S:              r = R_PPC64_ADDR16_HIGHERA;
2318       break;
2319     case BFD_RELOC_PPC64_HIGHEST:               r = R_PPC64_ADDR16_HIGHEST;
2320       break;
2321     case BFD_RELOC_PPC64_HIGHEST_S:             r = R_PPC64_ADDR16_HIGHESTA;
2322       break;
2323     case BFD_RELOC_64_PCREL:                    r = R_PPC64_REL64;
2324       break;
2325     case BFD_RELOC_64_PLTOFF:                   r = R_PPC64_PLT64;
2326       break;
2327     case BFD_RELOC_64_PLT_PCREL:                r = R_PPC64_PLTREL64;
2328       break;
2329     case BFD_RELOC_PPC_TOC16:                   r = R_PPC64_TOC16;
2330       break;
2331     case BFD_RELOC_PPC64_TOC16_LO:              r = R_PPC64_TOC16_LO;
2332       break;
2333     case BFD_RELOC_PPC64_TOC16_HI:              r = R_PPC64_TOC16_HI;
2334       break;
2335     case BFD_RELOC_PPC64_TOC16_HA:              r = R_PPC64_TOC16_HA;
2336       break;
2337     case BFD_RELOC_PPC64_TOC:                   r = R_PPC64_TOC;
2338       break;
2339     case BFD_RELOC_PPC64_PLTGOT16:              r = R_PPC64_PLTGOT16;
2340       break;
2341     case BFD_RELOC_PPC64_PLTGOT16_LO:           r = R_PPC64_PLTGOT16_LO;
2342       break;
2343     case BFD_RELOC_PPC64_PLTGOT16_HI:           r = R_PPC64_PLTGOT16_HI;
2344       break;
2345     case BFD_RELOC_PPC64_PLTGOT16_HA:           r = R_PPC64_PLTGOT16_HA;
2346       break;
2347     case BFD_RELOC_PPC64_ADDR16_DS:             r = R_PPC64_ADDR16_DS;
2348       break;
2349     case BFD_RELOC_PPC64_ADDR16_LO_DS:          r = R_PPC64_ADDR16_LO_DS;
2350       break;
2351     case BFD_RELOC_PPC64_GOT16_DS:              r = R_PPC64_GOT16_DS;
2352       break;
2353     case BFD_RELOC_PPC64_GOT16_LO_DS:           r = R_PPC64_GOT16_LO_DS;
2354       break;
2355     case BFD_RELOC_PPC64_PLT16_LO_DS:           r = R_PPC64_PLT16_LO_DS;
2356       break;
2357     case BFD_RELOC_PPC64_SECTOFF_DS:            r = R_PPC64_SECTOFF_DS;
2358       break;
2359     case BFD_RELOC_PPC64_SECTOFF_LO_DS:         r = R_PPC64_SECTOFF_LO_DS;
2360       break;
2361     case BFD_RELOC_PPC64_TOC16_DS:              r = R_PPC64_TOC16_DS;
2362       break;
2363     case BFD_RELOC_PPC64_TOC16_LO_DS:           r = R_PPC64_TOC16_LO_DS;
2364       break;
2365     case BFD_RELOC_PPC64_PLTGOT16_DS:           r = R_PPC64_PLTGOT16_DS;
2366       break;
2367     case BFD_RELOC_PPC64_PLTGOT16_LO_DS:        r = R_PPC64_PLTGOT16_LO_DS;
2368       break;
2369     case BFD_RELOC_PPC_TLS:                     r = R_PPC64_TLS;
2370       break;
2371     case BFD_RELOC_PPC_TLSGD:                   r = R_PPC64_TLSGD;
2372       break;
2373     case BFD_RELOC_PPC_TLSLD:                   r = R_PPC64_TLSLD;
2374       break;
2375     case BFD_RELOC_PPC_DTPMOD:                  r = R_PPC64_DTPMOD64;
2376       break;
2377     case BFD_RELOC_PPC_TPREL16:                 r = R_PPC64_TPREL16;
2378       break;
2379     case BFD_RELOC_PPC_TPREL16_LO:              r = R_PPC64_TPREL16_LO;
2380       break;
2381     case BFD_RELOC_PPC_TPREL16_HI:              r = R_PPC64_TPREL16_HI;
2382       break;
2383     case BFD_RELOC_PPC64_TPREL16_HIGH:          r = R_PPC64_TPREL16_HIGH;
2384       break;
2385     case BFD_RELOC_PPC_TPREL16_HA:              r = R_PPC64_TPREL16_HA;
2386       break;
2387     case BFD_RELOC_PPC64_TPREL16_HIGHA:         r = R_PPC64_TPREL16_HIGHA;
2388       break;
2389     case BFD_RELOC_PPC_TPREL:                   r = R_PPC64_TPREL64;
2390       break;
2391     case BFD_RELOC_PPC_DTPREL16:                r = R_PPC64_DTPREL16;
2392       break;
2393     case BFD_RELOC_PPC_DTPREL16_LO:             r = R_PPC64_DTPREL16_LO;
2394       break;
2395     case BFD_RELOC_PPC_DTPREL16_HI:             r = R_PPC64_DTPREL16_HI;
2396       break;
2397     case BFD_RELOC_PPC64_DTPREL16_HIGH:         r = R_PPC64_DTPREL16_HIGH;
2398       break;
2399     case BFD_RELOC_PPC_DTPREL16_HA:             r = R_PPC64_DTPREL16_HA;
2400       break;
2401     case BFD_RELOC_PPC64_DTPREL16_HIGHA:        r = R_PPC64_DTPREL16_HIGHA;
2402       break;
2403     case BFD_RELOC_PPC_DTPREL:                  r = R_PPC64_DTPREL64;
2404       break;
2405     case BFD_RELOC_PPC_GOT_TLSGD16:             r = R_PPC64_GOT_TLSGD16;
2406       break;
2407     case BFD_RELOC_PPC_GOT_TLSGD16_LO:          r = R_PPC64_GOT_TLSGD16_LO;
2408       break;
2409     case BFD_RELOC_PPC_GOT_TLSGD16_HI:          r = R_PPC64_GOT_TLSGD16_HI;
2410       break;
2411     case BFD_RELOC_PPC_GOT_TLSGD16_HA:          r = R_PPC64_GOT_TLSGD16_HA;
2412       break;
2413     case BFD_RELOC_PPC_GOT_TLSLD16:             r = R_PPC64_GOT_TLSLD16;
2414       break;
2415     case BFD_RELOC_PPC_GOT_TLSLD16_LO:          r = R_PPC64_GOT_TLSLD16_LO;
2416       break;
2417     case BFD_RELOC_PPC_GOT_TLSLD16_HI:          r = R_PPC64_GOT_TLSLD16_HI;
2418       break;
2419     case BFD_RELOC_PPC_GOT_TLSLD16_HA:          r = R_PPC64_GOT_TLSLD16_HA;
2420       break;
2421     case BFD_RELOC_PPC_GOT_TPREL16:             r = R_PPC64_GOT_TPREL16_DS;
2422       break;
2423     case BFD_RELOC_PPC_GOT_TPREL16_LO:          r = R_PPC64_GOT_TPREL16_LO_DS;
2424       break;
2425     case BFD_RELOC_PPC_GOT_TPREL16_HI:          r = R_PPC64_GOT_TPREL16_HI;
2426       break;
2427     case BFD_RELOC_PPC_GOT_TPREL16_HA:          r = R_PPC64_GOT_TPREL16_HA;
2428       break;
2429     case BFD_RELOC_PPC_GOT_DTPREL16:            r = R_PPC64_GOT_DTPREL16_DS;
2430       break;
2431     case BFD_RELOC_PPC_GOT_DTPREL16_LO:         r = R_PPC64_GOT_DTPREL16_LO_DS;
2432       break;
2433     case BFD_RELOC_PPC_GOT_DTPREL16_HI:         r = R_PPC64_GOT_DTPREL16_HI;
2434       break;
2435     case BFD_RELOC_PPC_GOT_DTPREL16_HA:         r = R_PPC64_GOT_DTPREL16_HA;
2436       break;
2437     case BFD_RELOC_PPC64_TPREL16_DS:            r = R_PPC64_TPREL16_DS;
2438       break;
2439     case BFD_RELOC_PPC64_TPREL16_LO_DS:         r = R_PPC64_TPREL16_LO_DS;
2440       break;
2441     case BFD_RELOC_PPC64_TPREL16_HIGHER:        r = R_PPC64_TPREL16_HIGHER;
2442       break;
2443     case BFD_RELOC_PPC64_TPREL16_HIGHERA:       r = R_PPC64_TPREL16_HIGHERA;
2444       break;
2445     case BFD_RELOC_PPC64_TPREL16_HIGHEST:       r = R_PPC64_TPREL16_HIGHEST;
2446       break;
2447     case BFD_RELOC_PPC64_TPREL16_HIGHESTA:      r = R_PPC64_TPREL16_HIGHESTA;
2448       break;
2449     case BFD_RELOC_PPC64_DTPREL16_DS:           r = R_PPC64_DTPREL16_DS;
2450       break;
2451     case BFD_RELOC_PPC64_DTPREL16_LO_DS:        r = R_PPC64_DTPREL16_LO_DS;
2452       break;
2453     case BFD_RELOC_PPC64_DTPREL16_HIGHER:       r = R_PPC64_DTPREL16_HIGHER;
2454       break;
2455     case BFD_RELOC_PPC64_DTPREL16_HIGHERA:      r = R_PPC64_DTPREL16_HIGHERA;
2456       break;
2457     case BFD_RELOC_PPC64_DTPREL16_HIGHEST:      r = R_PPC64_DTPREL16_HIGHEST;
2458       break;
2459     case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:     r = R_PPC64_DTPREL16_HIGHESTA;
2460       break;
2461     case BFD_RELOC_16_PCREL:                    r = R_PPC64_REL16;
2462       break;
2463     case BFD_RELOC_LO16_PCREL:                  r = R_PPC64_REL16_LO;
2464       break;
2465     case BFD_RELOC_HI16_PCREL:                  r = R_PPC64_REL16_HI;
2466       break;
2467     case BFD_RELOC_HI16_S_PCREL:                r = R_PPC64_REL16_HA;
2468       break;
2469     case BFD_RELOC_PPC_16DX_HA:                 r = R_PPC64_16DX_HA;
2470       break;
2471     case BFD_RELOC_PPC_REL16DX_HA:              r = R_PPC64_REL16DX_HA;
2472       break;
2473     case BFD_RELOC_PPC64_ENTRY:                 r = R_PPC64_ENTRY;
2474       break;
2475     case BFD_RELOC_PPC64_ADDR64_LOCAL:          r = R_PPC64_ADDR64_LOCAL;
2476       break;
2477     case BFD_RELOC_VTABLE_INHERIT:              r = R_PPC64_GNU_VTINHERIT;
2478       break;
2479     case BFD_RELOC_VTABLE_ENTRY:                r = R_PPC64_GNU_VTENTRY;
2480       break;
2481     }
2482
2483   return ppc64_elf_howto_table[r];
2484 };
2485
2486 static reloc_howto_type *
2487 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2488                              const char *r_name)
2489 {
2490   unsigned int i;
2491
2492   for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2493     if (ppc64_elf_howto_raw[i].name != NULL
2494         && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2495       return &ppc64_elf_howto_raw[i];
2496
2497   return NULL;
2498 }
2499
2500 /* Set the howto pointer for a PowerPC ELF reloc.  */
2501
2502 static void
2503 ppc64_elf_info_to_howto (bfd *abfd, arelent *cache_ptr,
2504                          Elf_Internal_Rela *dst)
2505 {
2506   unsigned int type;
2507
2508   /* Initialize howto table if needed.  */
2509   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2510     ppc_howto_init ();
2511
2512   type = ELF64_R_TYPE (dst->r_info);
2513   if (type >= ARRAY_SIZE (ppc64_elf_howto_table))
2514     {
2515       /* xgettext:c-format */
2516       _bfd_error_handler (_("%B: invalid relocation type %d"),
2517                           abfd, (int) type);
2518       type = R_PPC64_NONE;
2519     }
2520   cache_ptr->howto = ppc64_elf_howto_table[type];
2521 }
2522
2523 /* Handle the R_PPC64_ADDR16_HA and similar relocs.  */
2524
2525 static bfd_reloc_status_type
2526 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2527                     void *data, asection *input_section,
2528                     bfd *output_bfd, char **error_message)
2529 {
2530   enum elf_ppc64_reloc_type r_type;
2531   long insn;
2532   bfd_size_type octets;
2533   bfd_vma value;
2534
2535   /* If this is a relocatable link (output_bfd test tells us), just
2536      call the generic function.  Any adjustment will be done at final
2537      link time.  */
2538   if (output_bfd != NULL)
2539     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2540                                   input_section, output_bfd, error_message);
2541
2542   /* Adjust the addend for sign extension of the low 16 bits.
2543      We won't actually be using the low 16 bits, so trashing them
2544      doesn't matter.  */
2545   reloc_entry->addend += 0x8000;
2546   r_type = reloc_entry->howto->type;
2547   if (r_type != R_PPC64_REL16DX_HA)
2548     return bfd_reloc_continue;
2549
2550   value = 0;
2551   if (!bfd_is_com_section (symbol->section))
2552     value = symbol->value;
2553   value += (reloc_entry->addend
2554             + symbol->section->output_offset
2555             + symbol->section->output_section->vma);
2556   value -= (reloc_entry->address
2557             + input_section->output_offset
2558             + input_section->output_section->vma);
2559   value = (bfd_signed_vma) value >> 16;
2560
2561   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2562   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2563   insn &= ~0x1fffc1;
2564   insn |= (value & 0xffc1) | ((value & 0x3e) << 15);
2565   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2566   if (value + 0x8000 > 0xffff)
2567     return bfd_reloc_overflow;
2568   return bfd_reloc_ok;
2569 }
2570
2571 static bfd_reloc_status_type
2572 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2573                         void *data, asection *input_section,
2574                         bfd *output_bfd, char **error_message)
2575 {
2576   if (output_bfd != NULL)
2577     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2578                                   input_section, output_bfd, error_message);
2579
2580   if (strcmp (symbol->section->name, ".opd") == 0
2581       && (symbol->section->owner->flags & DYNAMIC) == 0)
2582     {
2583       bfd_vma dest = opd_entry_value (symbol->section,
2584                                       symbol->value + reloc_entry->addend,
2585                                       NULL, NULL, FALSE);
2586       if (dest != (bfd_vma) -1)
2587         reloc_entry->addend = dest - (symbol->value
2588                                       + symbol->section->output_section->vma
2589                                       + symbol->section->output_offset);
2590     }
2591   else
2592     {
2593       elf_symbol_type *elfsym = (elf_symbol_type *) symbol;
2594
2595       if (symbol->section->owner != abfd
2596           && symbol->section->owner != NULL
2597           && abiversion (symbol->section->owner) >= 2)
2598         {
2599           unsigned int i;
2600
2601           for (i = 0; i < symbol->section->owner->symcount; ++i)
2602             {
2603               asymbol *symdef = symbol->section->owner->outsymbols[i];
2604
2605               if (strcmp (symdef->name, symbol->name) == 0)
2606                 {
2607                   elfsym = (elf_symbol_type *) symdef;
2608                   break;
2609                 }
2610             }
2611         }
2612       reloc_entry->addend
2613         += PPC64_LOCAL_ENTRY_OFFSET (elfsym->internal_elf_sym.st_other);
2614     }
2615   return bfd_reloc_continue;
2616 }
2617
2618 static bfd_reloc_status_type
2619 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2620                          void *data, asection *input_section,
2621                          bfd *output_bfd, char **error_message)
2622 {
2623   long insn;
2624   enum elf_ppc64_reloc_type r_type;
2625   bfd_size_type octets;
2626   /* Assume 'at' branch hints.  */
2627   bfd_boolean is_isa_v2 = TRUE;
2628
2629   /* If this is a relocatable link (output_bfd test tells us), just
2630      call the generic function.  Any adjustment will be done at final
2631      link time.  */
2632   if (output_bfd != NULL)
2633     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2634                                   input_section, output_bfd, error_message);
2635
2636   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2637   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2638   insn &= ~(0x01 << 21);
2639   r_type = reloc_entry->howto->type;
2640   if (r_type == R_PPC64_ADDR14_BRTAKEN
2641       || r_type == R_PPC64_REL14_BRTAKEN)
2642     insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
2643
2644   if (is_isa_v2)
2645     {
2646       /* Set 'a' bit.  This is 0b00010 in BO field for branch
2647          on CR(BI) insns (BO == 001at or 011at), and 0b01000
2648          for branch on CTR insns (BO == 1a00t or 1a01t).  */
2649       if ((insn & (0x14 << 21)) == (0x04 << 21))
2650         insn |= 0x02 << 21;
2651       else if ((insn & (0x14 << 21)) == (0x10 << 21))
2652         insn |= 0x08 << 21;
2653       else
2654         goto out;
2655     }
2656   else
2657     {
2658       bfd_vma target = 0;
2659       bfd_vma from;
2660
2661       if (!bfd_is_com_section (symbol->section))
2662         target = symbol->value;
2663       target += symbol->section->output_section->vma;
2664       target += symbol->section->output_offset;
2665       target += reloc_entry->addend;
2666
2667       from = (reloc_entry->address
2668               + input_section->output_offset
2669               + input_section->output_section->vma);
2670
2671       /* Invert 'y' bit if not the default.  */
2672       if ((bfd_signed_vma) (target - from) < 0)
2673         insn ^= 0x01 << 21;
2674     }
2675   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2676  out:
2677   return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2678                                  input_section, output_bfd, error_message);
2679 }
2680
2681 static bfd_reloc_status_type
2682 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2683                          void *data, asection *input_section,
2684                          bfd *output_bfd, char **error_message)
2685 {
2686   /* If this is a relocatable link (output_bfd test tells us), just
2687      call the generic function.  Any adjustment will be done at final
2688      link time.  */
2689   if (output_bfd != NULL)
2690     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2691                                   input_section, output_bfd, error_message);
2692
2693   /* Subtract the symbol section base address.  */
2694   reloc_entry->addend -= symbol->section->output_section->vma;
2695   return bfd_reloc_continue;
2696 }
2697
2698 static bfd_reloc_status_type
2699 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2700                             void *data, asection *input_section,
2701                             bfd *output_bfd, char **error_message)
2702 {
2703   /* If this is a relocatable link (output_bfd test tells us), just
2704      call the generic function.  Any adjustment will be done at final
2705      link time.  */
2706   if (output_bfd != NULL)
2707     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2708                                   input_section, output_bfd, error_message);
2709
2710   /* Subtract the symbol section base address.  */
2711   reloc_entry->addend -= symbol->section->output_section->vma;
2712
2713   /* Adjust the addend for sign extension of the low 16 bits.  */
2714   reloc_entry->addend += 0x8000;
2715   return bfd_reloc_continue;
2716 }
2717
2718 static bfd_reloc_status_type
2719 ppc64_elf_toc_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   return bfd_reloc_continue;
2739 }
2740
2741 static bfd_reloc_status_type
2742 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2743                         void *data, asection *input_section,
2744                         bfd *output_bfd, char **error_message)
2745 {
2746   bfd_vma TOCstart;
2747
2748   /* If this is a relocatable link (output_bfd test tells us), just
2749      call the generic function.  Any adjustment will be done at final
2750      link time.  */
2751   if (output_bfd != NULL)
2752     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2753                                   input_section, output_bfd, error_message);
2754
2755   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2756   if (TOCstart == 0)
2757     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2758
2759   /* Subtract the TOC base address.  */
2760   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2761
2762   /* Adjust the addend for sign extension of the low 16 bits.  */
2763   reloc_entry->addend += 0x8000;
2764   return bfd_reloc_continue;
2765 }
2766
2767 static bfd_reloc_status_type
2768 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2769                        void *data, asection *input_section,
2770                        bfd *output_bfd, char **error_message)
2771 {
2772   bfd_vma TOCstart;
2773   bfd_size_type octets;
2774
2775   /* If this is a relocatable link (output_bfd test tells us), just
2776      call the generic function.  Any adjustment will be done at final
2777      link time.  */
2778   if (output_bfd != NULL)
2779     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2780                                   input_section, output_bfd, error_message);
2781
2782   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2783   if (TOCstart == 0)
2784     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2785
2786   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2787   bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2788   return bfd_reloc_ok;
2789 }
2790
2791 static bfd_reloc_status_type
2792 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2793                            void *data, asection *input_section,
2794                            bfd *output_bfd, char **error_message)
2795 {
2796   /* If this is a relocatable link (output_bfd test tells us), just
2797      call the generic function.  Any adjustment will be done at final
2798      link time.  */
2799   if (output_bfd != NULL)
2800     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2801                                   input_section, output_bfd, error_message);
2802
2803   if (error_message != NULL)
2804     {
2805       static char buf[60];
2806       sprintf (buf, "generic linker can't handle %s",
2807                reloc_entry->howto->name);
2808       *error_message = buf;
2809     }
2810   return bfd_reloc_dangerous;
2811 }
2812
2813 /* Track GOT entries needed for a given symbol.  We might need more
2814    than one got entry per symbol.  */
2815 struct got_entry
2816 {
2817   struct got_entry *next;
2818
2819   /* The symbol addend that we'll be placing in the GOT.  */
2820   bfd_vma addend;
2821
2822   /* Unlike other ELF targets, we use separate GOT entries for the same
2823      symbol referenced from different input files.  This is to support
2824      automatic multiple TOC/GOT sections, where the TOC base can vary
2825      from one input file to another.  After partitioning into TOC groups
2826      we merge entries within the group.
2827
2828      Point to the BFD owning this GOT entry.  */
2829   bfd *owner;
2830
2831   /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2832      TLS_TPREL or TLS_DTPREL for tls entries.  */
2833   unsigned char tls_type;
2834
2835   /* Non-zero if got.ent points to real entry.  */
2836   unsigned char is_indirect;
2837
2838   /* Reference count until size_dynamic_sections, GOT offset thereafter.  */
2839   union
2840     {
2841       bfd_signed_vma refcount;
2842       bfd_vma offset;
2843       struct got_entry *ent;
2844     } got;
2845 };
2846
2847 /* The same for PLT.  */
2848 struct plt_entry
2849 {
2850   struct plt_entry *next;
2851
2852   bfd_vma addend;
2853
2854   union
2855     {
2856       bfd_signed_vma refcount;
2857       bfd_vma offset;
2858     } plt;
2859 };
2860
2861 struct ppc64_elf_obj_tdata
2862 {
2863   struct elf_obj_tdata elf;
2864
2865   /* Shortcuts to dynamic linker sections.  */
2866   asection *got;
2867   asection *relgot;
2868
2869   /* Used during garbage collection.  We attach global symbols defined
2870      on removed .opd entries to this section so that the sym is removed.  */
2871   asection *deleted_section;
2872
2873   /* TLS local dynamic got entry handling.  Support for multiple GOT
2874      sections means we potentially need one of these for each input bfd.  */
2875   struct got_entry tlsld_got;
2876
2877   union {
2878     /* A copy of relocs before they are modified for --emit-relocs.  */
2879     Elf_Internal_Rela *relocs;
2880
2881     /* Section contents.  */
2882     bfd_byte *contents;
2883   } opd;
2884
2885   /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2886      the reloc to be in the range -32768 to 32767.  */
2887   unsigned int has_small_toc_reloc : 1;
2888
2889   /* Set if toc/got ha relocs detected not using r2, or lo reloc
2890      instruction not one we handle.  */
2891   unsigned int unexpected_toc_insn : 1;
2892 };
2893
2894 #define ppc64_elf_tdata(bfd) \
2895   ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2896
2897 #define ppc64_tlsld_got(bfd) \
2898   (&ppc64_elf_tdata (bfd)->tlsld_got)
2899
2900 #define is_ppc64_elf(bfd) \
2901   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2902    && elf_object_id (bfd) == PPC64_ELF_DATA)
2903
2904 /* Override the generic function because we store some extras.  */
2905
2906 static bfd_boolean
2907 ppc64_elf_mkobject (bfd *abfd)
2908 {
2909   return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2910                                   PPC64_ELF_DATA);
2911 }
2912
2913 /* Fix bad default arch selected for a 64 bit input bfd when the
2914    default is 32 bit.  Also select arch based on apuinfo.  */
2915
2916 static bfd_boolean
2917 ppc64_elf_object_p (bfd *abfd)
2918 {
2919   if (!abfd->arch_info->the_default)
2920     return TRUE;
2921
2922   if (abfd->arch_info->bits_per_word == 32)
2923     {
2924       Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2925
2926       if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2927         {
2928           /* Relies on arch after 32 bit default being 64 bit default.  */
2929           abfd->arch_info = abfd->arch_info->next;
2930           BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2931         }
2932     }
2933   return _bfd_elf_ppc_set_arch (abfd);
2934 }
2935
2936 /* Support for core dump NOTE sections.  */
2937
2938 static bfd_boolean
2939 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2940 {
2941   size_t offset, size;
2942
2943   if (note->descsz != 504)
2944     return FALSE;
2945
2946   /* pr_cursig */
2947   elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2948
2949   /* pr_pid */
2950   elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2951
2952   /* pr_reg */
2953   offset = 112;
2954   size = 384;
2955
2956   /* Make a ".reg/999" section.  */
2957   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2958                                           size, note->descpos + offset);
2959 }
2960
2961 static bfd_boolean
2962 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2963 {
2964   if (note->descsz != 136)
2965     return FALSE;
2966
2967   elf_tdata (abfd)->core->pid
2968     = bfd_get_32 (abfd, note->descdata + 24);
2969   elf_tdata (abfd)->core->program
2970     = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2971   elf_tdata (abfd)->core->command
2972     = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2973
2974   return TRUE;
2975 }
2976
2977 static char *
2978 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2979                            ...)
2980 {
2981   switch (note_type)
2982     {
2983     default:
2984       return NULL;
2985
2986     case NT_PRPSINFO:
2987       {
2988         char data[136];
2989         va_list ap;
2990
2991         va_start (ap, note_type);
2992         memset (data, 0, sizeof (data));
2993         strncpy (data + 40, va_arg (ap, const char *), 16);
2994         strncpy (data + 56, va_arg (ap, const char *), 80);
2995         va_end (ap);
2996         return elfcore_write_note (abfd, buf, bufsiz,
2997                                    "CORE", note_type, data, sizeof (data));
2998       }
2999
3000     case NT_PRSTATUS:
3001       {
3002         char data[504];
3003         va_list ap;
3004         long pid;
3005         int cursig;
3006         const void *greg;
3007
3008         va_start (ap, note_type);
3009         memset (data, 0, 112);
3010         pid = va_arg (ap, long);
3011         bfd_put_32 (abfd, pid, data + 32);
3012         cursig = va_arg (ap, int);
3013         bfd_put_16 (abfd, cursig, data + 12);
3014         greg = va_arg (ap, const void *);
3015         memcpy (data + 112, greg, 384);
3016         memset (data + 496, 0, 8);
3017         va_end (ap);
3018         return elfcore_write_note (abfd, buf, bufsiz,
3019                                    "CORE", note_type, data, sizeof (data));
3020       }
3021     }
3022 }
3023
3024 /* Add extra PPC sections.  */
3025
3026 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
3027 {
3028   { STRING_COMMA_LEN (".plt"),    0, SHT_NOBITS,   0 },
3029   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
3030   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3031   { STRING_COMMA_LEN (".toc"),    0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3032   { STRING_COMMA_LEN (".toc1"),   0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3033   { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
3034   { NULL,                     0,  0, 0,            0 }
3035 };
3036
3037 enum _ppc64_sec_type {
3038   sec_normal = 0,
3039   sec_opd = 1,
3040   sec_toc = 2
3041 };
3042
3043 struct _ppc64_elf_section_data
3044 {
3045   struct bfd_elf_section_data elf;
3046
3047   union
3048   {
3049     /* An array with one entry for each opd function descriptor,
3050        and some spares since opd entries may be either 16 or 24 bytes.  */
3051 #define OPD_NDX(OFF) ((OFF) >> 4)
3052     struct _opd_sec_data
3053     {
3054       /* Points to the function code section for local opd entries.  */
3055       asection **func_sec;
3056
3057       /* After editing .opd, adjust references to opd local syms.  */
3058       long *adjust;
3059     } opd;
3060
3061     /* An array for toc sections, indexed by offset/8.  */
3062     struct _toc_sec_data
3063     {
3064       /* Specifies the relocation symbol index used at a given toc offset.  */
3065       unsigned *symndx;
3066
3067       /* And the relocation addend.  */
3068       bfd_vma *add;
3069     } toc;
3070   } u;
3071
3072   enum _ppc64_sec_type sec_type:2;
3073
3074   /* Flag set when small branches are detected.  Used to
3075      select suitable defaults for the stub group size.  */
3076   unsigned int has_14bit_branch:1;
3077 };
3078
3079 #define ppc64_elf_section_data(sec) \
3080   ((struct _ppc64_elf_section_data *) elf_section_data (sec))
3081
3082 static bfd_boolean
3083 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
3084 {
3085   if (!sec->used_by_bfd)
3086     {
3087       struct _ppc64_elf_section_data *sdata;
3088       bfd_size_type amt = sizeof (*sdata);
3089
3090       sdata = bfd_zalloc (abfd, amt);
3091       if (sdata == NULL)
3092         return FALSE;
3093       sec->used_by_bfd = sdata;
3094     }
3095
3096   return _bfd_elf_new_section_hook (abfd, sec);
3097 }
3098
3099 static struct _opd_sec_data *
3100 get_opd_info (asection * sec)
3101 {
3102   if (sec != NULL
3103       && ppc64_elf_section_data (sec) != NULL
3104       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
3105     return &ppc64_elf_section_data (sec)->u.opd;
3106   return NULL;
3107 }
3108 \f
3109 /* Parameters for the qsort hook.  */
3110 static bfd_boolean synthetic_relocatable;
3111 static asection *synthetic_opd;
3112
3113 /* qsort comparison function for ppc64_elf_get_synthetic_symtab.  */
3114
3115 static int
3116 compare_symbols (const void *ap, const void *bp)
3117 {
3118   const asymbol *a = * (const asymbol **) ap;
3119   const asymbol *b = * (const asymbol **) bp;
3120
3121   /* Section symbols first.  */
3122   if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
3123     return -1;
3124   if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
3125     return 1;
3126
3127   /* then .opd symbols.  */
3128   if (synthetic_opd != NULL)
3129     {
3130       if (strcmp (a->section->name, ".opd") == 0
3131           && strcmp (b->section->name, ".opd") != 0)
3132         return -1;
3133       if (strcmp (a->section->name, ".opd") != 0
3134           && strcmp (b->section->name, ".opd") == 0)
3135         return 1;
3136     }
3137
3138   /* then other code symbols.  */
3139   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3140       == (SEC_CODE | SEC_ALLOC)
3141       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3142          != (SEC_CODE | SEC_ALLOC))
3143     return -1;
3144
3145   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3146       != (SEC_CODE | SEC_ALLOC)
3147       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3148          == (SEC_CODE | SEC_ALLOC))
3149     return 1;
3150
3151   if (synthetic_relocatable)
3152     {
3153       if (a->section->id < b->section->id)
3154         return -1;
3155
3156       if (a->section->id > b->section->id)
3157         return 1;
3158     }
3159
3160   if (a->value + a->section->vma < b->value + b->section->vma)
3161     return -1;
3162
3163   if (a->value + a->section->vma > b->value + b->section->vma)
3164     return 1;
3165
3166   /* For syms with the same value, prefer strong dynamic global function
3167      syms over other syms.  */
3168   if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3169     return -1;
3170
3171   if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3172     return 1;
3173
3174   if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3175     return -1;
3176
3177   if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3178     return 1;
3179
3180   if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3181     return -1;
3182
3183   if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3184     return 1;
3185
3186   if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3187     return -1;
3188
3189   if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3190     return 1;
3191
3192   return a > b;
3193 }
3194
3195 /* Search SYMS for a symbol of the given VALUE.  */
3196
3197 static asymbol *
3198 sym_exists_at (asymbol **syms, long lo, long hi, unsigned int id, bfd_vma value)
3199 {
3200   long mid;
3201
3202   if (id == (unsigned) -1)
3203     {
3204       while (lo < hi)
3205         {
3206           mid = (lo + hi) >> 1;
3207           if (syms[mid]->value + syms[mid]->section->vma < value)
3208             lo = mid + 1;
3209           else if (syms[mid]->value + syms[mid]->section->vma > value)
3210             hi = mid;
3211           else
3212             return syms[mid];
3213         }
3214     }
3215   else
3216     {
3217       while (lo < hi)
3218         {
3219           mid = (lo + hi) >> 1;
3220           if (syms[mid]->section->id < id)
3221             lo = mid + 1;
3222           else if (syms[mid]->section->id > id)
3223             hi = mid;
3224           else if (syms[mid]->value < value)
3225             lo = mid + 1;
3226           else if (syms[mid]->value > value)
3227             hi = mid;
3228           else
3229             return syms[mid];
3230         }
3231     }
3232   return NULL;
3233 }
3234
3235 static bfd_boolean
3236 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3237 {
3238   bfd_vma vma = *(bfd_vma *) ptr;
3239   return ((section->flags & SEC_ALLOC) != 0
3240           && section->vma <= vma
3241           && vma < section->vma + section->size);
3242 }
3243
3244 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3245    entry syms.  Also generate @plt symbols for the glink branch table.
3246    Returns count of synthetic symbols in RET or -1 on error.  */
3247
3248 static long
3249 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3250                                 long static_count, asymbol **static_syms,
3251                                 long dyn_count, asymbol **dyn_syms,
3252                                 asymbol **ret)
3253 {
3254   asymbol *s;
3255   long i;
3256   long count;
3257   char *names;
3258   long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3259   asection *opd = NULL;
3260   bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3261   asymbol **syms;
3262   int abi = abiversion (abfd);
3263
3264   *ret = NULL;
3265
3266   if (abi < 2)
3267     {
3268       opd = bfd_get_section_by_name (abfd, ".opd");
3269       if (opd == NULL && abi == 1)
3270         return 0;
3271     }
3272
3273   symcount = static_count;
3274   if (!relocatable)
3275     symcount += dyn_count;
3276   if (symcount == 0)
3277     return 0;
3278
3279   syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3280   if (syms == NULL)
3281     return -1;
3282
3283   if (!relocatable && static_count != 0 && dyn_count != 0)
3284     {
3285       /* Use both symbol tables.  */
3286       memcpy (syms, static_syms, static_count * sizeof (*syms));
3287       memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3288     }
3289   else if (!relocatable && static_count == 0)
3290     memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3291   else
3292     memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3293
3294   synthetic_relocatable = relocatable;
3295   synthetic_opd = opd;
3296   qsort (syms, symcount, sizeof (*syms), compare_symbols);
3297
3298   if (!relocatable && symcount > 1)
3299     {
3300       long j;
3301       /* Trim duplicate syms, since we may have merged the normal and
3302          dynamic symbols.  Actually, we only care about syms that have
3303          different values, so trim any with the same value.  */
3304       for (i = 1, j = 1; i < symcount; ++i)
3305         if (syms[i - 1]->value + syms[i - 1]->section->vma
3306             != syms[i]->value + syms[i]->section->vma)
3307           syms[j++] = syms[i];
3308       symcount = j;
3309     }
3310
3311   i = 0;
3312   /* Note that here and in compare_symbols we can't compare opd and
3313      sym->section directly.  With separate debug info files, the
3314      symbols will be extracted from the debug file while abfd passed
3315      to this function is the real binary.  */
3316   if (opd != NULL && strcmp (syms[i]->section->name, ".opd") == 0)
3317     ++i;
3318   codesecsym = i;
3319
3320   for (; i < symcount; ++i)
3321     if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3322          != (SEC_CODE | SEC_ALLOC))
3323         || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3324       break;
3325   codesecsymend = i;
3326
3327   for (; i < symcount; ++i)
3328     if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3329       break;
3330   secsymend = i;
3331
3332   if (opd != NULL)
3333     for (; i < symcount; ++i)
3334       if (strcmp (syms[i]->section->name, ".opd") != 0)
3335         break;
3336   opdsymend = i;
3337
3338   for (; i < symcount; ++i)
3339     if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3340         != (SEC_CODE | SEC_ALLOC))
3341       break;
3342   symcount = i;
3343
3344   count = 0;
3345
3346   if (relocatable)
3347     {
3348       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3349       arelent *r;
3350       size_t size;
3351       long relcount;
3352
3353       if (opdsymend == secsymend)
3354         goto done;
3355
3356       slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3357       relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3358       if (relcount == 0)
3359         goto done;
3360
3361       if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3362         {
3363           count = -1;
3364           goto done;
3365         }
3366
3367       size = 0;
3368       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3369         {
3370           asymbol *sym;
3371
3372           while (r < opd->relocation + relcount
3373                  && r->address < syms[i]->value + opd->vma)
3374             ++r;
3375
3376           if (r == opd->relocation + relcount)
3377             break;
3378
3379           if (r->address != syms[i]->value + opd->vma)
3380             continue;
3381
3382           if (r->howto->type != R_PPC64_ADDR64)
3383             continue;
3384
3385           sym = *r->sym_ptr_ptr;
3386           if (!sym_exists_at (syms, opdsymend, symcount,
3387                               sym->section->id, sym->value + r->addend))
3388             {
3389               ++count;
3390               size += sizeof (asymbol);
3391               size += strlen (syms[i]->name) + 2;
3392             }
3393         }
3394
3395       if (size == 0)
3396         goto done;
3397       s = *ret = bfd_malloc (size);
3398       if (s == NULL)
3399         {
3400           count = -1;
3401           goto done;
3402         }
3403
3404       names = (char *) (s + count);
3405
3406       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3407         {
3408           asymbol *sym;
3409
3410           while (r < opd->relocation + relcount
3411                  && r->address < syms[i]->value + opd->vma)
3412             ++r;
3413
3414           if (r == opd->relocation + relcount)
3415             break;
3416
3417           if (r->address != syms[i]->value + opd->vma)
3418             continue;
3419
3420           if (r->howto->type != R_PPC64_ADDR64)
3421             continue;
3422
3423           sym = *r->sym_ptr_ptr;
3424           if (!sym_exists_at (syms, opdsymend, symcount,
3425                               sym->section->id, sym->value + r->addend))
3426             {
3427               size_t len;
3428
3429               *s = *syms[i];
3430               s->flags |= BSF_SYNTHETIC;
3431               s->section = sym->section;
3432               s->value = sym->value + r->addend;
3433               s->name = names;
3434               *names++ = '.';
3435               len = strlen (syms[i]->name);
3436               memcpy (names, syms[i]->name, len + 1);
3437               names += len + 1;
3438               /* Have udata.p point back to the original symbol this
3439                  synthetic symbol was derived from.  */
3440               s->udata.p = syms[i];
3441               s++;
3442             }
3443         }
3444     }
3445   else
3446     {
3447       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3448       bfd_byte *contents = NULL;
3449       size_t size;
3450       long plt_count = 0;
3451       bfd_vma glink_vma = 0, resolv_vma = 0;
3452       asection *dynamic, *glink = NULL, *relplt = NULL;
3453       arelent *p;
3454
3455       if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3456         {
3457         free_contents_and_exit_err:
3458           count = -1;
3459         free_contents_and_exit:
3460           if (contents)
3461             free (contents);
3462           goto done;
3463         }
3464
3465       size = 0;
3466       for (i = secsymend; i < opdsymend; ++i)
3467         {
3468           bfd_vma ent;
3469
3470           /* Ignore bogus symbols.  */
3471           if (syms[i]->value > opd->size - 8)
3472             continue;
3473
3474           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3475           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3476             {
3477               ++count;
3478               size += sizeof (asymbol);
3479               size += strlen (syms[i]->name) + 2;
3480             }
3481         }
3482
3483       /* Get start of .glink stubs from DT_PPC64_GLINK.  */
3484       if (dyn_count != 0
3485           && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3486         {
3487           bfd_byte *dynbuf, *extdyn, *extdynend;
3488           size_t extdynsize;
3489           void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3490
3491           if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3492             goto free_contents_and_exit_err;
3493
3494           extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3495           swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3496
3497           extdyn = dynbuf;
3498           extdynend = extdyn + dynamic->size;
3499           for (; extdyn < extdynend; extdyn += extdynsize)
3500             {
3501               Elf_Internal_Dyn dyn;
3502               (*swap_dyn_in) (abfd, extdyn, &dyn);
3503
3504               if (dyn.d_tag == DT_NULL)
3505                 break;
3506
3507               if (dyn.d_tag == DT_PPC64_GLINK)
3508                 {
3509                   /* The first glink stub starts at offset 32; see
3510                      comment in ppc64_elf_finish_dynamic_sections. */
3511                   glink_vma = dyn.d_un.d_val + GLINK_CALL_STUB_SIZE - 8 * 4;
3512                   /* The .glink section usually does not survive the final
3513                      link; search for the section (usually .text) where the
3514                      glink stubs now reside.  */
3515                   glink = bfd_sections_find_if (abfd, section_covers_vma,
3516                                                 &glink_vma);
3517                   break;
3518                 }
3519             }
3520
3521           free (dynbuf);
3522         }
3523
3524       if (glink != NULL)
3525         {
3526           /* Determine __glink trampoline by reading the relative branch
3527              from the first glink stub.  */
3528           bfd_byte buf[4];
3529           unsigned int off = 0;
3530
3531           while (bfd_get_section_contents (abfd, glink, buf,
3532                                            glink_vma + off - glink->vma, 4))
3533             {
3534               unsigned int insn = bfd_get_32 (abfd, buf);
3535               insn ^= B_DOT;
3536               if ((insn & ~0x3fffffc) == 0)
3537                 {
3538                   resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3539                   break;
3540                 }
3541               off += 4;
3542               if (off > 4)
3543                 break;
3544             }
3545
3546           if (resolv_vma)
3547             size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3548
3549           relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3550           if (relplt != NULL)
3551             {
3552               slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3553               if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3554                 goto free_contents_and_exit_err;
3555
3556               plt_count = relplt->size / sizeof (Elf64_External_Rela);
3557               size += plt_count * sizeof (asymbol);
3558
3559               p = relplt->relocation;
3560               for (i = 0; i < plt_count; i++, p++)
3561                 {
3562                   size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3563                   if (p->addend != 0)
3564                     size += sizeof ("+0x") - 1 + 16;
3565                 }
3566             }
3567         }
3568
3569       if (size == 0)
3570         goto free_contents_and_exit;
3571       s = *ret = bfd_malloc (size);
3572       if (s == NULL)
3573         goto free_contents_and_exit_err;
3574
3575       names = (char *) (s + count + plt_count + (resolv_vma != 0));
3576
3577       for (i = secsymend; i < opdsymend; ++i)
3578         {
3579           bfd_vma ent;
3580
3581           if (syms[i]->value > opd->size - 8)
3582             continue;
3583
3584           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3585           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3586             {
3587               long lo, hi;
3588               size_t len;
3589               asection *sec = abfd->sections;
3590
3591               *s = *syms[i];
3592               lo = codesecsym;
3593               hi = codesecsymend;
3594               while (lo < hi)
3595                 {
3596                   long mid = (lo + hi) >> 1;
3597                   if (syms[mid]->section->vma < ent)
3598                     lo = mid + 1;
3599                   else if (syms[mid]->section->vma > ent)
3600                     hi = mid;
3601                   else
3602                     {
3603                       sec = syms[mid]->section;
3604                       break;
3605                     }
3606                 }
3607
3608               if (lo >= hi && lo > codesecsym)
3609                 sec = syms[lo - 1]->section;
3610
3611               for (; sec != NULL; sec = sec->next)
3612                 {
3613                   if (sec->vma > ent)
3614                     break;
3615                   /* SEC_LOAD may not be set if SEC is from a separate debug
3616                      info file.  */
3617                   if ((sec->flags & SEC_ALLOC) == 0)
3618                     break;
3619                   if ((sec->flags & SEC_CODE) != 0)
3620                     s->section = sec;
3621                 }
3622               s->flags |= BSF_SYNTHETIC;
3623               s->value = ent - s->section->vma;
3624               s->name = names;
3625               *names++ = '.';
3626               len = strlen (syms[i]->name);
3627               memcpy (names, syms[i]->name, len + 1);
3628               names += len + 1;
3629               /* Have udata.p point back to the original symbol this
3630                  synthetic symbol was derived from.  */
3631               s->udata.p = syms[i];
3632               s++;
3633             }
3634         }
3635       free (contents);
3636
3637       if (glink != NULL && relplt != NULL)
3638         {
3639           if (resolv_vma)
3640             {
3641               /* Add a symbol for the main glink trampoline.  */
3642               memset (s, 0, sizeof *s);
3643               s->the_bfd = abfd;
3644               s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3645               s->section = glink;
3646               s->value = resolv_vma - glink->vma;
3647               s->name = names;
3648               memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3649               names += sizeof ("__glink_PLTresolve");
3650               s++;
3651               count++;
3652             }
3653
3654           /* FIXME: It would be very much nicer to put sym@plt on the
3655              stub rather than on the glink branch table entry.  The
3656              objdump disassembler would then use a sensible symbol
3657              name on plt calls.  The difficulty in doing so is
3658              a) finding the stubs, and,
3659              b) matching stubs against plt entries, and,
3660              c) there can be multiple stubs for a given plt entry.
3661
3662              Solving (a) could be done by code scanning, but older
3663              ppc64 binaries used different stubs to current code.
3664              (b) is the tricky one since you need to known the toc
3665              pointer for at least one function that uses a pic stub to
3666              be able to calculate the plt address referenced.
3667              (c) means gdb would need to set multiple breakpoints (or
3668              find the glink branch itself) when setting breakpoints
3669              for pending shared library loads.  */
3670           p = relplt->relocation;
3671           for (i = 0; i < plt_count; i++, p++)
3672             {
3673               size_t len;
3674
3675               *s = **p->sym_ptr_ptr;
3676               /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
3677                  we are defining a symbol, ensure one of them is set.  */
3678               if ((s->flags & BSF_LOCAL) == 0)
3679                 s->flags |= BSF_GLOBAL;
3680               s->flags |= BSF_SYNTHETIC;
3681               s->section = glink;
3682               s->value = glink_vma - glink->vma;
3683               s->name = names;
3684               s->udata.p = NULL;
3685               len = strlen ((*p->sym_ptr_ptr)->name);
3686               memcpy (names, (*p->sym_ptr_ptr)->name, len);
3687               names += len;
3688               if (p->addend != 0)
3689                 {
3690                   memcpy (names, "+0x", sizeof ("+0x") - 1);
3691                   names += sizeof ("+0x") - 1;
3692                   bfd_sprintf_vma (abfd, names, p->addend);
3693                   names += strlen (names);
3694                 }
3695               memcpy (names, "@plt", sizeof ("@plt"));
3696               names += sizeof ("@plt");
3697               s++;
3698               if (abi < 2)
3699                 {
3700                   glink_vma += 8;
3701                   if (i >= 0x8000)
3702                     glink_vma += 4;
3703                 }
3704               else
3705                 glink_vma += 4;
3706             }
3707           count += plt_count;
3708         }
3709     }
3710
3711  done:
3712   free (syms);
3713   return count;
3714 }
3715 \f
3716 /* The following functions are specific to the ELF linker, while
3717    functions above are used generally.  Those named ppc64_elf_* are
3718    called by the main ELF linker code.  They appear in this file more
3719    or less in the order in which they are called.  eg.
3720    ppc64_elf_check_relocs is called early in the link process,
3721    ppc64_elf_finish_dynamic_sections is one of the last functions
3722    called.
3723
3724    PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3725    functions have both a function code symbol and a function descriptor
3726    symbol.  A call to foo in a relocatable object file looks like:
3727
3728    .            .text
3729    .    x:
3730    .            bl      .foo
3731    .            nop
3732
3733    The function definition in another object file might be:
3734
3735    .            .section .opd
3736    .    foo:    .quad   .foo
3737    .            .quad   .TOC.@tocbase
3738    .            .quad   0
3739    .
3740    .            .text
3741    .    .foo:   blr
3742
3743    When the linker resolves the call during a static link, the branch
3744    unsurprisingly just goes to .foo and the .opd information is unused.
3745    If the function definition is in a shared library, things are a little
3746    different:  The call goes via a plt call stub, the opd information gets
3747    copied to the plt, and the linker patches the nop.
3748
3749    .    x:
3750    .            bl      .foo_stub
3751    .            ld      2,40(1)
3752    .
3753    .
3754    .    .foo_stub:
3755    .            std     2,40(1)                 # in practice, the call stub
3756    .            addis   11,2,Lfoo@toc@ha        # is slightly optimized, but
3757    .            addi    11,11,Lfoo@toc@l        # this is the general idea
3758    .            ld      12,0(11)
3759    .            ld      2,8(11)
3760    .            mtctr   12
3761    .            ld      11,16(11)
3762    .            bctr
3763    .
3764    .            .section .plt
3765    .    Lfoo:   reloc (R_PPC64_JMP_SLOT, foo)
3766
3767    The "reloc ()" notation is supposed to indicate that the linker emits
3768    an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
3769    copying.
3770
3771    What are the difficulties here?  Well, firstly, the relocations
3772    examined by the linker in check_relocs are against the function code
3773    sym .foo, while the dynamic relocation in the plt is emitted against
3774    the function descriptor symbol, foo.  Somewhere along the line, we need
3775    to carefully copy dynamic link information from one symbol to the other.
3776    Secondly, the generic part of the elf linker will make .foo a dynamic
3777    symbol as is normal for most other backends.  We need foo dynamic
3778    instead, at least for an application final link.  However, when
3779    creating a shared library containing foo, we need to have both symbols
3780    dynamic so that references to .foo are satisfied during the early
3781    stages of linking.  Otherwise the linker might decide to pull in a
3782    definition from some other object, eg. a static library.
3783
3784    Update: As of August 2004, we support a new convention.  Function
3785    calls may use the function descriptor symbol, ie. "bl foo".  This
3786    behaves exactly as "bl .foo".  */
3787
3788 /* Of those relocs that might be copied as dynamic relocs, this function
3789    selects those that must be copied when linking a shared library,
3790    even when the symbol is local.  */
3791
3792 static int
3793 must_be_dyn_reloc (struct bfd_link_info *info,
3794                    enum elf_ppc64_reloc_type r_type)
3795 {
3796   switch (r_type)
3797     {
3798     default:
3799       return 1;
3800
3801     case R_PPC64_REL32:
3802     case R_PPC64_REL64:
3803     case R_PPC64_REL30:
3804       return 0;
3805
3806     case R_PPC64_TPREL16:
3807     case R_PPC64_TPREL16_LO:
3808     case R_PPC64_TPREL16_HI:
3809     case R_PPC64_TPREL16_HA:
3810     case R_PPC64_TPREL16_DS:
3811     case R_PPC64_TPREL16_LO_DS:
3812     case R_PPC64_TPREL16_HIGH:
3813     case R_PPC64_TPREL16_HIGHA:
3814     case R_PPC64_TPREL16_HIGHER:
3815     case R_PPC64_TPREL16_HIGHERA:
3816     case R_PPC64_TPREL16_HIGHEST:
3817     case R_PPC64_TPREL16_HIGHESTA:
3818     case R_PPC64_TPREL64:
3819       return !bfd_link_executable (info);
3820     }
3821 }
3822
3823 /* Whether an undefined weak symbol should resolve to its link-time
3824    value, even in PIC or PIE objects.  */
3825 #define UNDEFWEAK_NO_DYNAMIC_RELOC(INFO, H)             \
3826   ((H)->root.type == bfd_link_hash_undefweak            \
3827    && (ELF_ST_VISIBILITY ((H)->other) != STV_DEFAULT    \
3828        || (INFO)->dynamic_undefined_weak == 0))
3829
3830 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3831    copying dynamic variables from a shared lib into an app's dynbss
3832    section, and instead use a dynamic relocation to point into the
3833    shared lib.  With code that gcc generates, it's vital that this be
3834    enabled;  In the PowerPC64 ABI, the address of a function is actually
3835    the address of a function descriptor, which resides in the .opd
3836    section.  gcc uses the descriptor directly rather than going via the
3837    GOT as some other ABI's do, which means that initialized function
3838    pointers must reference the descriptor.  Thus, a function pointer
3839    initialized to the address of a function in a shared library will
3840    either require a copy reloc, or a dynamic reloc.  Using a copy reloc
3841    redefines the function descriptor symbol to point to the copy.  This
3842    presents a problem as a plt entry for that function is also
3843    initialized from the function descriptor symbol and the copy reloc
3844    may not be initialized first.  */
3845 #define ELIMINATE_COPY_RELOCS 1
3846
3847 /* Section name for stubs is the associated section name plus this
3848    string.  */
3849 #define STUB_SUFFIX ".stub"
3850
3851 /* Linker stubs.
3852    ppc_stub_long_branch:
3853    Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3854    destination, but a 24 bit branch in a stub section will reach.
3855    .    b       dest
3856
3857    ppc_stub_plt_branch:
3858    Similar to the above, but a 24 bit branch in the stub section won't
3859    reach its destination.
3860    .    addis   %r11,%r2,xxx@toc@ha
3861    .    ld      %r12,xxx@toc@l(%r11)
3862    .    mtctr   %r12
3863    .    bctr
3864
3865    ppc_stub_plt_call:
3866    Used to call a function in a shared library.  If it so happens that
3867    the plt entry referenced crosses a 64k boundary, then an extra
3868    "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3869    .    std     %r2,40(%r1)
3870    .    addis   %r11,%r2,xxx@toc@ha
3871    .    ld      %r12,xxx+0@toc@l(%r11)
3872    .    mtctr   %r12
3873    .    ld      %r2,xxx+8@toc@l(%r11)
3874    .    ld      %r11,xxx+16@toc@l(%r11)
3875    .    bctr
3876
3877    ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3878    code to adjust the value and save r2 to support multiple toc sections.
3879    A ppc_stub_long_branch with an r2 offset looks like:
3880    .    std     %r2,40(%r1)
3881    .    addis   %r2,%r2,off@ha
3882    .    addi    %r2,%r2,off@l
3883    .    b       dest
3884
3885    A ppc_stub_plt_branch with an r2 offset looks like:
3886    .    std     %r2,40(%r1)
3887    .    addis   %r11,%r2,xxx@toc@ha
3888    .    ld      %r12,xxx@toc@l(%r11)
3889    .    addis   %r2,%r2,off@ha
3890    .    addi    %r2,%r2,off@l
3891    .    mtctr   %r12
3892    .    bctr
3893
3894    In cases where the "addis" instruction would add zero, the "addis" is
3895    omitted and following instructions modified slightly in some cases.
3896 */
3897
3898 enum ppc_stub_type {
3899   ppc_stub_none,
3900   ppc_stub_long_branch,
3901   ppc_stub_long_branch_r2off,
3902   ppc_stub_plt_branch,
3903   ppc_stub_plt_branch_r2off,
3904   ppc_stub_plt_call,
3905   ppc_stub_plt_call_r2save,
3906   ppc_stub_global_entry,
3907   ppc_stub_save_res
3908 };
3909
3910 /* Information on stub grouping.  */
3911 struct map_stub
3912 {
3913   /* The stub section.  */
3914   asection *stub_sec;
3915   /* This is the section to which stubs in the group will be attached.  */
3916   asection *link_sec;
3917   /* Next group.  */
3918   struct map_stub *next;
3919   /* Whether to emit a copy of register save/restore functions in this
3920      group.  */
3921   int needs_save_res;
3922 };
3923
3924 struct ppc_stub_hash_entry {
3925
3926   /* Base hash table entry structure.  */
3927   struct bfd_hash_entry root;
3928
3929   enum ppc_stub_type stub_type;
3930
3931   /* Group information.  */
3932   struct map_stub *group;
3933
3934   /* Offset within stub_sec of the beginning of this stub.  */
3935   bfd_vma stub_offset;
3936
3937   /* Given the symbol's value and its section we can determine its final
3938      value when building the stubs (so the stub knows where to jump.  */
3939   bfd_vma target_value;
3940   asection *target_section;
3941
3942   /* The symbol table entry, if any, that this was derived from.  */
3943   struct ppc_link_hash_entry *h;
3944   struct plt_entry *plt_ent;
3945
3946   /* Symbol st_other.  */
3947   unsigned char other;
3948 };
3949
3950 struct ppc_branch_hash_entry {
3951
3952   /* Base hash table entry structure.  */
3953   struct bfd_hash_entry root;
3954
3955   /* Offset within branch lookup table.  */
3956   unsigned int offset;
3957
3958   /* Generation marker.  */
3959   unsigned int iter;
3960 };
3961
3962 /* Used to track dynamic relocations for local symbols.  */
3963 struct ppc_dyn_relocs
3964 {
3965   struct ppc_dyn_relocs *next;
3966
3967   /* The input section of the reloc.  */
3968   asection *sec;
3969
3970   /* Total number of relocs copied for the input section.  */
3971   unsigned int count : 31;
3972
3973   /* Whether this entry is for STT_GNU_IFUNC symbols.  */
3974   unsigned int ifunc : 1;
3975 };
3976
3977 struct ppc_link_hash_entry
3978 {
3979   struct elf_link_hash_entry elf;
3980
3981   union {
3982     /* A pointer to the most recently used stub hash entry against this
3983        symbol.  */
3984     struct ppc_stub_hash_entry *stub_cache;
3985
3986     /* A pointer to the next symbol starting with a '.'  */
3987     struct ppc_link_hash_entry *next_dot_sym;
3988   } u;
3989
3990   /* Track dynamic relocs copied for this symbol.  */
3991   struct elf_dyn_relocs *dyn_relocs;
3992
3993   /* Chain of aliases referring to a weakdef.  */
3994   struct ppc_link_hash_entry *weakref;
3995
3996   /* Link between function code and descriptor symbols.  */
3997   struct ppc_link_hash_entry *oh;
3998
3999   /* Flag function code and descriptor symbols.  */
4000   unsigned int is_func:1;
4001   unsigned int is_func_descriptor:1;
4002   unsigned int fake:1;
4003
4004   /* Whether global opd/toc sym has been adjusted or not.
4005      After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
4006      should be set for all globals defined in any opd/toc section.  */
4007   unsigned int adjust_done:1;
4008
4009   /* Set if this is an out-of-line register save/restore function,
4010      with non-standard calling convention.  */
4011   unsigned int save_res:1;
4012
4013   /* Contexts in which symbol is used in the GOT (or TOC).
4014      TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
4015      corresponding relocs are encountered during check_relocs.
4016      tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
4017      indicate the corresponding GOT entry type is not needed.
4018      tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
4019      a TPREL one.  We use a separate flag rather than setting TPREL
4020      just for convenience in distinguishing the two cases.  */
4021 #define TLS_GD           1      /* GD reloc. */
4022 #define TLS_LD           2      /* LD reloc. */
4023 #define TLS_TPREL        4      /* TPREL reloc, => IE. */
4024 #define TLS_DTPREL       8      /* DTPREL reloc, => LD. */
4025 #define TLS_TLS         16      /* Any TLS reloc.  */
4026 #define TLS_EXPLICIT    32      /* Marks TOC section TLS relocs. */
4027 #define TLS_TPRELGD     64      /* TPREL reloc resulting from GD->IE. */
4028 #define PLT_IFUNC      128      /* STT_GNU_IFUNC.  */
4029   unsigned char tls_mask;
4030 };
4031
4032 /* ppc64 ELF linker hash table.  */
4033
4034 struct ppc_link_hash_table
4035 {
4036   struct elf_link_hash_table elf;
4037
4038   /* The stub hash table.  */
4039   struct bfd_hash_table stub_hash_table;
4040
4041   /* Another hash table for plt_branch stubs.  */
4042   struct bfd_hash_table branch_hash_table;
4043
4044   /* Hash table for function prologue tocsave.  */
4045   htab_t tocsave_htab;
4046
4047   /* Various options and other info passed from the linker.  */
4048   struct ppc64_elf_params *params;
4049
4050   /* The size of sec_info below.  */
4051   unsigned int sec_info_arr_size;
4052
4053   /* Per-section array of extra section info.  Done this way rather
4054      than as part of ppc64_elf_section_data so we have the info for
4055      non-ppc64 sections.  */
4056   struct
4057   {
4058     /* Along with elf_gp, specifies the TOC pointer used by this section.  */
4059     bfd_vma toc_off;
4060
4061     union
4062     {
4063       /* The section group that this section belongs to.  */
4064       struct map_stub *group;
4065       /* A temp section list pointer.  */
4066       asection *list;
4067     } u;
4068   } *sec_info;
4069
4070   /* Linked list of groups.  */
4071   struct map_stub *group;
4072
4073   /* Temp used when calculating TOC pointers.  */
4074   bfd_vma toc_curr;
4075   bfd *toc_bfd;
4076   asection *toc_first_sec;
4077
4078   /* Used when adding symbols.  */
4079   struct ppc_link_hash_entry *dot_syms;
4080
4081   /* Shortcuts to get to dynamic linker sections.  */
4082   asection *glink;
4083   asection *sfpr;
4084   asection *brlt;
4085   asection *relbrlt;
4086   asection *glink_eh_frame;
4087
4088   /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
4089   struct ppc_link_hash_entry *tls_get_addr;
4090   struct ppc_link_hash_entry *tls_get_addr_fd;
4091
4092   /* The size of reliplt used by got entry relocs.  */
4093   bfd_size_type got_reli_size;
4094
4095   /* Statistics.  */
4096   unsigned long stub_count[ppc_stub_global_entry];
4097
4098   /* Number of stubs against global syms.  */
4099   unsigned long stub_globals;
4100
4101   /* Set if we're linking code with function descriptors.  */
4102   unsigned int opd_abi:1;
4103
4104   /* Support for multiple toc sections.  */
4105   unsigned int do_multi_toc:1;
4106   unsigned int multi_toc_needed:1;
4107   unsigned int second_toc_pass:1;
4108   unsigned int do_toc_opt:1;
4109
4110   /* Set on error.  */
4111   unsigned int stub_error:1;
4112
4113   /* Whether func_desc_adjust needs to be run over symbols.  */
4114   unsigned int need_func_desc_adj:1;
4115
4116   /* Whether there exist local gnu indirect function resolvers,
4117      referenced by dynamic relocations.  */
4118   unsigned int local_ifunc_resolver:1;
4119   unsigned int maybe_local_ifunc_resolver:1;
4120
4121   /* Whether plt calls for ELFv2 localentry:0 funcs have been optimized.  */
4122   unsigned int has_plt_localentry0:1;
4123
4124   /* Incremented every time we size stubs.  */
4125   unsigned int stub_iteration;
4126
4127   /* Small local sym cache.  */
4128   struct sym_cache sym_cache;
4129 };
4130
4131 /* Rename some of the generic section flags to better document how they
4132    are used here.  */
4133
4134 /* Nonzero if this section has TLS related relocations.  */
4135 #define has_tls_reloc sec_flg0
4136
4137 /* Nonzero if this section has a call to __tls_get_addr.  */
4138 #define has_tls_get_addr_call sec_flg1
4139
4140 /* Nonzero if this section has any toc or got relocs.  */
4141 #define has_toc_reloc sec_flg2
4142
4143 /* Nonzero if this section has a call to another section that uses
4144    the toc or got.  */
4145 #define makes_toc_func_call sec_flg3
4146
4147 /* Recursion protection when determining above flag.  */
4148 #define call_check_in_progress sec_flg4
4149 #define call_check_done sec_flg5
4150
4151 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
4152
4153 #define ppc_hash_table(p) \
4154   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
4155   == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
4156
4157 #define ppc_stub_hash_lookup(table, string, create, copy) \
4158   ((struct ppc_stub_hash_entry *) \
4159    bfd_hash_lookup ((table), (string), (create), (copy)))
4160
4161 #define ppc_branch_hash_lookup(table, string, create, copy) \
4162   ((struct ppc_branch_hash_entry *) \
4163    bfd_hash_lookup ((table), (string), (create), (copy)))
4164
4165 /* Create an entry in the stub hash table.  */
4166
4167 static struct bfd_hash_entry *
4168 stub_hash_newfunc (struct bfd_hash_entry *entry,
4169                    struct bfd_hash_table *table,
4170                    const char *string)
4171 {
4172   /* Allocate the structure if it has not already been allocated by a
4173      subclass.  */
4174   if (entry == NULL)
4175     {
4176       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4177       if (entry == NULL)
4178         return entry;
4179     }
4180
4181   /* Call the allocation method of the superclass.  */
4182   entry = bfd_hash_newfunc (entry, table, string);
4183   if (entry != NULL)
4184     {
4185       struct ppc_stub_hash_entry *eh;
4186
4187       /* Initialize the local fields.  */
4188       eh = (struct ppc_stub_hash_entry *) entry;
4189       eh->stub_type = ppc_stub_none;
4190       eh->group = NULL;
4191       eh->stub_offset = 0;
4192       eh->target_value = 0;
4193       eh->target_section = NULL;
4194       eh->h = NULL;
4195       eh->plt_ent = NULL;
4196       eh->other = 0;
4197     }
4198
4199   return entry;
4200 }
4201
4202 /* Create an entry in the branch hash table.  */
4203
4204 static struct bfd_hash_entry *
4205 branch_hash_newfunc (struct bfd_hash_entry *entry,
4206                      struct bfd_hash_table *table,
4207                      const char *string)
4208 {
4209   /* Allocate the structure if it has not already been allocated by a
4210      subclass.  */
4211   if (entry == NULL)
4212     {
4213       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4214       if (entry == NULL)
4215         return entry;
4216     }
4217
4218   /* Call the allocation method of the superclass.  */
4219   entry = bfd_hash_newfunc (entry, table, string);
4220   if (entry != NULL)
4221     {
4222       struct ppc_branch_hash_entry *eh;
4223
4224       /* Initialize the local fields.  */
4225       eh = (struct ppc_branch_hash_entry *) entry;
4226       eh->offset = 0;
4227       eh->iter = 0;
4228     }
4229
4230   return entry;
4231 }
4232
4233 /* Create an entry in a ppc64 ELF linker hash table.  */
4234
4235 static struct bfd_hash_entry *
4236 link_hash_newfunc (struct bfd_hash_entry *entry,
4237                    struct bfd_hash_table *table,
4238                    const char *string)
4239 {
4240   /* Allocate the structure if it has not already been allocated by a
4241      subclass.  */
4242   if (entry == NULL)
4243     {
4244       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4245       if (entry == NULL)
4246         return entry;
4247     }
4248
4249   /* Call the allocation method of the superclass.  */
4250   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4251   if (entry != NULL)
4252     {
4253       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4254
4255       memset (&eh->u.stub_cache, 0,
4256               (sizeof (struct ppc_link_hash_entry)
4257                - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4258
4259       /* When making function calls, old ABI code references function entry
4260          points (dot symbols), while new ABI code references the function
4261          descriptor symbol.  We need to make any combination of reference and
4262          definition work together, without breaking archive linking.
4263
4264          For a defined function "foo" and an undefined call to "bar":
4265          An old object defines "foo" and ".foo", references ".bar" (possibly
4266          "bar" too).
4267          A new object defines "foo" and references "bar".
4268
4269          A new object thus has no problem with its undefined symbols being
4270          satisfied by definitions in an old object.  On the other hand, the
4271          old object won't have ".bar" satisfied by a new object.
4272
4273          Keep a list of newly added dot-symbols.  */
4274
4275       if (string[0] == '.')
4276         {
4277           struct ppc_link_hash_table *htab;
4278
4279           htab = (struct ppc_link_hash_table *) table;
4280           eh->u.next_dot_sym = htab->dot_syms;
4281           htab->dot_syms = eh;
4282         }
4283     }
4284
4285   return entry;
4286 }
4287
4288 struct tocsave_entry {
4289   asection *sec;
4290   bfd_vma offset;
4291 };
4292
4293 static hashval_t
4294 tocsave_htab_hash (const void *p)
4295 {
4296   const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4297   return ((bfd_vma) (intptr_t) e->sec ^ e->offset) >> 3;
4298 }
4299
4300 static int
4301 tocsave_htab_eq (const void *p1, const void *p2)
4302 {
4303   const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4304   const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4305   return e1->sec == e2->sec && e1->offset == e2->offset;
4306 }
4307
4308 /* Destroy a ppc64 ELF linker hash table.  */
4309
4310 static void
4311 ppc64_elf_link_hash_table_free (bfd *obfd)
4312 {
4313   struct ppc_link_hash_table *htab;
4314
4315   htab = (struct ppc_link_hash_table *) obfd->link.hash;
4316   if (htab->tocsave_htab)
4317     htab_delete (htab->tocsave_htab);
4318   bfd_hash_table_free (&htab->branch_hash_table);
4319   bfd_hash_table_free (&htab->stub_hash_table);
4320   _bfd_elf_link_hash_table_free (obfd);
4321 }
4322
4323 /* Create a ppc64 ELF linker hash table.  */
4324
4325 static struct bfd_link_hash_table *
4326 ppc64_elf_link_hash_table_create (bfd *abfd)
4327 {
4328   struct ppc_link_hash_table *htab;
4329   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4330
4331   htab = bfd_zmalloc (amt);
4332   if (htab == NULL)
4333     return NULL;
4334
4335   if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4336                                       sizeof (struct ppc_link_hash_entry),
4337                                       PPC64_ELF_DATA))
4338     {
4339       free (htab);
4340       return NULL;
4341     }
4342
4343   /* Init the stub hash table too.  */
4344   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4345                             sizeof (struct ppc_stub_hash_entry)))
4346     {
4347       _bfd_elf_link_hash_table_free (abfd);
4348       return NULL;
4349     }
4350
4351   /* And the branch hash table.  */
4352   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4353                             sizeof (struct ppc_branch_hash_entry)))
4354     {
4355       bfd_hash_table_free (&htab->stub_hash_table);
4356       _bfd_elf_link_hash_table_free (abfd);
4357       return NULL;
4358     }
4359
4360   htab->tocsave_htab = htab_try_create (1024,
4361                                         tocsave_htab_hash,
4362                                         tocsave_htab_eq,
4363                                         NULL);
4364   if (htab->tocsave_htab == NULL)
4365     {
4366       ppc64_elf_link_hash_table_free (abfd);
4367       return NULL;
4368     }
4369   htab->elf.root.hash_table_free = ppc64_elf_link_hash_table_free;
4370
4371   /* Initializing two fields of the union is just cosmetic.  We really
4372      only care about glist, but when compiled on a 32-bit host the
4373      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
4374      debugger inspection of these fields look nicer.  */
4375   htab->elf.init_got_refcount.refcount = 0;
4376   htab->elf.init_got_refcount.glist = NULL;
4377   htab->elf.init_plt_refcount.refcount = 0;
4378   htab->elf.init_plt_refcount.glist = NULL;
4379   htab->elf.init_got_offset.offset = 0;
4380   htab->elf.init_got_offset.glist = NULL;
4381   htab->elf.init_plt_offset.offset = 0;
4382   htab->elf.init_plt_offset.glist = NULL;
4383
4384   return &htab->elf.root;
4385 }
4386
4387 /* Create sections for linker generated code.  */
4388
4389 static bfd_boolean
4390 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4391 {
4392   struct ppc_link_hash_table *htab;
4393   flagword flags;
4394
4395   htab = ppc_hash_table (info);
4396
4397   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4398            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4399   if (htab->params->save_restore_funcs)
4400     {
4401       /* Create .sfpr for code to save and restore fp regs.  */
4402       htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4403                                                        flags);
4404       if (htab->sfpr == NULL
4405           || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4406         return FALSE;
4407     }
4408
4409   if (bfd_link_relocatable (info))
4410     return TRUE;
4411
4412   /* Create .glink for lazy dynamic linking support.  */
4413   htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4414                                                     flags);
4415   if (htab->glink == NULL
4416       || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4417     return FALSE;
4418
4419   if (!info->no_ld_generated_unwind_info)
4420     {
4421       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4422                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4423       htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4424                                                                  ".eh_frame",
4425                                                                  flags);
4426       if (htab->glink_eh_frame == NULL
4427           || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4428         return FALSE;
4429     }
4430
4431   flags = SEC_ALLOC | SEC_LINKER_CREATED;
4432   htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4433   if (htab->elf.iplt == NULL
4434       || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4435     return FALSE;
4436
4437   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4438            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4439   htab->elf.irelplt
4440     = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4441   if (htab->elf.irelplt == NULL
4442       || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4443     return FALSE;
4444
4445   /* Create branch lookup table for plt_branch stubs.  */
4446   flags = (SEC_ALLOC | SEC_LOAD
4447            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4448   htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4449                                                    flags);
4450   if (htab->brlt == NULL
4451       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4452     return FALSE;
4453
4454   if (!bfd_link_pic (info))
4455     return TRUE;
4456
4457   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4458            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4459   htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4460                                                       ".rela.branch_lt",
4461                                                       flags);
4462   if (htab->relbrlt == NULL
4463       || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4464     return FALSE;
4465
4466   return TRUE;
4467 }
4468
4469 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
4470
4471 bfd_boolean
4472 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4473                          struct ppc64_elf_params *params)
4474 {
4475   struct ppc_link_hash_table *htab;
4476
4477   elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4478
4479 /* Always hook our dynamic sections into the first bfd, which is the
4480    linker created stub bfd.  This ensures that the GOT header is at
4481    the start of the output TOC section.  */
4482   htab = ppc_hash_table (info);
4483   htab->elf.dynobj = params->stub_bfd;
4484   htab->params = params;
4485
4486   return create_linkage_sections (htab->elf.dynobj, info);
4487 }
4488
4489 /* Build a name for an entry in the stub hash table.  */
4490
4491 static char *
4492 ppc_stub_name (const asection *input_section,
4493                const asection *sym_sec,
4494                const struct ppc_link_hash_entry *h,
4495                const Elf_Internal_Rela *rel)
4496 {
4497   char *stub_name;
4498   ssize_t len;
4499
4500   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4501      offsets from a sym as a branch target?  In fact, we could
4502      probably assume the addend is always zero.  */
4503   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4504
4505   if (h)
4506     {
4507       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4508       stub_name = bfd_malloc (len);
4509       if (stub_name == NULL)
4510         return stub_name;
4511
4512       len = sprintf (stub_name, "%08x.%s+%x",
4513                      input_section->id & 0xffffffff,
4514                      h->elf.root.root.string,
4515                      (int) rel->r_addend & 0xffffffff);
4516     }
4517   else
4518     {
4519       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4520       stub_name = bfd_malloc (len);
4521       if (stub_name == NULL)
4522         return stub_name;
4523
4524       len = sprintf (stub_name, "%08x.%x:%x+%x",
4525                      input_section->id & 0xffffffff,
4526                      sym_sec->id & 0xffffffff,
4527                      (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4528                      (int) rel->r_addend & 0xffffffff);
4529     }
4530   if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4531     stub_name[len - 2] = 0;
4532   return stub_name;
4533 }
4534
4535 /* Look up an entry in the stub hash.  Stub entries are cached because
4536    creating the stub name takes a bit of time.  */
4537
4538 static struct ppc_stub_hash_entry *
4539 ppc_get_stub_entry (const asection *input_section,
4540                     const asection *sym_sec,
4541                     struct ppc_link_hash_entry *h,
4542                     const Elf_Internal_Rela *rel,
4543                     struct ppc_link_hash_table *htab)
4544 {
4545   struct ppc_stub_hash_entry *stub_entry;
4546   struct map_stub *group;
4547
4548   /* If this input section is part of a group of sections sharing one
4549      stub section, then use the id of the first section in the group.
4550      Stub names need to include a section id, as there may well be
4551      more than one stub used to reach say, printf, and we need to
4552      distinguish between them.  */
4553   group = htab->sec_info[input_section->id].u.group;
4554   if (group == NULL)
4555     return NULL;
4556
4557   if (h != NULL && h->u.stub_cache != NULL
4558       && h->u.stub_cache->h == h
4559       && h->u.stub_cache->group == group)
4560     {
4561       stub_entry = h->u.stub_cache;
4562     }
4563   else
4564     {
4565       char *stub_name;
4566
4567       stub_name = ppc_stub_name (group->link_sec, sym_sec, h, rel);
4568       if (stub_name == NULL)
4569         return NULL;
4570
4571       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4572                                          stub_name, FALSE, FALSE);
4573       if (h != NULL)
4574         h->u.stub_cache = stub_entry;
4575
4576       free (stub_name);
4577     }
4578
4579   return stub_entry;
4580 }
4581
4582 /* Add a new stub entry to the stub hash.  Not all fields of the new
4583    stub entry are initialised.  */
4584
4585 static struct ppc_stub_hash_entry *
4586 ppc_add_stub (const char *stub_name,
4587               asection *section,
4588               struct bfd_link_info *info)
4589 {
4590   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4591   struct map_stub *group;
4592   asection *link_sec;
4593   asection *stub_sec;
4594   struct ppc_stub_hash_entry *stub_entry;
4595
4596   group = htab->sec_info[section->id].u.group;
4597   link_sec = group->link_sec;
4598   stub_sec = group->stub_sec;
4599   if (stub_sec == NULL)
4600     {
4601       size_t namelen;
4602       bfd_size_type len;
4603       char *s_name;
4604
4605       namelen = strlen (link_sec->name);
4606       len = namelen + sizeof (STUB_SUFFIX);
4607       s_name = bfd_alloc (htab->params->stub_bfd, len);
4608       if (s_name == NULL)
4609         return NULL;
4610
4611       memcpy (s_name, link_sec->name, namelen);
4612       memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4613       stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4614       if (stub_sec == NULL)
4615         return NULL;
4616       group->stub_sec = stub_sec;
4617     }
4618
4619   /* Enter this entry into the linker stub hash table.  */
4620   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4621                                      TRUE, FALSE);
4622   if (stub_entry == NULL)
4623     {
4624       /* xgettext:c-format */
4625       info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4626                               section->owner, stub_name);
4627       return NULL;
4628     }
4629
4630   stub_entry->group = group;
4631   stub_entry->stub_offset = 0;
4632   return stub_entry;
4633 }
4634
4635 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4636    not already done.  */
4637
4638 static bfd_boolean
4639 create_got_section (bfd *abfd, struct bfd_link_info *info)
4640 {
4641   asection *got, *relgot;
4642   flagword flags;
4643   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4644
4645   if (!is_ppc64_elf (abfd))
4646     return FALSE;
4647   if (htab == NULL)
4648     return FALSE;
4649
4650   if (!htab->elf.sgot
4651       && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4652     return FALSE;
4653
4654   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4655            | SEC_LINKER_CREATED);
4656
4657   got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4658   if (!got
4659       || !bfd_set_section_alignment (abfd, got, 3))
4660     return FALSE;
4661
4662   relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4663                                                flags | SEC_READONLY);
4664   if (!relgot
4665       || ! bfd_set_section_alignment (abfd, relgot, 3))
4666     return FALSE;
4667
4668   ppc64_elf_tdata (abfd)->got = got;
4669   ppc64_elf_tdata (abfd)->relgot = relgot;
4670   return TRUE;
4671 }
4672
4673 /* Follow indirect and warning symbol links.  */
4674
4675 static inline struct bfd_link_hash_entry *
4676 follow_link (struct bfd_link_hash_entry *h)
4677 {
4678   while (h->type == bfd_link_hash_indirect
4679          || h->type == bfd_link_hash_warning)
4680     h = h->u.i.link;
4681   return h;
4682 }
4683
4684 static inline struct elf_link_hash_entry *
4685 elf_follow_link (struct elf_link_hash_entry *h)
4686 {
4687   return (struct elf_link_hash_entry *) follow_link (&h->root);
4688 }
4689
4690 static inline struct ppc_link_hash_entry *
4691 ppc_follow_link (struct ppc_link_hash_entry *h)
4692 {
4693   return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4694 }
4695
4696 /* Merge PLT info on FROM with that on TO.  */
4697
4698 static void
4699 move_plt_plist (struct ppc_link_hash_entry *from,
4700                 struct ppc_link_hash_entry *to)
4701 {
4702   if (from->elf.plt.plist != NULL)
4703     {
4704       if (to->elf.plt.plist != NULL)
4705         {
4706           struct plt_entry **entp;
4707           struct plt_entry *ent;
4708
4709           for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4710             {
4711               struct plt_entry *dent;
4712
4713               for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4714                 if (dent->addend == ent->addend)
4715                   {
4716                     dent->plt.refcount += ent->plt.refcount;
4717                     *entp = ent->next;
4718                     break;
4719                   }
4720               if (dent == NULL)
4721                 entp = &ent->next;
4722             }
4723           *entp = to->elf.plt.plist;
4724         }
4725
4726       to->elf.plt.plist = from->elf.plt.plist;
4727       from->elf.plt.plist = NULL;
4728     }
4729 }
4730
4731 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
4732
4733 static void
4734 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4735                                 struct elf_link_hash_entry *dir,
4736                                 struct elf_link_hash_entry *ind)
4737 {
4738   struct ppc_link_hash_entry *edir, *eind;
4739
4740   edir = (struct ppc_link_hash_entry *) dir;
4741   eind = (struct ppc_link_hash_entry *) ind;
4742
4743   edir->is_func |= eind->is_func;
4744   edir->is_func_descriptor |= eind->is_func_descriptor;
4745   edir->tls_mask |= eind->tls_mask;
4746   if (eind->oh != NULL)
4747     edir->oh = ppc_follow_link (eind->oh);
4748
4749   /* If called to transfer flags for a weakdef during processing
4750      of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4751      We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
4752   if (!(ELIMINATE_COPY_RELOCS
4753         && eind->elf.root.type != bfd_link_hash_indirect
4754         && edir->elf.dynamic_adjusted))
4755     edir->elf.non_got_ref |= eind->elf.non_got_ref;
4756
4757   if (edir->elf.versioned != versioned_hidden)
4758     edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4759   edir->elf.ref_regular |= eind->elf.ref_regular;
4760   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4761   edir->elf.needs_plt |= eind->elf.needs_plt;
4762   edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4763
4764   /* If we were called to copy over info for a weak sym, don't copy
4765      dyn_relocs, plt/got info, or dynindx.  We used to copy dyn_relocs
4766      in order to simplify readonly_dynrelocs and save a field in the
4767      symbol hash entry, but that means dyn_relocs can't be used in any
4768      tests about a specific symbol, or affect other symbol flags which
4769      are then tested.
4770      Chain weakdefs so we can get from the weakdef back to an alias.
4771      The list is circular so that we don't need to use u.weakdef as
4772      well as this list to look at all aliases.  */
4773   if (eind->elf.root.type != bfd_link_hash_indirect)
4774     {
4775       struct ppc_link_hash_entry *cur, *add, *next;
4776
4777       add = eind;
4778       do
4779         {
4780           cur = edir->weakref;
4781           if (cur != NULL)
4782             {
4783               do
4784                 {
4785                   /* We can be called twice for the same symbols.
4786                      Don't make multiple loops.  */
4787                   if (cur == add)
4788                     return;
4789                   cur = cur->weakref;
4790                 } while (cur != edir);
4791             }
4792           next = add->weakref;
4793           if (cur != add)
4794             {
4795               add->weakref = edir->weakref != NULL ? edir->weakref : edir;
4796               edir->weakref = add;
4797             }
4798           add = next;
4799         } while (add != NULL && add != eind);
4800       return;
4801     }
4802
4803   /* Copy over any dynamic relocs we may have on the indirect sym.  */
4804   if (eind->dyn_relocs != NULL)
4805     {
4806       if (edir->dyn_relocs != NULL)
4807         {
4808           struct elf_dyn_relocs **pp;
4809           struct elf_dyn_relocs *p;
4810
4811           /* Add reloc counts against the indirect sym to the direct sym
4812              list.  Merge any entries against the same section.  */
4813           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4814             {
4815               struct elf_dyn_relocs *q;
4816
4817               for (q = edir->dyn_relocs; q != NULL; q = q->next)
4818                 if (q->sec == p->sec)
4819                   {
4820                     q->pc_count += p->pc_count;
4821                     q->count += p->count;
4822                     *pp = p->next;
4823                     break;
4824                   }
4825               if (q == NULL)
4826                 pp = &p->next;
4827             }
4828           *pp = edir->dyn_relocs;
4829         }
4830
4831       edir->dyn_relocs = eind->dyn_relocs;
4832       eind->dyn_relocs = NULL;
4833     }
4834
4835   /* Copy over got entries that we may have already seen to the
4836      symbol which just became indirect.  */
4837   if (eind->elf.got.glist != NULL)
4838     {
4839       if (edir->elf.got.glist != NULL)
4840         {
4841           struct got_entry **entp;
4842           struct got_entry *ent;
4843
4844           for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4845             {
4846               struct got_entry *dent;
4847
4848               for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4849                 if (dent->addend == ent->addend
4850                     && dent->owner == ent->owner
4851                     && dent->tls_type == ent->tls_type)
4852                   {
4853                     dent->got.refcount += ent->got.refcount;
4854                     *entp = ent->next;
4855                     break;
4856                   }
4857               if (dent == NULL)
4858                 entp = &ent->next;
4859             }
4860           *entp = edir->elf.got.glist;
4861         }
4862
4863       edir->elf.got.glist = eind->elf.got.glist;
4864       eind->elf.got.glist = NULL;
4865     }
4866
4867   /* And plt entries.  */
4868   move_plt_plist (eind, edir);
4869
4870   if (eind->elf.dynindx != -1)
4871     {
4872       if (edir->elf.dynindx != -1)
4873         _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4874                                 edir->elf.dynstr_index);
4875       edir->elf.dynindx = eind->elf.dynindx;
4876       edir->elf.dynstr_index = eind->elf.dynstr_index;
4877       eind->elf.dynindx = -1;
4878       eind->elf.dynstr_index = 0;
4879     }
4880 }
4881
4882 /* Find the function descriptor hash entry from the given function code
4883    hash entry FH.  Link the entries via their OH fields.  */
4884
4885 static struct ppc_link_hash_entry *
4886 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4887 {
4888   struct ppc_link_hash_entry *fdh = fh->oh;
4889
4890   if (fdh == NULL)
4891     {
4892       const char *fd_name = fh->elf.root.root.string + 1;
4893
4894       fdh = (struct ppc_link_hash_entry *)
4895         elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4896       if (fdh == NULL)
4897         return fdh;
4898
4899       fdh->is_func_descriptor = 1;
4900       fdh->oh = fh;
4901       fh->is_func = 1;
4902       fh->oh = fdh;
4903     }
4904
4905   fdh = ppc_follow_link (fdh);
4906   fdh->is_func_descriptor = 1;
4907   fdh->oh = fh;
4908   return fdh;
4909 }
4910
4911 /* Make a fake function descriptor sym for the undefined code sym FH.  */
4912
4913 static struct ppc_link_hash_entry *
4914 make_fdh (struct bfd_link_info *info,
4915           struct ppc_link_hash_entry *fh)
4916 {
4917   bfd *abfd = fh->elf.root.u.undef.abfd;
4918   struct bfd_link_hash_entry *bh = NULL;
4919   struct ppc_link_hash_entry *fdh;
4920   flagword flags = (fh->elf.root.type == bfd_link_hash_undefweak
4921                     ? BSF_WEAK
4922                     : BSF_GLOBAL);
4923
4924   if (!_bfd_generic_link_add_one_symbol (info, abfd,
4925                                          fh->elf.root.root.string + 1,
4926                                          flags, bfd_und_section_ptr, 0,
4927                                          NULL, FALSE, FALSE, &bh))
4928     return NULL;
4929
4930   fdh = (struct ppc_link_hash_entry *) bh;
4931   fdh->elf.non_elf = 0;
4932   fdh->fake = 1;
4933   fdh->is_func_descriptor = 1;
4934   fdh->oh = fh;
4935   fh->is_func = 1;
4936   fh->oh = fdh;
4937   return fdh;
4938 }
4939
4940 /* Fix function descriptor symbols defined in .opd sections to be
4941    function type.  */
4942
4943 static bfd_boolean
4944 ppc64_elf_add_symbol_hook (bfd *ibfd,
4945                            struct bfd_link_info *info,
4946                            Elf_Internal_Sym *isym,
4947                            const char **name,
4948                            flagword *flags ATTRIBUTE_UNUSED,
4949                            asection **sec,
4950                            bfd_vma *value)
4951 {
4952   if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4953       && (ibfd->flags & DYNAMIC) == 0
4954       && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
4955     elf_tdata (info->output_bfd)->has_gnu_symbols |= elf_gnu_symbol_ifunc;
4956
4957   if (*sec != NULL
4958       && strcmp ((*sec)->name, ".opd") == 0)
4959     {
4960       asection *code_sec;
4961
4962       if (!(ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4963             || ELF_ST_TYPE (isym->st_info) == STT_FUNC))
4964         isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4965
4966       /* If the symbol is a function defined in .opd, and the function
4967          code is in a discarded group, let it appear to be undefined.  */
4968       if (!bfd_link_relocatable (info)
4969           && (*sec)->reloc_count != 0
4970           && opd_entry_value (*sec, *value, &code_sec, NULL,
4971                               FALSE) != (bfd_vma) -1
4972           && discarded_section (code_sec))
4973         {
4974           *sec = bfd_und_section_ptr;
4975           isym->st_shndx = SHN_UNDEF;
4976         }
4977     }
4978   else if (*sec != NULL
4979            && strcmp ((*sec)->name, ".toc") == 0
4980            && ELF_ST_TYPE (isym->st_info) == STT_OBJECT)
4981     {
4982       struct ppc_link_hash_table *htab = ppc_hash_table (info);
4983       if (htab != NULL)
4984         htab->params->object_in_toc = 1;
4985     }
4986
4987   if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4988     {
4989       if (abiversion (ibfd) == 0)
4990         set_abiversion (ibfd, 2);
4991       else if (abiversion (ibfd) == 1)
4992         {
4993           info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other"
4994                                     " for ABI version 1\n"), name);
4995           bfd_set_error (bfd_error_bad_value);
4996           return FALSE;
4997         }
4998     }
4999
5000   return TRUE;
5001 }
5002
5003 /* Merge non-visibility st_other attributes: local entry point.  */
5004
5005 static void
5006 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
5007                                   const Elf_Internal_Sym *isym,
5008                                   bfd_boolean definition,
5009                                   bfd_boolean dynamic)
5010 {
5011   if (definition && (!dynamic || !h->def_regular))
5012     h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
5013                 | ELF_ST_VISIBILITY (h->other));
5014 }
5015
5016 /* Hook called on merging a symbol.  We use this to clear "fake" since
5017    we now have a real symbol.  */
5018
5019 static bfd_boolean
5020 ppc64_elf_merge_symbol (struct elf_link_hash_entry *h,
5021                         const Elf_Internal_Sym *isym ATTRIBUTE_UNUSED,
5022                         asection **psec ATTRIBUTE_UNUSED,
5023                         bfd_boolean newdef ATTRIBUTE_UNUSED,
5024                         bfd_boolean olddef ATTRIBUTE_UNUSED,
5025                         bfd *oldbfd ATTRIBUTE_UNUSED,
5026                         const asection *oldsec ATTRIBUTE_UNUSED)
5027 {
5028   ((struct ppc_link_hash_entry *) h)->fake = 0;
5029   return TRUE;
5030 }
5031
5032 /* This function makes an old ABI object reference to ".bar" cause the
5033    inclusion of a new ABI object archive that defines "bar".
5034    NAME is a symbol defined in an archive.  Return a symbol in the hash
5035    table that might be satisfied by the archive symbols.  */
5036
5037 static struct elf_link_hash_entry *
5038 ppc64_elf_archive_symbol_lookup (bfd *abfd,
5039                                  struct bfd_link_info *info,
5040                                  const char *name)
5041 {
5042   struct elf_link_hash_entry *h;
5043   char *dot_name;
5044   size_t len;
5045
5046   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
5047   if (h != NULL
5048       /* Don't return this sym if it is a fake function descriptor
5049          created by add_symbol_adjust.  */
5050       && !((struct ppc_link_hash_entry *) h)->fake)
5051     return h;
5052
5053   if (name[0] == '.')
5054     return h;
5055
5056   len = strlen (name);
5057   dot_name = bfd_alloc (abfd, len + 2);
5058   if (dot_name == NULL)
5059     return (struct elf_link_hash_entry *) 0 - 1;
5060   dot_name[0] = '.';
5061   memcpy (dot_name + 1, name, len + 1);
5062   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
5063   bfd_release (abfd, dot_name);
5064   return h;
5065 }
5066
5067 /* This function satisfies all old ABI object references to ".bar" if a
5068    new ABI object defines "bar".  Well, at least, undefined dot symbols
5069    are made weak.  This stops later archive searches from including an
5070    object if we already have a function descriptor definition.  It also
5071    prevents the linker complaining about undefined symbols.
5072    We also check and correct mismatched symbol visibility here.  The
5073    most restrictive visibility of the function descriptor and the
5074    function entry symbol is used.  */
5075
5076 static bfd_boolean
5077 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
5078 {
5079   struct ppc_link_hash_table *htab;
5080   struct ppc_link_hash_entry *fdh;
5081
5082   if (eh->elf.root.type == bfd_link_hash_warning)
5083     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
5084
5085   if (eh->elf.root.type == bfd_link_hash_indirect)
5086     return TRUE;
5087
5088   if (eh->elf.root.root.string[0] != '.')
5089     abort ();
5090
5091   htab = ppc_hash_table (info);
5092   if (htab == NULL)
5093     return FALSE;
5094
5095   fdh = lookup_fdh (eh, htab);
5096   if (fdh == NULL
5097       && !bfd_link_relocatable (info)
5098       && (eh->elf.root.type == bfd_link_hash_undefined
5099           || eh->elf.root.type == bfd_link_hash_undefweak)
5100       && eh->elf.ref_regular)
5101     {
5102       /* Make an undefined function descriptor sym, in order to
5103          pull in an --as-needed shared lib.  Archives are handled
5104          elsewhere.  */
5105       fdh = make_fdh (info, eh);
5106       if (fdh == NULL)
5107         return FALSE;
5108     }
5109
5110   if (fdh != NULL)
5111     {
5112       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
5113       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
5114
5115       /* Make both descriptor and entry symbol have the most
5116          constraining visibility of either symbol.  */
5117       if (entry_vis < descr_vis)
5118         fdh->elf.other += entry_vis - descr_vis;
5119       else if (entry_vis > descr_vis)
5120         eh->elf.other += descr_vis - entry_vis;
5121
5122       /* Propagate reference flags from entry symbol to function
5123          descriptor symbol.  */
5124       fdh->elf.root.non_ir_ref_regular |= eh->elf.root.non_ir_ref_regular;
5125       fdh->elf.root.non_ir_ref_dynamic |= eh->elf.root.non_ir_ref_dynamic;
5126       fdh->elf.ref_regular |= eh->elf.ref_regular;
5127       fdh->elf.ref_regular_nonweak |= eh->elf.ref_regular_nonweak;
5128
5129       if (!fdh->elf.forced_local
5130           && fdh->elf.dynindx == -1
5131           && fdh->elf.versioned != versioned_hidden
5132           && (bfd_link_dll (info)
5133               || fdh->elf.def_dynamic
5134               || fdh->elf.ref_dynamic)
5135           && (eh->elf.ref_regular
5136               || eh->elf.def_regular))
5137         {
5138           if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
5139             return FALSE;
5140         }
5141     }
5142
5143   return TRUE;
5144 }
5145
5146 /* Set up opd section info and abiversion for IBFD, and process list
5147    of dot-symbols we made in link_hash_newfunc.  */
5148
5149 static bfd_boolean
5150 ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
5151 {
5152   struct ppc_link_hash_table *htab;
5153   struct ppc_link_hash_entry **p, *eh;
5154   asection *opd = bfd_get_section_by_name (ibfd, ".opd");
5155
5156   if (opd != NULL && opd->size != 0)
5157     {
5158       if (abiversion (ibfd) == 0)
5159         set_abiversion (ibfd, 1);
5160       else if (abiversion (ibfd) >= 2)
5161         {
5162           /* xgettext:c-format */
5163           info->callbacks->einfo (_("%P: %B .opd not allowed in ABI"
5164                                     " version %d\n"),
5165                                   ibfd, abiversion (ibfd));
5166           bfd_set_error (bfd_error_bad_value);
5167           return FALSE;
5168         }
5169
5170       if ((ibfd->flags & DYNAMIC) == 0
5171           && (opd->flags & SEC_RELOC) != 0
5172           && opd->reloc_count != 0
5173           && !bfd_is_abs_section (opd->output_section))
5174         {
5175           /* Garbage collection needs some extra help with .opd sections.
5176              We don't want to necessarily keep everything referenced by
5177              relocs in .opd, as that would keep all functions.  Instead,
5178              if we reference an .opd symbol (a function descriptor), we
5179              want to keep the function code symbol's section.  This is
5180              easy for global symbols, but for local syms we need to keep
5181              information about the associated function section.  */
5182           bfd_size_type amt;
5183           asection **opd_sym_map;
5184
5185           amt = OPD_NDX (opd->size) * sizeof (*opd_sym_map);
5186           opd_sym_map = bfd_zalloc (ibfd, amt);
5187           if (opd_sym_map == NULL)
5188             return FALSE;
5189           ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
5190           BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
5191           ppc64_elf_section_data (opd)->sec_type = sec_opd;
5192         }
5193     }
5194
5195   if (!is_ppc64_elf (info->output_bfd))
5196     return TRUE;
5197   htab = ppc_hash_table (info);
5198   if (htab == NULL)
5199     return FALSE;
5200
5201   /* For input files without an explicit abiversion in e_flags
5202      we should have flagged any with symbol st_other bits set
5203      as ELFv1 and above flagged those with .opd as ELFv2.
5204      Set the output abiversion if not yet set, and for any input
5205      still ambiguous, take its abiversion from the output.
5206      Differences in ABI are reported later.  */
5207   if (abiversion (info->output_bfd) == 0)
5208     set_abiversion (info->output_bfd, abiversion (ibfd));
5209   else if (abiversion (ibfd) == 0)
5210     set_abiversion (ibfd, abiversion (info->output_bfd));
5211
5212   p = &htab->dot_syms;
5213   while ((eh = *p) != NULL)
5214     {
5215       *p = NULL;
5216       if (&eh->elf == htab->elf.hgot)
5217         ;
5218       else if (htab->elf.hgot == NULL
5219                && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
5220         htab->elf.hgot = &eh->elf;
5221       else if (abiversion (ibfd) <= 1)
5222         {
5223           htab->need_func_desc_adj = 1;
5224           if (!add_symbol_adjust (eh, info))
5225             return FALSE;
5226         }
5227       p = &eh->u.next_dot_sym;
5228     }
5229   return TRUE;
5230 }
5231
5232 /* Undo hash table changes when an --as-needed input file is determined
5233    not to be needed.  */
5234
5235 static bfd_boolean
5236 ppc64_elf_notice_as_needed (bfd *ibfd,
5237                             struct bfd_link_info *info,
5238                             enum notice_asneeded_action act)
5239 {
5240   if (act == notice_not_needed)
5241     {
5242       struct ppc_link_hash_table *htab = ppc_hash_table (info);
5243
5244       if (htab == NULL)
5245         return FALSE;
5246
5247       htab->dot_syms = NULL;
5248     }
5249   return _bfd_elf_notice_as_needed (ibfd, info, act);
5250 }
5251
5252 /* If --just-symbols against a final linked binary, then assume we need
5253    toc adjusting stubs when calling functions defined there.  */
5254
5255 static void
5256 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5257 {
5258   if ((sec->flags & SEC_CODE) != 0
5259       && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5260       && is_ppc64_elf (sec->owner))
5261     {
5262       if (abiversion (sec->owner) >= 2
5263           || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5264         sec->has_toc_reloc = 1;
5265     }
5266   _bfd_elf_link_just_syms (sec, info);
5267 }
5268
5269 static struct plt_entry **
5270 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5271                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5272 {
5273   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5274   struct plt_entry **local_plt;
5275   unsigned char *local_got_tls_masks;
5276
5277   if (local_got_ents == NULL)
5278     {
5279       bfd_size_type size = symtab_hdr->sh_info;
5280
5281       size *= (sizeof (*local_got_ents)
5282                + sizeof (*local_plt)
5283                + sizeof (*local_got_tls_masks));
5284       local_got_ents = bfd_zalloc (abfd, size);
5285       if (local_got_ents == NULL)
5286         return NULL;
5287       elf_local_got_ents (abfd) = local_got_ents;
5288     }
5289
5290   if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
5291     {
5292       struct got_entry *ent;
5293
5294       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5295         if (ent->addend == r_addend
5296             && ent->owner == abfd
5297             && ent->tls_type == tls_type)
5298           break;
5299       if (ent == NULL)
5300         {
5301           bfd_size_type amt = sizeof (*ent);
5302           ent = bfd_alloc (abfd, amt);
5303           if (ent == NULL)
5304             return FALSE;
5305           ent->next = local_got_ents[r_symndx];
5306           ent->addend = r_addend;
5307           ent->owner = abfd;
5308           ent->tls_type = tls_type;
5309           ent->is_indirect = FALSE;
5310           ent->got.refcount = 0;
5311           local_got_ents[r_symndx] = ent;
5312         }
5313       ent->got.refcount += 1;
5314     }
5315
5316   local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5317   local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5318   local_got_tls_masks[r_symndx] |= tls_type;
5319
5320   return local_plt + r_symndx;
5321 }
5322
5323 static bfd_boolean
5324 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5325 {
5326   struct plt_entry *ent;
5327
5328   for (ent = *plist; ent != NULL; ent = ent->next)
5329     if (ent->addend == addend)
5330       break;
5331   if (ent == NULL)
5332     {
5333       bfd_size_type amt = sizeof (*ent);
5334       ent = bfd_alloc (abfd, amt);
5335       if (ent == NULL)
5336         return FALSE;
5337       ent->next = *plist;
5338       ent->addend = addend;
5339       ent->plt.refcount = 0;
5340       *plist = ent;
5341     }
5342   ent->plt.refcount += 1;
5343   return TRUE;
5344 }
5345
5346 static bfd_boolean
5347 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5348 {
5349   return (r_type == R_PPC64_REL24
5350           || r_type == R_PPC64_REL14
5351           || r_type == R_PPC64_REL14_BRTAKEN
5352           || r_type == R_PPC64_REL14_BRNTAKEN
5353           || r_type == R_PPC64_ADDR24
5354           || r_type == R_PPC64_ADDR14
5355           || r_type == R_PPC64_ADDR14_BRTAKEN
5356           || r_type == R_PPC64_ADDR14_BRNTAKEN);
5357 }
5358
5359 /* Look through the relocs for a section during the first phase, and
5360    calculate needed space in the global offset table, procedure
5361    linkage table, and dynamic reloc sections.  */
5362
5363 static bfd_boolean
5364 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5365                         asection *sec, const Elf_Internal_Rela *relocs)
5366 {
5367   struct ppc_link_hash_table *htab;
5368   Elf_Internal_Shdr *symtab_hdr;
5369   struct elf_link_hash_entry **sym_hashes;
5370   const Elf_Internal_Rela *rel;
5371   const Elf_Internal_Rela *rel_end;
5372   asection *sreloc;
5373   asection **opd_sym_map;
5374   struct elf_link_hash_entry *tga, *dottga;
5375
5376   if (bfd_link_relocatable (info))
5377     return TRUE;
5378
5379   /* Don't do anything special with non-loaded, non-alloced sections.
5380      In particular, any relocs in such sections should not affect GOT
5381      and PLT reference counting (ie. we don't allow them to create GOT
5382      or PLT entries), there's no possibility or desire to optimize TLS
5383      relocs, and there's not much point in propagating relocs to shared
5384      libs that the dynamic linker won't relocate.  */
5385   if ((sec->flags & SEC_ALLOC) == 0)
5386     return TRUE;
5387
5388   BFD_ASSERT (is_ppc64_elf (abfd));
5389
5390   htab = ppc_hash_table (info);
5391   if (htab == NULL)
5392     return FALSE;
5393
5394   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5395                               FALSE, FALSE, TRUE);
5396   dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5397                                  FALSE, FALSE, TRUE);
5398   symtab_hdr = &elf_symtab_hdr (abfd);
5399   sym_hashes = elf_sym_hashes (abfd);
5400   sreloc = NULL;
5401   opd_sym_map = NULL;
5402   if (ppc64_elf_section_data (sec) != NULL
5403       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
5404     opd_sym_map = ppc64_elf_section_data (sec)->u.opd.func_sec;
5405
5406   rel_end = relocs + sec->reloc_count;
5407   for (rel = relocs; rel < rel_end; rel++)
5408     {
5409       unsigned long r_symndx;
5410       struct elf_link_hash_entry *h;
5411       enum elf_ppc64_reloc_type r_type;
5412       int tls_type;
5413       struct _ppc64_elf_section_data *ppc64_sec;
5414       struct plt_entry **ifunc, **plt_list;
5415
5416       r_symndx = ELF64_R_SYM (rel->r_info);
5417       if (r_symndx < symtab_hdr->sh_info)
5418         h = NULL;
5419       else
5420         {
5421           struct ppc_link_hash_entry *eh;
5422
5423           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5424           h = elf_follow_link (h);
5425           eh = (struct ppc_link_hash_entry *) h;
5426
5427           /* PR15323, ref flags aren't set for references in the same
5428              object.  */
5429           h->root.non_ir_ref_regular = 1;
5430           if (eh->is_func && eh->oh != NULL)
5431             eh->oh->elf.root.non_ir_ref_regular = 1;
5432
5433           if (h == htab->elf.hgot)
5434             sec->has_toc_reloc = 1;
5435         }
5436
5437       tls_type = 0;
5438       ifunc = NULL;
5439       if (h != NULL)
5440         {
5441           if (h->type == STT_GNU_IFUNC)
5442             {
5443               h->needs_plt = 1;
5444               ifunc = &h->plt.plist;
5445             }
5446         }
5447       else
5448         {
5449           Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5450                                                           abfd, r_symndx);
5451           if (isym == NULL)
5452             return FALSE;
5453
5454           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5455             {
5456               ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5457                                              rel->r_addend, PLT_IFUNC);
5458               if (ifunc == NULL)
5459                 return FALSE;
5460             }
5461         }
5462
5463       r_type = ELF64_R_TYPE (rel->r_info);
5464       switch (r_type)
5465         {
5466         case R_PPC64_TLSGD:
5467         case R_PPC64_TLSLD:
5468           /* These special tls relocs tie a call to __tls_get_addr with
5469              its parameter symbol.  */
5470           break;
5471
5472         case R_PPC64_GOT_TLSLD16:
5473         case R_PPC64_GOT_TLSLD16_LO:
5474         case R_PPC64_GOT_TLSLD16_HI:
5475         case R_PPC64_GOT_TLSLD16_HA:
5476           tls_type = TLS_TLS | TLS_LD;
5477           goto dogottls;
5478
5479         case R_PPC64_GOT_TLSGD16:
5480         case R_PPC64_GOT_TLSGD16_LO:
5481         case R_PPC64_GOT_TLSGD16_HI:
5482         case R_PPC64_GOT_TLSGD16_HA:
5483           tls_type = TLS_TLS | TLS_GD;
5484           goto dogottls;
5485
5486         case R_PPC64_GOT_TPREL16_DS:
5487         case R_PPC64_GOT_TPREL16_LO_DS:
5488         case R_PPC64_GOT_TPREL16_HI:
5489         case R_PPC64_GOT_TPREL16_HA:
5490           if (bfd_link_pic (info))
5491             info->flags |= DF_STATIC_TLS;
5492           tls_type = TLS_TLS | TLS_TPREL;
5493           goto dogottls;
5494
5495         case R_PPC64_GOT_DTPREL16_DS:
5496         case R_PPC64_GOT_DTPREL16_LO_DS:
5497         case R_PPC64_GOT_DTPREL16_HI:
5498         case R_PPC64_GOT_DTPREL16_HA:
5499           tls_type = TLS_TLS | TLS_DTPREL;
5500         dogottls:
5501           sec->has_tls_reloc = 1;
5502           /* Fall through */
5503
5504         case R_PPC64_GOT16:
5505         case R_PPC64_GOT16_DS:
5506         case R_PPC64_GOT16_HA:
5507         case R_PPC64_GOT16_HI:
5508         case R_PPC64_GOT16_LO:
5509         case R_PPC64_GOT16_LO_DS:
5510           /* This symbol requires a global offset table entry.  */
5511           sec->has_toc_reloc = 1;
5512           if (r_type == R_PPC64_GOT_TLSLD16
5513               || r_type == R_PPC64_GOT_TLSGD16
5514               || r_type == R_PPC64_GOT_TPREL16_DS
5515               || r_type == R_PPC64_GOT_DTPREL16_DS
5516               || r_type == R_PPC64_GOT16
5517               || r_type == R_PPC64_GOT16_DS)
5518             {
5519               htab->do_multi_toc = 1;
5520               ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5521             }
5522
5523           if (ppc64_elf_tdata (abfd)->got == NULL
5524               && !create_got_section (abfd, info))
5525             return FALSE;
5526
5527           if (h != NULL)
5528             {
5529               struct ppc_link_hash_entry *eh;
5530               struct got_entry *ent;
5531
5532               eh = (struct ppc_link_hash_entry *) h;
5533               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5534                 if (ent->addend == rel->r_addend
5535                     && ent->owner == abfd
5536                     && ent->tls_type == tls_type)
5537                   break;
5538               if (ent == NULL)
5539                 {
5540                   bfd_size_type amt = sizeof (*ent);
5541                   ent = bfd_alloc (abfd, amt);
5542                   if (ent == NULL)
5543                     return FALSE;
5544                   ent->next = eh->elf.got.glist;
5545                   ent->addend = rel->r_addend;
5546                   ent->owner = abfd;
5547                   ent->tls_type = tls_type;
5548                   ent->is_indirect = FALSE;
5549                   ent->got.refcount = 0;
5550                   eh->elf.got.glist = ent;
5551                 }
5552               ent->got.refcount += 1;
5553               eh->tls_mask |= tls_type;
5554             }
5555           else
5556             /* This is a global offset table entry for a local symbol.  */
5557             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5558                                         rel->r_addend, tls_type))
5559               return FALSE;
5560
5561           /* We may also need a plt entry if the symbol turns out to be
5562              an ifunc.  */
5563           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1)
5564             {
5565               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5566                 return FALSE;
5567             }
5568           break;
5569
5570         case R_PPC64_PLT16_HA:
5571         case R_PPC64_PLT16_HI:
5572         case R_PPC64_PLT16_LO:
5573         case R_PPC64_PLT32:
5574         case R_PPC64_PLT64:
5575           /* This symbol requires a procedure linkage table entry.  */
5576           plt_list = ifunc;
5577           if (h != NULL)
5578             {
5579               h->needs_plt = 1;
5580               if (h->root.root.string[0] == '.'
5581                   && h->root.root.string[1] != '\0')
5582                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5583               plt_list = &h->plt.plist;
5584             }
5585           if (plt_list == NULL)
5586             {
5587               /* It does not make sense to have a procedure linkage
5588                  table entry for a non-ifunc local symbol.  */
5589               info->callbacks->einfo
5590                 /* xgettext:c-format */
5591                 (_("%H: %s reloc against local symbol\n"),
5592                  abfd, sec, rel->r_offset,
5593                  ppc64_elf_howto_table[r_type]->name);
5594               bfd_set_error (bfd_error_bad_value);
5595               return FALSE;
5596             }
5597           if (!update_plt_info (abfd, plt_list, rel->r_addend))
5598             return FALSE;
5599           break;
5600
5601           /* The following relocations don't need to propagate the
5602              relocation if linking a shared object since they are
5603              section relative.  */
5604         case R_PPC64_SECTOFF:
5605         case R_PPC64_SECTOFF_LO:
5606         case R_PPC64_SECTOFF_HI:
5607         case R_PPC64_SECTOFF_HA:
5608         case R_PPC64_SECTOFF_DS:
5609         case R_PPC64_SECTOFF_LO_DS:
5610         case R_PPC64_DTPREL16:
5611         case R_PPC64_DTPREL16_LO:
5612         case R_PPC64_DTPREL16_HI:
5613         case R_PPC64_DTPREL16_HA:
5614         case R_PPC64_DTPREL16_DS:
5615         case R_PPC64_DTPREL16_LO_DS:
5616         case R_PPC64_DTPREL16_HIGH:
5617         case R_PPC64_DTPREL16_HIGHA:
5618         case R_PPC64_DTPREL16_HIGHER:
5619         case R_PPC64_DTPREL16_HIGHERA:
5620         case R_PPC64_DTPREL16_HIGHEST:
5621         case R_PPC64_DTPREL16_HIGHESTA:
5622           break;
5623
5624           /* Nor do these.  */
5625         case R_PPC64_REL16:
5626         case R_PPC64_REL16_LO:
5627         case R_PPC64_REL16_HI:
5628         case R_PPC64_REL16_HA:
5629         case R_PPC64_REL16DX_HA:
5630           break;
5631
5632           /* Not supported as a dynamic relocation.  */
5633         case R_PPC64_ADDR64_LOCAL:
5634           if (bfd_link_pic (info))
5635             {
5636               if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5637                 ppc_howto_init ();
5638               /* xgettext:c-format */
5639               info->callbacks->einfo (_("%H: %s reloc unsupported "
5640                                         "in shared libraries and PIEs.\n"),
5641                                       abfd, sec, rel->r_offset,
5642                                       ppc64_elf_howto_table[r_type]->name);
5643               bfd_set_error (bfd_error_bad_value);
5644               return FALSE;
5645             }
5646           break;
5647
5648         case R_PPC64_TOC16:
5649         case R_PPC64_TOC16_DS:
5650           htab->do_multi_toc = 1;
5651           ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5652           /* Fall through.  */
5653         case R_PPC64_TOC16_LO:
5654         case R_PPC64_TOC16_HI:
5655         case R_PPC64_TOC16_HA:
5656         case R_PPC64_TOC16_LO_DS:
5657           sec->has_toc_reloc = 1;
5658           break;
5659
5660           /* Marker reloc.  */
5661         case R_PPC64_ENTRY:
5662           break;
5663
5664           /* This relocation describes the C++ object vtable hierarchy.
5665              Reconstruct it for later use during GC.  */
5666         case R_PPC64_GNU_VTINHERIT:
5667           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5668             return FALSE;
5669           break;
5670
5671           /* This relocation describes which C++ vtable entries are actually
5672              used.  Record for later use during GC.  */
5673         case R_PPC64_GNU_VTENTRY:
5674           BFD_ASSERT (h != NULL);
5675           if (h != NULL
5676               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5677             return FALSE;
5678           break;
5679
5680         case R_PPC64_REL14:
5681         case R_PPC64_REL14_BRTAKEN:
5682         case R_PPC64_REL14_BRNTAKEN:
5683           {
5684             asection *dest = NULL;
5685
5686             /* Heuristic: If jumping outside our section, chances are
5687                we are going to need a stub.  */
5688             if (h != NULL)
5689               {
5690                 /* If the sym is weak it may be overridden later, so
5691                    don't assume we know where a weak sym lives.  */
5692                 if (h->root.type == bfd_link_hash_defined)
5693                   dest = h->root.u.def.section;
5694               }
5695             else
5696               {
5697                 Elf_Internal_Sym *isym;
5698
5699                 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5700                                               abfd, r_symndx);
5701                 if (isym == NULL)
5702                   return FALSE;
5703
5704                 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5705               }
5706
5707             if (dest != sec)
5708               ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5709           }
5710           /* Fall through.  */
5711
5712         case R_PPC64_REL24:
5713           plt_list = ifunc;
5714           if (h != NULL)
5715             {
5716               h->needs_plt = 1;
5717               if (h->root.root.string[0] == '.'
5718                   && h->root.root.string[1] != '\0')
5719                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5720
5721               if (h == tga || h == dottga)
5722                 {
5723                   sec->has_tls_reloc = 1;
5724                   if (rel != relocs
5725                       && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5726                           || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5727                     /* We have a new-style __tls_get_addr call with
5728                        a marker reloc.  */
5729                     ;
5730                   else
5731                     /* Mark this section as having an old-style call.  */
5732                     sec->has_tls_get_addr_call = 1;
5733                 }
5734               plt_list = &h->plt.plist;
5735             }
5736
5737           /* We may need a .plt entry if the function this reloc
5738              refers to is in a shared lib.  */
5739           if (plt_list
5740               && !update_plt_info (abfd, plt_list, rel->r_addend))
5741             return FALSE;
5742           break;
5743
5744         case R_PPC64_ADDR14:
5745         case R_PPC64_ADDR14_BRNTAKEN:
5746         case R_PPC64_ADDR14_BRTAKEN:
5747         case R_PPC64_ADDR24:
5748           goto dodyn;
5749
5750         case R_PPC64_TPREL64:
5751           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5752           if (bfd_link_pic (info))
5753             info->flags |= DF_STATIC_TLS;
5754           goto dotlstoc;
5755
5756         case R_PPC64_DTPMOD64:
5757           if (rel + 1 < rel_end
5758               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5759               && rel[1].r_offset == rel->r_offset + 8)
5760             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5761           else
5762             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5763           goto dotlstoc;
5764
5765         case R_PPC64_DTPREL64:
5766           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5767           if (rel != relocs
5768               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5769               && rel[-1].r_offset == rel->r_offset - 8)
5770             /* This is the second reloc of a dtpmod, dtprel pair.
5771                Don't mark with TLS_DTPREL.  */
5772             goto dodyn;
5773
5774         dotlstoc:
5775           sec->has_tls_reloc = 1;
5776           if (h != NULL)
5777             {
5778               struct ppc_link_hash_entry *eh;
5779               eh = (struct ppc_link_hash_entry *) h;
5780               eh->tls_mask |= tls_type;
5781             }
5782           else
5783             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5784                                         rel->r_addend, tls_type))
5785               return FALSE;
5786
5787           ppc64_sec = ppc64_elf_section_data (sec);
5788           if (ppc64_sec->sec_type != sec_toc)
5789             {
5790               bfd_size_type amt;
5791
5792               /* One extra to simplify get_tls_mask.  */
5793               amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5794               ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5795               if (ppc64_sec->u.toc.symndx == NULL)
5796                 return FALSE;
5797               amt = sec->size * sizeof (bfd_vma) / 8;
5798               ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5799               if (ppc64_sec->u.toc.add == NULL)
5800                 return FALSE;
5801               BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5802               ppc64_sec->sec_type = sec_toc;
5803             }
5804           BFD_ASSERT (rel->r_offset % 8 == 0);
5805           ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5806           ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5807
5808           /* Mark the second slot of a GD or LD entry.
5809              -1 to indicate GD and -2 to indicate LD.  */
5810           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5811             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5812           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5813             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5814           goto dodyn;
5815
5816         case R_PPC64_TPREL16:
5817         case R_PPC64_TPREL16_LO:
5818         case R_PPC64_TPREL16_HI:
5819         case R_PPC64_TPREL16_HA:
5820         case R_PPC64_TPREL16_DS:
5821         case R_PPC64_TPREL16_LO_DS:
5822         case R_PPC64_TPREL16_HIGH:
5823         case R_PPC64_TPREL16_HIGHA:
5824         case R_PPC64_TPREL16_HIGHER:
5825         case R_PPC64_TPREL16_HIGHERA:
5826         case R_PPC64_TPREL16_HIGHEST:
5827         case R_PPC64_TPREL16_HIGHESTA:
5828           if (bfd_link_pic (info))
5829             {
5830               info->flags |= DF_STATIC_TLS;
5831               goto dodyn;
5832             }
5833           break;
5834
5835         case R_PPC64_ADDR64:
5836           if (opd_sym_map != NULL
5837               && rel + 1 < rel_end
5838               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5839             {
5840               if (h != NULL)
5841                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5842               else
5843                 {
5844                   asection *s;
5845                   Elf_Internal_Sym *isym;
5846
5847                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5848                                                 abfd, r_symndx);
5849                   if (isym == NULL)
5850                     return FALSE;
5851
5852                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5853                   if (s != NULL && s != sec)
5854                     opd_sym_map[OPD_NDX (rel->r_offset)] = s;
5855                 }
5856             }
5857           /* Fall through.  */
5858
5859         case R_PPC64_ADDR16:
5860         case R_PPC64_ADDR16_DS:
5861         case R_PPC64_ADDR16_HA:
5862         case R_PPC64_ADDR16_HI:
5863         case R_PPC64_ADDR16_HIGH:
5864         case R_PPC64_ADDR16_HIGHA:
5865         case R_PPC64_ADDR16_HIGHER:
5866         case R_PPC64_ADDR16_HIGHERA:
5867         case R_PPC64_ADDR16_HIGHEST:
5868         case R_PPC64_ADDR16_HIGHESTA:
5869         case R_PPC64_ADDR16_LO:
5870         case R_PPC64_ADDR16_LO_DS:
5871           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1
5872               && rel->r_addend == 0)
5873             {
5874               /* We may need a .plt entry if this reloc refers to a
5875                  function in a shared lib.  */
5876               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5877                 return FALSE;
5878               h->pointer_equality_needed = 1;
5879             }
5880           /* Fall through.  */
5881
5882         case R_PPC64_REL30:
5883         case R_PPC64_REL32:
5884         case R_PPC64_REL64:
5885         case R_PPC64_ADDR32:
5886         case R_PPC64_UADDR16:
5887         case R_PPC64_UADDR32:
5888         case R_PPC64_UADDR64:
5889         case R_PPC64_TOC:
5890           if (h != NULL && !bfd_link_pic (info))
5891             /* We may need a copy reloc.  */
5892             h->non_got_ref = 1;
5893
5894           /* Don't propagate .opd relocs.  */
5895           if (NO_OPD_RELOCS && opd_sym_map != NULL)
5896             break;
5897
5898           /* If we are creating a shared library, and this is a reloc
5899              against a global symbol, or a non PC relative reloc
5900              against a local symbol, then we need to copy the reloc
5901              into the shared library.  However, if we are linking with
5902              -Bsymbolic, we do not need to copy a reloc against a
5903              global symbol which is defined in an object we are
5904              including in the link (i.e., DEF_REGULAR is set).  At
5905              this point we have not seen all the input files, so it is
5906              possible that DEF_REGULAR is not set now but will be set
5907              later (it is never cleared).  In case of a weak definition,
5908              DEF_REGULAR may be cleared later by a strong definition in
5909              a shared library.  We account for that possibility below by
5910              storing information in the dyn_relocs field of the hash
5911              table entry.  A similar situation occurs when creating
5912              shared libraries and symbol visibility changes render the
5913              symbol local.
5914
5915              If on the other hand, we are creating an executable, we
5916              may need to keep relocations for symbols satisfied by a
5917              dynamic library if we manage to avoid copy relocs for the
5918              symbol.  */
5919         dodyn:
5920           if ((bfd_link_pic (info)
5921                && (must_be_dyn_reloc (info, r_type)
5922                    || (h != NULL
5923                        && (!SYMBOLIC_BIND (info, h)
5924                            || h->root.type == bfd_link_hash_defweak
5925                            || !h->def_regular))))
5926               || (ELIMINATE_COPY_RELOCS
5927                   && !bfd_link_pic (info)
5928                   && h != NULL
5929                   && (h->root.type == bfd_link_hash_defweak
5930                       || !h->def_regular))
5931               || (!bfd_link_pic (info)
5932                   && ifunc != NULL))
5933             {
5934               /* We must copy these reloc types into the output file.
5935                  Create a reloc section in dynobj and make room for
5936                  this reloc.  */
5937               if (sreloc == NULL)
5938                 {
5939                   sreloc = _bfd_elf_make_dynamic_reloc_section
5940                     (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5941
5942                   if (sreloc == NULL)
5943                     return FALSE;
5944                 }
5945
5946               /* If this is a global symbol, we count the number of
5947                  relocations we need for this symbol.  */
5948               if (h != NULL)
5949                 {
5950                   struct elf_dyn_relocs *p;
5951                   struct elf_dyn_relocs **head;
5952
5953                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5954                   p = *head;
5955                   if (p == NULL || p->sec != sec)
5956                     {
5957                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5958                       if (p == NULL)
5959                         return FALSE;
5960                       p->next = *head;
5961                       *head = p;
5962                       p->sec = sec;
5963                       p->count = 0;
5964                       p->pc_count = 0;
5965                     }
5966                   p->count += 1;
5967                   if (!must_be_dyn_reloc (info, r_type))
5968                     p->pc_count += 1;
5969                 }
5970               else
5971                 {
5972                   /* Track dynamic relocs needed for local syms too.
5973                      We really need local syms available to do this
5974                      easily.  Oh well.  */
5975                   struct ppc_dyn_relocs *p;
5976                   struct ppc_dyn_relocs **head;
5977                   bfd_boolean is_ifunc;
5978                   asection *s;
5979                   void *vpp;
5980                   Elf_Internal_Sym *isym;
5981
5982                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5983                                                 abfd, r_symndx);
5984                   if (isym == NULL)
5985                     return FALSE;
5986
5987                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5988                   if (s == NULL)
5989                     s = sec;
5990
5991                   vpp = &elf_section_data (s)->local_dynrel;
5992                   head = (struct ppc_dyn_relocs **) vpp;
5993                   is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5994                   p = *head;
5995                   if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5996                     p = p->next;
5997                   if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5998                     {
5999                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
6000                       if (p == NULL)
6001                         return FALSE;
6002                       p->next = *head;
6003                       *head = p;
6004                       p->sec = sec;
6005                       p->ifunc = is_ifunc;
6006                       p->count = 0;
6007                     }
6008                   p->count += 1;
6009                 }
6010             }
6011           break;
6012
6013         default:
6014           break;
6015         }
6016     }
6017
6018   return TRUE;
6019 }
6020
6021 /* Merge backend specific data from an object file to the output
6022    object file when linking.  */
6023
6024 static bfd_boolean
6025 ppc64_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
6026 {
6027   bfd *obfd = info->output_bfd;
6028   unsigned long iflags, oflags;
6029
6030   if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
6031     return TRUE;
6032
6033   if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
6034     return TRUE;
6035
6036   if (!_bfd_generic_verify_endian_match (ibfd, info))
6037     return FALSE;
6038
6039   iflags = elf_elfheader (ibfd)->e_flags;
6040   oflags = elf_elfheader (obfd)->e_flags;
6041
6042   if (iflags & ~EF_PPC64_ABI)
6043     {
6044       _bfd_error_handler
6045         /* xgettext:c-format */
6046         (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
6047       bfd_set_error (bfd_error_bad_value);
6048       return FALSE;
6049     }
6050   else if (iflags != oflags && iflags != 0)
6051     {
6052       _bfd_error_handler
6053         /* xgettext:c-format */
6054         (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
6055          ibfd, iflags, oflags);
6056       bfd_set_error (bfd_error_bad_value);
6057       return FALSE;
6058     }
6059
6060   _bfd_elf_ppc_merge_fp_attributes (ibfd, info);
6061
6062   /* Merge Tag_compatibility attributes and any common GNU ones.  */
6063   _bfd_elf_merge_object_attributes (ibfd, info);
6064
6065   return TRUE;
6066 }
6067
6068 static bfd_boolean
6069 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
6070 {
6071   /* Print normal ELF private data.  */
6072   _bfd_elf_print_private_bfd_data (abfd, ptr);
6073
6074   if (elf_elfheader (abfd)->e_flags != 0)
6075     {
6076       FILE *file = ptr;
6077
6078       fprintf (file, _("private flags = 0x%lx:"),
6079                elf_elfheader (abfd)->e_flags);
6080
6081       if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
6082         fprintf (file, _(" [abiv%ld]"),
6083                  elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
6084       fputc ('\n', file);
6085     }
6086
6087   return TRUE;
6088 }
6089
6090 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
6091    of the code entry point, and its section, which must be in the same
6092    object as OPD_SEC.  Returns (bfd_vma) -1 on error.  */
6093
6094 static bfd_vma
6095 opd_entry_value (asection *opd_sec,
6096                  bfd_vma offset,
6097                  asection **code_sec,
6098                  bfd_vma *code_off,
6099                  bfd_boolean in_code_sec)
6100 {
6101   bfd *opd_bfd = opd_sec->owner;
6102   Elf_Internal_Rela *relocs;
6103   Elf_Internal_Rela *lo, *hi, *look;
6104   bfd_vma val;
6105
6106   /* No relocs implies we are linking a --just-symbols object, or looking
6107      at a final linked executable with addr2line or somesuch.  */
6108   if (opd_sec->reloc_count == 0)
6109     {
6110       bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
6111
6112       if (contents == NULL)
6113         {
6114           if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
6115             return (bfd_vma) -1;
6116           ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
6117         }
6118
6119       /* PR 17512: file: 64b9dfbb.  */
6120       if (offset + 7 >= opd_sec->size || offset + 7 < offset)
6121         return (bfd_vma) -1;
6122
6123       val = bfd_get_64 (opd_bfd, contents + offset);
6124       if (code_sec != NULL)
6125         {
6126           asection *sec, *likely = NULL;
6127
6128           if (in_code_sec)
6129             {
6130               sec = *code_sec;
6131               if (sec->vma <= val
6132                   && val < sec->vma + sec->size)
6133                 likely = sec;
6134               else
6135                 val = -1;
6136             }
6137           else
6138             for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
6139               if (sec->vma <= val
6140                   && (sec->flags & SEC_LOAD) != 0
6141                   && (sec->flags & SEC_ALLOC) != 0)
6142                 likely = sec;
6143           if (likely != NULL)
6144             {
6145               *code_sec = likely;
6146               if (code_off != NULL)
6147                 *code_off = val - likely->vma;
6148             }
6149         }
6150       return val;
6151     }
6152
6153   BFD_ASSERT (is_ppc64_elf (opd_bfd));
6154
6155   relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
6156   if (relocs == NULL)
6157     relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
6158   /* PR 17512: file: df8e1fd6.  */
6159   if (relocs == NULL)
6160     return (bfd_vma) -1;
6161
6162   /* Go find the opd reloc at the sym address.  */
6163   lo = relocs;
6164   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
6165   val = (bfd_vma) -1;
6166   while (lo < hi)
6167     {
6168       look = lo + (hi - lo) / 2;
6169       if (look->r_offset < offset)
6170         lo = look + 1;
6171       else if (look->r_offset > offset)
6172         hi = look;
6173       else
6174         {
6175           Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
6176
6177           if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
6178               && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
6179             {
6180               unsigned long symndx = ELF64_R_SYM (look->r_info);
6181               asection *sec = NULL;
6182
6183               if (symndx >= symtab_hdr->sh_info
6184                   && elf_sym_hashes (opd_bfd) != NULL)
6185                 {
6186                   struct elf_link_hash_entry **sym_hashes;
6187                   struct elf_link_hash_entry *rh;
6188
6189                   sym_hashes = elf_sym_hashes (opd_bfd);
6190                   rh = sym_hashes[symndx - symtab_hdr->sh_info];
6191                   if (rh != NULL)
6192                     {
6193                       rh = elf_follow_link (rh);
6194                       if (rh->root.type != bfd_link_hash_defined
6195                           && rh->root.type != bfd_link_hash_defweak)
6196                         break;
6197                       if (rh->root.u.def.section->owner == opd_bfd)
6198                         {
6199                           val = rh->root.u.def.value;
6200                           sec = rh->root.u.def.section;
6201                         }
6202                     }
6203                 }
6204
6205               if (sec == NULL)
6206                 {
6207                   Elf_Internal_Sym *sym;
6208
6209                   if (symndx < symtab_hdr->sh_info)
6210                     {
6211                       sym = (Elf_Internal_Sym *) symtab_hdr->contents;
6212                       if (sym == NULL)
6213                         {
6214                           size_t symcnt = symtab_hdr->sh_info;
6215                           sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6216                                                       symcnt, 0,
6217                                                       NULL, NULL, NULL);
6218                           if (sym == NULL)
6219                             break;
6220                           symtab_hdr->contents = (bfd_byte *) sym;
6221                         }
6222                       sym += symndx;
6223                     }
6224                   else
6225                     {
6226                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6227                                                   1, symndx,
6228                                                   NULL, NULL, NULL);
6229                       if (sym == NULL)
6230                         break;
6231                     }
6232                   sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6233                   if (sec == NULL)
6234                     break;
6235                   BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
6236                   val = sym->st_value;
6237                 }
6238
6239               val += look->r_addend;
6240               if (code_off != NULL)
6241                 *code_off = val;
6242               if (code_sec != NULL)
6243                 {
6244                   if (in_code_sec && *code_sec != sec)
6245                     return -1;
6246                   else
6247                     *code_sec = sec;
6248                 }
6249               if (sec->output_section != NULL)
6250                 val += sec->output_section->vma + sec->output_offset;
6251             }
6252           break;
6253         }
6254     }
6255
6256   return val;
6257 }
6258
6259 /* If the ELF symbol SYM might be a function in SEC, return the
6260    function size and set *CODE_OFF to the function's entry point,
6261    otherwise return zero.  */
6262
6263 static bfd_size_type
6264 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6265                               bfd_vma *code_off)
6266 {
6267   bfd_size_type size;
6268
6269   if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6270                      | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6271     return 0;
6272
6273   size = 0;
6274   if (!(sym->flags & BSF_SYNTHETIC))
6275     size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6276
6277   if (strcmp (sym->section->name, ".opd") == 0)
6278     {
6279       struct _opd_sec_data *opd = get_opd_info (sym->section);
6280       bfd_vma symval = sym->value;
6281
6282       if (opd != NULL
6283           && opd->adjust != NULL
6284           && elf_section_data (sym->section)->relocs != NULL)
6285         {
6286           /* opd_entry_value will use cached relocs that have been
6287              adjusted, but with raw symbols.  That means both local
6288              and global symbols need adjusting.  */
6289           long adjust = opd->adjust[OPD_NDX (symval)];
6290           if (adjust == -1)
6291             return 0;
6292           symval += adjust;
6293         }
6294
6295       if (opd_entry_value (sym->section, symval,
6296                            &sec, code_off, TRUE) == (bfd_vma) -1)
6297         return 0;
6298       /* An old ABI binary with dot-syms has a size of 24 on the .opd
6299          symbol.  This size has nothing to do with the code size of the
6300          function, which is what we're supposed to return, but the
6301          code size isn't available without looking up the dot-sym.
6302          However, doing that would be a waste of time particularly
6303          since elf_find_function will look at the dot-sym anyway.
6304          Now, elf_find_function will keep the largest size of any
6305          function sym found at the code address of interest, so return
6306          1 here to avoid it incorrectly caching a larger function size
6307          for a small function.  This does mean we return the wrong
6308          size for a new-ABI function of size 24, but all that does is
6309          disable caching for such functions.  */
6310       if (size == 24)
6311         size = 1;
6312     }
6313   else
6314     {
6315       if (sym->section != sec)
6316         return 0;
6317       *code_off = sym->value;
6318     }
6319   if (size == 0)
6320     size = 1;
6321   return size;
6322 }
6323
6324 /* Return true if symbol is a strong function defined in an ELFv2
6325    object with st_other localentry bits of zero, ie. its local entry
6326    point coincides with its global entry point.  */
6327
6328 static bfd_boolean
6329 is_elfv2_localentry0 (struct elf_link_hash_entry *h)
6330 {
6331   return (h != NULL
6332           && h->type == STT_FUNC
6333           && h->root.type == bfd_link_hash_defined
6334           && (STO_PPC64_LOCAL_MASK & h->other) == 0
6335           && is_ppc64_elf (h->root.u.def.section->owner)
6336           && abiversion (h->root.u.def.section->owner) >= 2);
6337 }
6338
6339 /* Return true if symbol is defined in a regular object file.  */
6340
6341 static bfd_boolean
6342 is_static_defined (struct elf_link_hash_entry *h)
6343 {
6344   return ((h->root.type == bfd_link_hash_defined
6345            || h->root.type == bfd_link_hash_defweak)
6346           && h->root.u.def.section != NULL
6347           && h->root.u.def.section->output_section != NULL);
6348 }
6349
6350 /* If FDH is a function descriptor symbol, return the associated code
6351    entry symbol if it is defined.  Return NULL otherwise.  */
6352
6353 static struct ppc_link_hash_entry *
6354 defined_code_entry (struct ppc_link_hash_entry *fdh)
6355 {
6356   if (fdh->is_func_descriptor)
6357     {
6358       struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6359       if (fh->elf.root.type == bfd_link_hash_defined
6360           || fh->elf.root.type == bfd_link_hash_defweak)
6361         return fh;
6362     }
6363   return NULL;
6364 }
6365
6366 /* If FH is a function code entry symbol, return the associated
6367    function descriptor symbol if it is defined.  Return NULL otherwise.  */
6368
6369 static struct ppc_link_hash_entry *
6370 defined_func_desc (struct ppc_link_hash_entry *fh)
6371 {
6372   if (fh->oh != NULL
6373       && fh->oh->is_func_descriptor)
6374     {
6375       struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6376       if (fdh->elf.root.type == bfd_link_hash_defined
6377           || fdh->elf.root.type == bfd_link_hash_defweak)
6378         return fdh;
6379     }
6380   return NULL;
6381 }
6382
6383 static bfd_boolean func_desc_adjust (struct elf_link_hash_entry *, void *);
6384
6385 /* Garbage collect sections, after first dealing with dot-symbols.  */
6386
6387 static bfd_boolean
6388 ppc64_elf_gc_sections (bfd *abfd, struct bfd_link_info *info)
6389 {
6390   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6391
6392   if (htab != NULL && htab->need_func_desc_adj)
6393     {
6394       elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6395       htab->need_func_desc_adj = 0;
6396     }
6397   return bfd_elf_gc_sections (abfd, info);
6398 }
6399
6400 /* Mark all our entry sym sections, both opd and code section.  */
6401
6402 static void
6403 ppc64_elf_gc_keep (struct bfd_link_info *info)
6404 {
6405   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6406   struct bfd_sym_chain *sym;
6407
6408   if (htab == NULL)
6409     return;
6410
6411   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6412     {
6413       struct ppc_link_hash_entry *eh, *fh;
6414       asection *sec;
6415
6416       eh = (struct ppc_link_hash_entry *)
6417         elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6418       if (eh == NULL)
6419         continue;
6420       if (eh->elf.root.type != bfd_link_hash_defined
6421           && eh->elf.root.type != bfd_link_hash_defweak)
6422         continue;
6423
6424       fh = defined_code_entry (eh);
6425       if (fh != NULL)
6426         {
6427           sec = fh->elf.root.u.def.section;
6428           sec->flags |= SEC_KEEP;
6429         }
6430       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6431                && opd_entry_value (eh->elf.root.u.def.section,
6432                                    eh->elf.root.u.def.value,
6433                                    &sec, NULL, FALSE) != (bfd_vma) -1)
6434         sec->flags |= SEC_KEEP;
6435
6436       sec = eh->elf.root.u.def.section;
6437       sec->flags |= SEC_KEEP;
6438     }
6439 }
6440
6441 /* Mark sections containing dynamically referenced symbols.  When
6442    building shared libraries, we must assume that any visible symbol is
6443    referenced.  */
6444
6445 static bfd_boolean
6446 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6447 {
6448   struct bfd_link_info *info = (struct bfd_link_info *) inf;
6449   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6450   struct ppc_link_hash_entry *fdh;
6451   struct bfd_elf_dynamic_list *d = info->dynamic_list;
6452
6453   /* Dynamic linking info is on the func descriptor sym.  */
6454   fdh = defined_func_desc (eh);
6455   if (fdh != NULL)
6456     eh = fdh;
6457
6458   if ((eh->elf.root.type == bfd_link_hash_defined
6459        || eh->elf.root.type == bfd_link_hash_defweak)
6460       && (eh->elf.ref_dynamic
6461           || ((eh->elf.def_regular || ELF_COMMON_DEF_P (&eh->elf))
6462               && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6463               && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6464               && (!bfd_link_executable (info)
6465                   || info->gc_keep_exported
6466                   || info->export_dynamic
6467                   || (eh->elf.dynamic
6468                       && d != NULL
6469                       && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
6470               && (eh->elf.versioned >= versioned
6471                   || !bfd_hide_sym_by_version (info->version_info,
6472                                                eh->elf.root.root.string)))))
6473     {
6474       asection *code_sec;
6475       struct ppc_link_hash_entry *fh;
6476
6477       eh->elf.root.u.def.section->flags |= SEC_KEEP;
6478
6479       /* Function descriptor syms cause the associated
6480          function code sym section to be marked.  */
6481       fh = defined_code_entry (eh);
6482       if (fh != NULL)
6483         {
6484           code_sec = fh->elf.root.u.def.section;
6485           code_sec->flags |= SEC_KEEP;
6486         }
6487       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6488                && opd_entry_value (eh->elf.root.u.def.section,
6489                                    eh->elf.root.u.def.value,
6490                                    &code_sec, NULL, FALSE) != (bfd_vma) -1)
6491         code_sec->flags |= SEC_KEEP;
6492     }
6493
6494   return TRUE;
6495 }
6496
6497 /* Return the section that should be marked against GC for a given
6498    relocation.  */
6499
6500 static asection *
6501 ppc64_elf_gc_mark_hook (asection *sec,
6502                         struct bfd_link_info *info,
6503                         Elf_Internal_Rela *rel,
6504                         struct elf_link_hash_entry *h,
6505                         Elf_Internal_Sym *sym)
6506 {
6507   asection *rsec;
6508
6509   /* Syms return NULL if we're marking .opd, so we avoid marking all
6510      function sections, as all functions are referenced in .opd.  */
6511   rsec = NULL;
6512   if (get_opd_info (sec) != NULL)
6513     return rsec;
6514
6515   if (h != NULL)
6516     {
6517       enum elf_ppc64_reloc_type r_type;
6518       struct ppc_link_hash_entry *eh, *fh, *fdh;
6519
6520       r_type = ELF64_R_TYPE (rel->r_info);
6521       switch (r_type)
6522         {
6523         case R_PPC64_GNU_VTINHERIT:
6524         case R_PPC64_GNU_VTENTRY:
6525           break;
6526
6527         default:
6528           switch (h->root.type)
6529             {
6530             case bfd_link_hash_defined:
6531             case bfd_link_hash_defweak:
6532               eh = (struct ppc_link_hash_entry *) h;
6533               fdh = defined_func_desc (eh);
6534               if (fdh != NULL)
6535                 {
6536                   /* -mcall-aixdesc code references the dot-symbol on
6537                      a call reloc.  Mark the function descriptor too
6538                      against garbage collection.  */
6539                   fdh->elf.mark = 1;
6540                   if (fdh->elf.u.weakdef != NULL)
6541                     fdh->elf.u.weakdef->mark = 1;
6542                   eh = fdh;
6543                 }
6544
6545               /* Function descriptor syms cause the associated
6546                  function code sym section to be marked.  */
6547               fh = defined_code_entry (eh);
6548               if (fh != NULL)
6549                 {
6550                   /* They also mark their opd section.  */
6551                   eh->elf.root.u.def.section->gc_mark = 1;
6552
6553                   rsec = fh->elf.root.u.def.section;
6554                 }
6555               else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6556                        && opd_entry_value (eh->elf.root.u.def.section,
6557                                            eh->elf.root.u.def.value,
6558                                            &rsec, NULL, FALSE) != (bfd_vma) -1)
6559                 eh->elf.root.u.def.section->gc_mark = 1;
6560               else
6561                 rsec = h->root.u.def.section;
6562               break;
6563
6564             case bfd_link_hash_common:
6565               rsec = h->root.u.c.p->section;
6566               break;
6567
6568             default:
6569               return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6570             }
6571         }
6572     }
6573   else
6574     {
6575       struct _opd_sec_data *opd;
6576
6577       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6578       opd = get_opd_info (rsec);
6579       if (opd != NULL && opd->func_sec != NULL)
6580         {
6581           rsec->gc_mark = 1;
6582
6583           rsec = opd->func_sec[OPD_NDX (sym->st_value + rel->r_addend)];
6584         }
6585     }
6586
6587   return rsec;
6588 }
6589
6590 /* Update the .got, .plt. and dynamic reloc reference counts for the
6591    section being removed.  */
6592
6593 static bfd_boolean
6594 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
6595                          asection *sec, const Elf_Internal_Rela *relocs)
6596 {
6597   struct ppc_link_hash_table *htab;
6598   Elf_Internal_Shdr *symtab_hdr;
6599   struct elf_link_hash_entry **sym_hashes;
6600   struct got_entry **local_got_ents;
6601   const Elf_Internal_Rela *rel, *relend;
6602
6603   if (bfd_link_relocatable (info))
6604     return TRUE;
6605
6606   if ((sec->flags & SEC_ALLOC) == 0)
6607     return TRUE;
6608
6609   elf_section_data (sec)->local_dynrel = NULL;
6610
6611   htab = ppc_hash_table (info);
6612   if (htab == NULL)
6613     return FALSE;
6614
6615   symtab_hdr = &elf_symtab_hdr (abfd);
6616   sym_hashes = elf_sym_hashes (abfd);
6617   local_got_ents = elf_local_got_ents (abfd);
6618
6619   relend = relocs + sec->reloc_count;
6620   for (rel = relocs; rel < relend; rel++)
6621     {
6622       unsigned long r_symndx;
6623       enum elf_ppc64_reloc_type r_type;
6624       struct elf_link_hash_entry *h = NULL;
6625       struct plt_entry **plt_list = NULL;
6626       unsigned char tls_type = 0;
6627
6628       r_symndx = ELF64_R_SYM (rel->r_info);
6629       r_type = ELF64_R_TYPE (rel->r_info);
6630       if (r_symndx >= symtab_hdr->sh_info)
6631         {
6632           struct ppc_link_hash_entry *eh;
6633           struct elf_dyn_relocs **pp;
6634           struct elf_dyn_relocs *p;
6635
6636           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6637           h = elf_follow_link (h);
6638           eh = (struct ppc_link_hash_entry *) h;
6639
6640           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6641             if (p->sec == sec)
6642               {
6643                 /* Everything must go for SEC.  */
6644                 *pp = p->next;
6645                 break;
6646               }
6647         }
6648
6649       switch (r_type)
6650         {
6651         case R_PPC64_GOT_TLSLD16:
6652         case R_PPC64_GOT_TLSLD16_LO:
6653         case R_PPC64_GOT_TLSLD16_HI:
6654         case R_PPC64_GOT_TLSLD16_HA:
6655           tls_type = TLS_TLS | TLS_LD;
6656           goto dogot;
6657
6658         case R_PPC64_GOT_TLSGD16:
6659         case R_PPC64_GOT_TLSGD16_LO:
6660         case R_PPC64_GOT_TLSGD16_HI:
6661         case R_PPC64_GOT_TLSGD16_HA:
6662           tls_type = TLS_TLS | TLS_GD;
6663           goto dogot;
6664
6665         case R_PPC64_GOT_TPREL16_DS:
6666         case R_PPC64_GOT_TPREL16_LO_DS:
6667         case R_PPC64_GOT_TPREL16_HI:
6668         case R_PPC64_GOT_TPREL16_HA:
6669           tls_type = TLS_TLS | TLS_TPREL;
6670           goto dogot;
6671
6672         case R_PPC64_GOT_DTPREL16_DS:
6673         case R_PPC64_GOT_DTPREL16_LO_DS:
6674         case R_PPC64_GOT_DTPREL16_HI:
6675         case R_PPC64_GOT_DTPREL16_HA:
6676           tls_type = TLS_TLS | TLS_DTPREL;
6677           goto dogot;
6678
6679         case R_PPC64_GOT16:
6680         case R_PPC64_GOT16_DS:
6681         case R_PPC64_GOT16_HA:
6682         case R_PPC64_GOT16_HI:
6683         case R_PPC64_GOT16_LO:
6684         case R_PPC64_GOT16_LO_DS:
6685         dogot:
6686           {
6687             struct got_entry *ent;
6688
6689             if (h != NULL)
6690               ent = h->got.glist;
6691             else
6692               ent = local_got_ents[r_symndx];
6693
6694             for (; ent != NULL; ent = ent->next)
6695               if (ent->addend == rel->r_addend
6696                   && ent->owner == abfd
6697                   && ent->tls_type == tls_type)
6698                 break;
6699             if (ent == NULL)
6700               abort ();
6701             if (ent->got.refcount > 0)
6702               ent->got.refcount -= 1;
6703           }
6704           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1)
6705             plt_list = &h->plt.plist;
6706           break;
6707
6708         case R_PPC64_PLT16_HA:
6709         case R_PPC64_PLT16_HI:
6710         case R_PPC64_PLT16_LO:
6711         case R_PPC64_PLT32:
6712         case R_PPC64_PLT64:
6713         case R_PPC64_REL14:
6714         case R_PPC64_REL14_BRNTAKEN:
6715         case R_PPC64_REL14_BRTAKEN:
6716         case R_PPC64_REL24:
6717           if (h != NULL)
6718             plt_list = &h->plt.plist;
6719           else if (local_got_ents != NULL)
6720             {
6721               struct plt_entry **local_plt = (struct plt_entry **)
6722                 (local_got_ents + symtab_hdr->sh_info);
6723               unsigned char *local_got_tls_masks = (unsigned char *)
6724                 (local_plt + symtab_hdr->sh_info);
6725               if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6726                 plt_list = local_plt + r_symndx;
6727             }
6728           break;
6729
6730         case R_PPC64_ADDR64:
6731         case R_PPC64_ADDR16:
6732         case R_PPC64_ADDR16_DS:
6733         case R_PPC64_ADDR16_HA:
6734         case R_PPC64_ADDR16_HI:
6735         case R_PPC64_ADDR16_HIGH:
6736         case R_PPC64_ADDR16_HIGHA:
6737         case R_PPC64_ADDR16_HIGHER:
6738         case R_PPC64_ADDR16_HIGHERA:
6739         case R_PPC64_ADDR16_HIGHEST:
6740         case R_PPC64_ADDR16_HIGHESTA:
6741         case R_PPC64_ADDR16_LO:
6742         case R_PPC64_ADDR16_LO_DS:
6743           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1
6744               && rel->r_addend == 0)
6745             plt_list = &h->plt.plist;
6746           break;
6747
6748         default:
6749           break;
6750         }
6751       if (plt_list != NULL)
6752         {
6753           struct plt_entry *ent;
6754
6755           for (ent = *plt_list; ent != NULL; ent = ent->next)
6756             if (ent->addend == rel->r_addend)
6757               break;
6758           if (ent != NULL && ent->plt.refcount > 0)
6759             ent->plt.refcount -= 1;
6760         }
6761     }
6762   return TRUE;
6763 }
6764
6765 /* The maximum size of .sfpr.  */
6766 #define SFPR_MAX (218*4)
6767
6768 struct sfpr_def_parms
6769 {
6770   const char name[12];
6771   unsigned char lo, hi;
6772   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6773   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6774 };
6775
6776 /* Auto-generate _save*, _rest* functions in .sfpr.
6777    If STUB_SEC is non-null, define alias symbols in STUB_SEC
6778    instead.  */
6779
6780 static bfd_boolean
6781 sfpr_define (struct bfd_link_info *info,
6782              const struct sfpr_def_parms *parm,
6783              asection *stub_sec)
6784 {
6785   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6786   unsigned int i;
6787   size_t len = strlen (parm->name);
6788   bfd_boolean writing = FALSE;
6789   char sym[16];
6790
6791   if (htab == NULL)
6792     return FALSE;
6793
6794   memcpy (sym, parm->name, len);
6795   sym[len + 2] = 0;
6796
6797   for (i = parm->lo; i <= parm->hi; i++)
6798     {
6799       struct ppc_link_hash_entry *h;
6800
6801       sym[len + 0] = i / 10 + '0';
6802       sym[len + 1] = i % 10 + '0';
6803       h = (struct ppc_link_hash_entry *)
6804         elf_link_hash_lookup (&htab->elf, sym, writing, TRUE, TRUE);
6805       if (stub_sec != NULL)
6806         {
6807           if (h != NULL
6808               && h->elf.root.type == bfd_link_hash_defined
6809               && h->elf.root.u.def.section == htab->sfpr)
6810             {
6811               struct elf_link_hash_entry *s;
6812               char buf[32];
6813               sprintf (buf, "%08x.%s", stub_sec->id & 0xffffffff, sym);
6814               s = elf_link_hash_lookup (&htab->elf, buf, TRUE, TRUE, FALSE);
6815               if (s == NULL)
6816                 return FALSE;
6817               if (s->root.type == bfd_link_hash_new
6818                   || (s->root.type = bfd_link_hash_defined
6819                       && s->root.u.def.section == stub_sec))
6820                 {
6821                   s->root.type = bfd_link_hash_defined;
6822                   s->root.u.def.section = stub_sec;
6823                   s->root.u.def.value = (stub_sec->size
6824                                          + h->elf.root.u.def.value);
6825                   s->ref_regular = 1;
6826                   s->def_regular = 1;
6827                   s->ref_regular_nonweak = 1;
6828                   s->forced_local = 1;
6829                   s->non_elf = 0;
6830                   s->root.linker_def = 1;
6831                 }
6832             }
6833           continue;
6834         }
6835       if (h != NULL)
6836         {
6837           h->save_res = 1;
6838           if (!h->elf.def_regular)
6839             {
6840               h->elf.root.type = bfd_link_hash_defined;
6841               h->elf.root.u.def.section = htab->sfpr;
6842               h->elf.root.u.def.value = htab->sfpr->size;
6843               h->elf.type = STT_FUNC;
6844               h->elf.def_regular = 1;
6845               h->elf.non_elf = 0;
6846               _bfd_elf_link_hash_hide_symbol (info, &h->elf, TRUE);
6847               writing = TRUE;
6848               if (htab->sfpr->contents == NULL)
6849                 {
6850                   htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6851                   if (htab->sfpr->contents == NULL)
6852                     return FALSE;
6853                 }
6854             }
6855         }
6856       if (writing)
6857         {
6858           bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6859           if (i != parm->hi)
6860             p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6861           else
6862             p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6863           htab->sfpr->size = p - htab->sfpr->contents;
6864         }
6865     }
6866
6867   return TRUE;
6868 }
6869
6870 static bfd_byte *
6871 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6872 {
6873   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6874   return p + 4;
6875 }
6876
6877 static bfd_byte *
6878 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6879 {
6880   p = savegpr0 (abfd, p, r);
6881   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6882   p = p + 4;
6883   bfd_put_32 (abfd, BLR, p);
6884   return p + 4;
6885 }
6886
6887 static bfd_byte *
6888 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6889 {
6890   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6891   return p + 4;
6892 }
6893
6894 static bfd_byte *
6895 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6896 {
6897   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6898   p = p + 4;
6899   p = restgpr0 (abfd, p, r);
6900   bfd_put_32 (abfd, MTLR_R0, p);
6901   p = p + 4;
6902   if (r == 29)
6903     {
6904       p = restgpr0 (abfd, p, 30);
6905       p = restgpr0 (abfd, p, 31);
6906     }
6907   bfd_put_32 (abfd, BLR, p);
6908   return p + 4;
6909 }
6910
6911 static bfd_byte *
6912 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6913 {
6914   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6915   return p + 4;
6916 }
6917
6918 static bfd_byte *
6919 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6920 {
6921   p = savegpr1 (abfd, p, r);
6922   bfd_put_32 (abfd, BLR, p);
6923   return p + 4;
6924 }
6925
6926 static bfd_byte *
6927 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6928 {
6929   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6930   return p + 4;
6931 }
6932
6933 static bfd_byte *
6934 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6935 {
6936   p = restgpr1 (abfd, p, r);
6937   bfd_put_32 (abfd, BLR, p);
6938   return p + 4;
6939 }
6940
6941 static bfd_byte *
6942 savefpr (bfd *abfd, bfd_byte *p, int r)
6943 {
6944   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6945   return p + 4;
6946 }
6947
6948 static bfd_byte *
6949 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6950 {
6951   p = savefpr (abfd, p, r);
6952   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6953   p = p + 4;
6954   bfd_put_32 (abfd, BLR, p);
6955   return p + 4;
6956 }
6957
6958 static bfd_byte *
6959 restfpr (bfd *abfd, bfd_byte *p, int r)
6960 {
6961   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6962   return p + 4;
6963 }
6964
6965 static bfd_byte *
6966 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6967 {
6968   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6969   p = p + 4;
6970   p = restfpr (abfd, p, r);
6971   bfd_put_32 (abfd, MTLR_R0, p);
6972   p = p + 4;
6973   if (r == 29)
6974     {
6975       p = restfpr (abfd, p, 30);
6976       p = restfpr (abfd, p, 31);
6977     }
6978   bfd_put_32 (abfd, BLR, p);
6979   return p + 4;
6980 }
6981
6982 static bfd_byte *
6983 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6984 {
6985   p = savefpr (abfd, p, r);
6986   bfd_put_32 (abfd, BLR, p);
6987   return p + 4;
6988 }
6989
6990 static bfd_byte *
6991 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6992 {
6993   p = restfpr (abfd, p, r);
6994   bfd_put_32 (abfd, BLR, p);
6995   return p + 4;
6996 }
6997
6998 static bfd_byte *
6999 savevr (bfd *abfd, bfd_byte *p, int r)
7000 {
7001   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
7002   p = p + 4;
7003   bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
7004   return p + 4;
7005 }
7006
7007 static bfd_byte *
7008 savevr_tail (bfd *abfd, bfd_byte *p, int r)
7009 {
7010   p = savevr (abfd, p, r);
7011   bfd_put_32 (abfd, BLR, p);
7012   return p + 4;
7013 }
7014
7015 static bfd_byte *
7016 restvr (bfd *abfd, bfd_byte *p, int r)
7017 {
7018   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
7019   p = p + 4;
7020   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
7021   return p + 4;
7022 }
7023
7024 static bfd_byte *
7025 restvr_tail (bfd *abfd, bfd_byte *p, int r)
7026 {
7027   p = restvr (abfd, p, r);
7028   bfd_put_32 (abfd, BLR, p);
7029   return p + 4;
7030 }
7031
7032 /* Called via elf_link_hash_traverse to transfer dynamic linking
7033    information on function code symbol entries to their corresponding
7034    function descriptor symbol entries.  */
7035
7036 static bfd_boolean
7037 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
7038 {
7039   struct bfd_link_info *info;
7040   struct ppc_link_hash_table *htab;
7041   struct ppc_link_hash_entry *fh;
7042   struct ppc_link_hash_entry *fdh;
7043   bfd_boolean force_local;
7044
7045   fh = (struct ppc_link_hash_entry *) h;
7046   if (fh->elf.root.type == bfd_link_hash_indirect)
7047     return TRUE;
7048
7049   if (!fh->is_func)
7050     return TRUE;
7051
7052   if (fh->elf.root.root.string[0] != '.'
7053       || fh->elf.root.root.string[1] == '\0')
7054     return TRUE;
7055
7056   info = inf;
7057   htab = ppc_hash_table (info);
7058   if (htab == NULL)
7059     return FALSE;
7060
7061   /* Find the corresponding function descriptor symbol.  */
7062   fdh = lookup_fdh (fh, htab);
7063
7064   /* Resolve undefined references to dot-symbols as the value
7065      in the function descriptor, if we have one in a regular object.
7066      This is to satisfy cases like ".quad .foo".  Calls to functions
7067      in dynamic objects are handled elsewhere.  */
7068   if ((fh->elf.root.type == bfd_link_hash_undefined
7069        || fh->elf.root.type == bfd_link_hash_undefweak)
7070       && (fdh->elf.root.type == bfd_link_hash_defined
7071           || fdh->elf.root.type == bfd_link_hash_defweak)
7072       && get_opd_info (fdh->elf.root.u.def.section) != NULL
7073       && opd_entry_value (fdh->elf.root.u.def.section,
7074                           fdh->elf.root.u.def.value,
7075                           &fh->elf.root.u.def.section,
7076                           &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
7077     {
7078       fh->elf.root.type = fdh->elf.root.type;
7079       fh->elf.forced_local = 1;
7080       fh->elf.def_regular = fdh->elf.def_regular;
7081       fh->elf.def_dynamic = fdh->elf.def_dynamic;
7082     }
7083
7084   if (!fh->elf.dynamic)
7085     {
7086       struct plt_entry *ent;
7087
7088       for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
7089         if (ent->plt.refcount > 0)
7090           break;
7091       if (ent == NULL)
7092         return TRUE;
7093     }
7094
7095   /* Create a descriptor as undefined if necessary.  */
7096   if (fdh == NULL
7097       && !bfd_link_executable (info)
7098       && (fh->elf.root.type == bfd_link_hash_undefined
7099           || fh->elf.root.type == bfd_link_hash_undefweak))
7100     {
7101       fdh = make_fdh (info, fh);
7102       if (fdh == NULL)
7103         return FALSE;
7104     }
7105
7106   /* We can't support overriding of symbols on a fake descriptor.  */
7107   if (fdh != NULL
7108       && fdh->fake
7109       && (fh->elf.root.type == bfd_link_hash_defined
7110           || fh->elf.root.type == bfd_link_hash_defweak))
7111     _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
7112
7113   /* Transfer dynamic linking information to the function descriptor.  */
7114   if (fdh != NULL)
7115     {
7116       fdh->elf.ref_regular |= fh->elf.ref_regular;
7117       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
7118       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
7119       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
7120       fdh->elf.dynamic |= fh->elf.dynamic;
7121       fdh->elf.needs_plt |= (fh->elf.needs_plt
7122                              || fh->elf.type == STT_FUNC
7123                              || fh->elf.type == STT_GNU_IFUNC);
7124       move_plt_plist (fh, fdh);
7125
7126       if (!fdh->elf.forced_local
7127           && fh->elf.dynindx != -1)
7128         if (!bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
7129           return FALSE;
7130     }
7131
7132   /* Now that the info is on the function descriptor, clear the
7133      function code sym info.  Any function code syms for which we
7134      don't have a definition in a regular file, we force local.
7135      This prevents a shared library from exporting syms that have
7136      been imported from another library.  Function code syms that
7137      are really in the library we must leave global to prevent the
7138      linker dragging in a definition from a static library.  */
7139   force_local = (!fh->elf.def_regular
7140                  || fdh == NULL
7141                  || !fdh->elf.def_regular
7142                  || fdh->elf.forced_local);
7143   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7144
7145   return TRUE;
7146 }
7147
7148 static const struct sfpr_def_parms save_res_funcs[] =
7149   {
7150     { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
7151     { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
7152     { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
7153     { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
7154     { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
7155     { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
7156     { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
7157     { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
7158     { "._savef", 14, 31, savefpr, savefpr1_tail },
7159     { "._restf", 14, 31, restfpr, restfpr1_tail },
7160     { "_savevr_", 20, 31, savevr, savevr_tail },
7161     { "_restvr_", 20, 31, restvr, restvr_tail }
7162   };
7163
7164 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
7165    this hook to a) provide some gcc support functions, and b) transfer
7166    dynamic linking information gathered so far on function code symbol
7167    entries, to their corresponding function descriptor symbol entries.  */
7168
7169 static bfd_boolean
7170 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
7171                             struct bfd_link_info *info)
7172 {
7173   struct ppc_link_hash_table *htab;
7174
7175   htab = ppc_hash_table (info);
7176   if (htab == NULL)
7177     return FALSE;
7178
7179   /* Provide any missing _save* and _rest* functions.  */
7180   if (htab->sfpr != NULL)
7181     {
7182       unsigned int i;
7183
7184       htab->sfpr->size = 0;
7185       for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
7186         if (!sfpr_define (info, &save_res_funcs[i], NULL))
7187           return FALSE;
7188       if (htab->sfpr->size == 0)
7189         htab->sfpr->flags |= SEC_EXCLUDE;
7190     }
7191
7192   if (bfd_link_relocatable (info))
7193     return TRUE;
7194
7195   if (htab->elf.hgot != NULL)
7196     {
7197       _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
7198       /* Make .TOC. defined so as to prevent it being made dynamic.
7199          The wrong value here is fixed later in ppc64_elf_set_toc.  */
7200       if (!htab->elf.hgot->def_regular
7201           || htab->elf.hgot->root.type != bfd_link_hash_defined)
7202         {
7203           htab->elf.hgot->root.type = bfd_link_hash_defined;
7204           htab->elf.hgot->root.u.def.value = 0;
7205           htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
7206           htab->elf.hgot->def_regular = 1;
7207           htab->elf.hgot->root.linker_def = 1;
7208         }
7209       htab->elf.hgot->type = STT_OBJECT;
7210       htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
7211                                | STV_HIDDEN);
7212     }
7213
7214   if (htab->need_func_desc_adj)
7215     {
7216       elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
7217       htab->need_func_desc_adj = 0;
7218     }
7219
7220   return TRUE;
7221 }
7222
7223 /* Return true if we have dynamic relocs against H that apply to
7224    read-only sections.  */
7225
7226 static bfd_boolean
7227 readonly_dynrelocs (struct elf_link_hash_entry *h)
7228 {
7229   struct ppc_link_hash_entry *eh;
7230   struct elf_dyn_relocs *p;
7231
7232   eh = (struct ppc_link_hash_entry *) h;
7233   for (p = eh->dyn_relocs; p != NULL; p = p->next)
7234     {
7235       asection *s = p->sec->output_section;
7236
7237       if (s != NULL && (s->flags & SEC_READONLY) != 0)
7238         return TRUE;
7239     }
7240   return FALSE;
7241 }
7242
7243 /* Return true if we have dynamic relocs against H or any of its weak
7244    aliases, that apply to read-only sections.  */
7245
7246 static bfd_boolean
7247 alias_readonly_dynrelocs (struct elf_link_hash_entry *h)
7248 {
7249   struct ppc_link_hash_entry *eh;
7250
7251   eh = (struct ppc_link_hash_entry *) h;
7252   do
7253     {
7254       if (readonly_dynrelocs (&eh->elf))
7255         return TRUE;
7256       eh = eh->weakref;
7257     } while (eh != NULL && &eh->elf != h);
7258
7259   return FALSE;
7260 }
7261
7262 /* Return whether EH has pc-relative dynamic relocs.  */
7263
7264 static bfd_boolean
7265 pc_dynrelocs (struct ppc_link_hash_entry *eh)
7266 {
7267   struct elf_dyn_relocs *p;
7268
7269   for (p = eh->dyn_relocs; p != NULL; p = p->next)
7270     if (p->pc_count != 0)
7271       return TRUE;
7272   return FALSE;
7273 }
7274
7275 /* Return true if a global entry stub will be created for H.  Valid
7276    for ELFv2 before plt entries have been allocated.  */
7277
7278 static bfd_boolean
7279 global_entry_stub (struct elf_link_hash_entry *h)
7280 {
7281   struct plt_entry *pent;
7282
7283   if (!h->pointer_equality_needed
7284       || h->def_regular)
7285     return FALSE;
7286
7287   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
7288     if (pent->plt.refcount > 0
7289         && pent->addend == 0)
7290       return TRUE;
7291
7292   return FALSE;
7293 }
7294
7295 /* Adjust a symbol defined by a dynamic object and referenced by a
7296    regular object.  The current definition is in some section of the
7297    dynamic object, but we're not including those sections.  We have to
7298    change the definition to something the rest of the link can
7299    understand.  */
7300
7301 static bfd_boolean
7302 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
7303                                  struct elf_link_hash_entry *h)
7304 {
7305   struct ppc_link_hash_table *htab;
7306   asection *s, *srel;
7307
7308   htab = ppc_hash_table (info);
7309   if (htab == NULL)
7310     return FALSE;
7311
7312   /* Deal with function syms.  */
7313   if (h->type == STT_FUNC
7314       || h->type == STT_GNU_IFUNC
7315       || h->needs_plt)
7316     {
7317       /* Clear procedure linkage table information for any symbol that
7318          won't need a .plt entry.  */
7319       struct plt_entry *ent;
7320       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
7321         if (ent->plt.refcount > 0)
7322           break;
7323       if (ent == NULL
7324           || (h->type != STT_GNU_IFUNC
7325               && (SYMBOL_CALLS_LOCAL (info, h)
7326                   || UNDEFWEAK_NO_DYNAMIC_RELOC (info, h)))
7327           || ((struct ppc_link_hash_entry *) h)->save_res)
7328         {
7329           h->plt.plist = NULL;
7330           h->needs_plt = 0;
7331           h->pointer_equality_needed = 0;
7332         }
7333       else if (abiversion (info->output_bfd) >= 2)
7334         {
7335           /* Taking a function's address in a read/write section
7336              doesn't require us to define the function symbol in the
7337              executable on a global entry stub.  A dynamic reloc can
7338              be used instead.  The reason we prefer a few more dynamic
7339              relocs is that calling via a global entry stub costs a
7340              few more instructions, and pointer_equality_needed causes
7341              extra work in ld.so when resolving these symbols.  */
7342           if (global_entry_stub (h)
7343               && !alias_readonly_dynrelocs (h))
7344             {
7345               h->pointer_equality_needed = 0;
7346               /* After adjust_dynamic_symbol, non_got_ref set in
7347                  the non-pic case means that dyn_relocs for this
7348                  symbol should be discarded.  */
7349               h->non_got_ref = 0;
7350             }
7351
7352           /* If making a plt entry, then we don't need copy relocs.  */
7353           return TRUE;
7354         }
7355     }
7356   else
7357     h->plt.plist = NULL;
7358
7359   /* If this is a weak symbol, and there is a real definition, the
7360      processor independent code will have arranged for us to see the
7361      real definition first, and we can just use the same value.  */
7362   if (h->u.weakdef != NULL)
7363     {
7364       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
7365                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
7366       h->root.u.def.section = h->u.weakdef->root.u.def.section;
7367       h->root.u.def.value = h->u.weakdef->root.u.def.value;
7368       if (ELIMINATE_COPY_RELOCS)
7369         h->non_got_ref = h->u.weakdef->non_got_ref;
7370       return TRUE;
7371     }
7372
7373   /* If we are creating a shared library, we must presume that the
7374      only references to the symbol are via the global offset table.
7375      For such cases we need not do anything here; the relocations will
7376      be handled correctly by relocate_section.  */
7377   if (bfd_link_pic (info))
7378     return TRUE;
7379
7380   /* If there are no references to this symbol that do not use the
7381      GOT, we don't need to generate a copy reloc.  */
7382   if (!h->non_got_ref)
7383     return TRUE;
7384
7385   /* Don't generate a copy reloc for symbols defined in the executable.  */
7386   if (!h->def_dynamic || !h->ref_regular || h->def_regular
7387
7388       /* If -z nocopyreloc was given, don't generate them either.  */
7389       || info->nocopyreloc
7390
7391       /* If we didn't find any dynamic relocs in read-only sections, then
7392          we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
7393       || (ELIMINATE_COPY_RELOCS && !alias_readonly_dynrelocs (h))
7394
7395       /* Protected variables do not work with .dynbss.  The copy in
7396          .dynbss won't be used by the shared library with the protected
7397          definition for the variable.  Text relocations are preferable
7398          to an incorrect program.  */
7399       || h->protected_def)
7400     {
7401       h->non_got_ref = 0;
7402       return TRUE;
7403     }
7404
7405   if (h->plt.plist != NULL)
7406     {
7407       /* We should never get here, but unfortunately there are versions
7408          of gcc out there that improperly (for this ABI) put initialized
7409          function pointers, vtable refs and suchlike in read-only
7410          sections.  Allow them to proceed, but warn that this might
7411          break at runtime.  */
7412       info->callbacks->einfo
7413         (_("%P: copy reloc against `%T' requires lazy plt linking; "
7414            "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7415          h->root.root.string);
7416     }
7417
7418   /* This is a reference to a symbol defined by a dynamic object which
7419      is not a function.  */
7420
7421   /* We must allocate the symbol in our .dynbss section, which will
7422      become part of the .bss section of the executable.  There will be
7423      an entry for this symbol in the .dynsym section.  The dynamic
7424      object will contain position independent code, so all references
7425      from the dynamic object to this symbol will go through the global
7426      offset table.  The dynamic linker will use the .dynsym entry to
7427      determine the address it must put in the global offset table, so
7428      both the dynamic object and the regular object will refer to the
7429      same memory location for the variable.  */
7430
7431   /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
7432      to copy the initial value out of the dynamic object and into the
7433      runtime process image.  We need to remember the offset into the
7434      .rela.bss section we are going to use.  */
7435   if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
7436     {
7437       s = htab->elf.sdynrelro;
7438       srel = htab->elf.sreldynrelro;
7439     }
7440   else
7441     {
7442       s = htab->elf.sdynbss;
7443       srel = htab->elf.srelbss;
7444     }
7445   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7446     {
7447       srel->size += sizeof (Elf64_External_Rela);
7448       h->needs_copy = 1;
7449     }
7450
7451   return _bfd_elf_adjust_dynamic_copy (info, h, s);
7452 }
7453
7454 /* If given a function descriptor symbol, hide both the function code
7455    sym and the descriptor.  */
7456 static void
7457 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7458                        struct elf_link_hash_entry *h,
7459                        bfd_boolean force_local)
7460 {
7461   struct ppc_link_hash_entry *eh;
7462   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7463
7464   eh = (struct ppc_link_hash_entry *) h;
7465   if (eh->is_func_descriptor)
7466     {
7467       struct ppc_link_hash_entry *fh = eh->oh;
7468
7469       if (fh == NULL)
7470         {
7471           const char *p, *q;
7472           struct elf_link_hash_table *htab = elf_hash_table (info);
7473           char save;
7474
7475           /* We aren't supposed to use alloca in BFD because on
7476              systems which do not have alloca the version in libiberty
7477              calls xmalloc, which might cause the program to crash
7478              when it runs out of memory.  This function doesn't have a
7479              return status, so there's no way to gracefully return an
7480              error.  So cheat.  We know that string[-1] can be safely
7481              accessed;  It's either a string in an ELF string table,
7482              or allocated in an objalloc structure.  */
7483
7484           p = eh->elf.root.root.string - 1;
7485           save = *p;
7486           *(char *) p = '.';
7487           fh = (struct ppc_link_hash_entry *)
7488             elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
7489           *(char *) p = save;
7490
7491           /* Unfortunately, if it so happens that the string we were
7492              looking for was allocated immediately before this string,
7493              then we overwrote the string terminator.  That's the only
7494              reason the lookup should fail.  */
7495           if (fh == NULL)
7496             {
7497               q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7498               while (q >= eh->elf.root.root.string && *q == *p)
7499                 --q, --p;
7500               if (q < eh->elf.root.root.string && *p == '.')
7501                 fh = (struct ppc_link_hash_entry *)
7502                   elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
7503             }
7504           if (fh != NULL)
7505             {
7506               eh->oh = fh;
7507               fh->oh = eh;
7508             }
7509         }
7510       if (fh != NULL)
7511         _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7512     }
7513 }
7514
7515 static bfd_boolean
7516 get_sym_h (struct elf_link_hash_entry **hp,
7517            Elf_Internal_Sym **symp,
7518            asection **symsecp,
7519            unsigned char **tls_maskp,
7520            Elf_Internal_Sym **locsymsp,
7521            unsigned long r_symndx,
7522            bfd *ibfd)
7523 {
7524   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7525
7526   if (r_symndx >= symtab_hdr->sh_info)
7527     {
7528       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7529       struct elf_link_hash_entry *h;
7530
7531       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7532       h = elf_follow_link (h);
7533
7534       if (hp != NULL)
7535         *hp = h;
7536
7537       if (symp != NULL)
7538         *symp = NULL;
7539
7540       if (symsecp != NULL)
7541         {
7542           asection *symsec = NULL;
7543           if (h->root.type == bfd_link_hash_defined
7544               || h->root.type == bfd_link_hash_defweak)
7545             symsec = h->root.u.def.section;
7546           *symsecp = symsec;
7547         }
7548
7549       if (tls_maskp != NULL)
7550         {
7551           struct ppc_link_hash_entry *eh;
7552
7553           eh = (struct ppc_link_hash_entry *) h;
7554           *tls_maskp = &eh->tls_mask;
7555         }
7556     }
7557   else
7558     {
7559       Elf_Internal_Sym *sym;
7560       Elf_Internal_Sym *locsyms = *locsymsp;
7561
7562       if (locsyms == NULL)
7563         {
7564           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7565           if (locsyms == NULL)
7566             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7567                                             symtab_hdr->sh_info,
7568                                             0, NULL, NULL, NULL);
7569           if (locsyms == NULL)
7570             return FALSE;
7571           *locsymsp = locsyms;
7572         }
7573       sym = locsyms + r_symndx;
7574
7575       if (hp != NULL)
7576         *hp = NULL;
7577
7578       if (symp != NULL)
7579         *symp = sym;
7580
7581       if (symsecp != NULL)
7582         *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7583
7584       if (tls_maskp != NULL)
7585         {
7586           struct got_entry **lgot_ents;
7587           unsigned char *tls_mask;
7588
7589           tls_mask = NULL;
7590           lgot_ents = elf_local_got_ents (ibfd);
7591           if (lgot_ents != NULL)
7592             {
7593               struct plt_entry **local_plt = (struct plt_entry **)
7594                 (lgot_ents + symtab_hdr->sh_info);
7595               unsigned char *lgot_masks = (unsigned char *)
7596                 (local_plt + symtab_hdr->sh_info);
7597               tls_mask = &lgot_masks[r_symndx];
7598             }
7599           *tls_maskp = tls_mask;
7600         }
7601     }
7602   return TRUE;
7603 }
7604
7605 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
7606    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7607    type suitable for optimization, and 1 otherwise.  */
7608
7609 static int
7610 get_tls_mask (unsigned char **tls_maskp,
7611               unsigned long *toc_symndx,
7612               bfd_vma *toc_addend,
7613               Elf_Internal_Sym **locsymsp,
7614               const Elf_Internal_Rela *rel,
7615               bfd *ibfd)
7616 {
7617   unsigned long r_symndx;
7618   int next_r;
7619   struct elf_link_hash_entry *h;
7620   Elf_Internal_Sym *sym;
7621   asection *sec;
7622   bfd_vma off;
7623
7624   r_symndx = ELF64_R_SYM (rel->r_info);
7625   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7626     return 0;
7627
7628   if ((*tls_maskp != NULL && **tls_maskp != 0)
7629       || sec == NULL
7630       || ppc64_elf_section_data (sec) == NULL
7631       || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7632     return 1;
7633
7634   /* Look inside a TOC section too.  */
7635   if (h != NULL)
7636     {
7637       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7638       off = h->root.u.def.value;
7639     }
7640   else
7641     off = sym->st_value;
7642   off += rel->r_addend;
7643   BFD_ASSERT (off % 8 == 0);
7644   r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7645   next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7646   if (toc_symndx != NULL)
7647     *toc_symndx = r_symndx;
7648   if (toc_addend != NULL)
7649     *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7650   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7651     return 0;
7652   if ((h == NULL || is_static_defined (h))
7653       && (next_r == -1 || next_r == -2))
7654     return 1 - next_r;
7655   return 1;
7656 }
7657
7658 /* Find (or create) an entry in the tocsave hash table.  */
7659
7660 static struct tocsave_entry *
7661 tocsave_find (struct ppc_link_hash_table *htab,
7662               enum insert_option insert,
7663               Elf_Internal_Sym **local_syms,
7664               const Elf_Internal_Rela *irela,
7665               bfd *ibfd)
7666 {
7667   unsigned long r_indx;
7668   struct elf_link_hash_entry *h;
7669   Elf_Internal_Sym *sym;
7670   struct tocsave_entry ent, *p;
7671   hashval_t hash;
7672   struct tocsave_entry **slot;
7673
7674   r_indx = ELF64_R_SYM (irela->r_info);
7675   if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7676     return NULL;
7677   if (ent.sec == NULL || ent.sec->output_section == NULL)
7678     {
7679       _bfd_error_handler
7680         (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"), ibfd);
7681       return NULL;
7682     }
7683
7684   if (h != NULL)
7685     ent.offset = h->root.u.def.value;
7686   else
7687     ent.offset = sym->st_value;
7688   ent.offset += irela->r_addend;
7689
7690   hash = tocsave_htab_hash (&ent);
7691   slot = ((struct tocsave_entry **)
7692           htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7693   if (slot == NULL)
7694     return NULL;
7695
7696   if (*slot == NULL)
7697     {
7698       p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7699       if (p == NULL)
7700         return NULL;
7701       *p = ent;
7702       *slot = p;
7703     }
7704   return *slot;
7705 }
7706
7707 /* Adjust all global syms defined in opd sections.  In gcc generated
7708    code for the old ABI, these will already have been done.  */
7709
7710 static bfd_boolean
7711 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7712 {
7713   struct ppc_link_hash_entry *eh;
7714   asection *sym_sec;
7715   struct _opd_sec_data *opd;
7716
7717   if (h->root.type == bfd_link_hash_indirect)
7718     return TRUE;
7719
7720   if (h->root.type != bfd_link_hash_defined
7721       && h->root.type != bfd_link_hash_defweak)
7722     return TRUE;
7723
7724   eh = (struct ppc_link_hash_entry *) h;
7725   if (eh->adjust_done)
7726     return TRUE;
7727
7728   sym_sec = eh->elf.root.u.def.section;
7729   opd = get_opd_info (sym_sec);
7730   if (opd != NULL && opd->adjust != NULL)
7731     {
7732       long adjust = opd->adjust[OPD_NDX (eh->elf.root.u.def.value)];
7733       if (adjust == -1)
7734         {
7735           /* This entry has been deleted.  */
7736           asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7737           if (dsec == NULL)
7738             {
7739               for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7740                 if (discarded_section (dsec))
7741                   {
7742                     ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7743                     break;
7744                   }
7745             }
7746           eh->elf.root.u.def.value = 0;
7747           eh->elf.root.u.def.section = dsec;
7748         }
7749       else
7750         eh->elf.root.u.def.value += adjust;
7751       eh->adjust_done = 1;
7752     }
7753   return TRUE;
7754 }
7755
7756 /* Handles decrementing dynamic reloc counts for the reloc specified by
7757    R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM
7758    have already been determined.  */
7759
7760 static bfd_boolean
7761 dec_dynrel_count (bfd_vma r_info,
7762                   asection *sec,
7763                   struct bfd_link_info *info,
7764                   Elf_Internal_Sym **local_syms,
7765                   struct elf_link_hash_entry *h,
7766                   Elf_Internal_Sym *sym)
7767 {
7768   enum elf_ppc64_reloc_type r_type;
7769   asection *sym_sec = NULL;
7770
7771   /* Can this reloc be dynamic?  This switch, and later tests here
7772      should be kept in sync with the code in check_relocs.  */
7773   r_type = ELF64_R_TYPE (r_info);
7774   switch (r_type)
7775     {
7776     default:
7777       return TRUE;
7778
7779     case R_PPC64_TPREL16:
7780     case R_PPC64_TPREL16_LO:
7781     case R_PPC64_TPREL16_HI:
7782     case R_PPC64_TPREL16_HA:
7783     case R_PPC64_TPREL16_DS:
7784     case R_PPC64_TPREL16_LO_DS:
7785     case R_PPC64_TPREL16_HIGH:
7786     case R_PPC64_TPREL16_HIGHA:
7787     case R_PPC64_TPREL16_HIGHER:
7788     case R_PPC64_TPREL16_HIGHERA:
7789     case R_PPC64_TPREL16_HIGHEST:
7790     case R_PPC64_TPREL16_HIGHESTA:
7791       if (!bfd_link_pic (info))
7792         return TRUE;
7793
7794     case R_PPC64_TPREL64:
7795     case R_PPC64_DTPMOD64:
7796     case R_PPC64_DTPREL64:
7797     case R_PPC64_ADDR64:
7798     case R_PPC64_REL30:
7799     case R_PPC64_REL32:
7800     case R_PPC64_REL64:
7801     case R_PPC64_ADDR14:
7802     case R_PPC64_ADDR14_BRNTAKEN:
7803     case R_PPC64_ADDR14_BRTAKEN:
7804     case R_PPC64_ADDR16:
7805     case R_PPC64_ADDR16_DS:
7806     case R_PPC64_ADDR16_HA:
7807     case R_PPC64_ADDR16_HI:
7808     case R_PPC64_ADDR16_HIGH:
7809     case R_PPC64_ADDR16_HIGHA:
7810     case R_PPC64_ADDR16_HIGHER:
7811     case R_PPC64_ADDR16_HIGHERA:
7812     case R_PPC64_ADDR16_HIGHEST:
7813     case R_PPC64_ADDR16_HIGHESTA:
7814     case R_PPC64_ADDR16_LO:
7815     case R_PPC64_ADDR16_LO_DS:
7816     case R_PPC64_ADDR24:
7817     case R_PPC64_ADDR32:
7818     case R_PPC64_UADDR16:
7819     case R_PPC64_UADDR32:
7820     case R_PPC64_UADDR64:
7821     case R_PPC64_TOC:
7822       break;
7823     }
7824
7825   if (local_syms != NULL)
7826     {
7827       unsigned long r_symndx;
7828       bfd *ibfd = sec->owner;
7829
7830       r_symndx = ELF64_R_SYM (r_info);
7831       if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7832         return FALSE;
7833     }
7834
7835   if ((bfd_link_pic (info)
7836        && (must_be_dyn_reloc (info, r_type)
7837            || (h != NULL
7838                && (!SYMBOLIC_BIND (info, h)
7839                    || h->root.type == bfd_link_hash_defweak
7840                    || !h->def_regular))))
7841       || (ELIMINATE_COPY_RELOCS
7842           && !bfd_link_pic (info)
7843           && h != NULL
7844           && (h->root.type == bfd_link_hash_defweak
7845               || !h->def_regular)))
7846     ;
7847   else
7848     return TRUE;
7849
7850   if (h != NULL)
7851     {
7852       struct elf_dyn_relocs *p;
7853       struct elf_dyn_relocs **pp;
7854       pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7855
7856       /* elf_gc_sweep may have already removed all dyn relocs associated
7857          with local syms for a given section.  Also, symbol flags are
7858          changed by elf_gc_sweep_symbol, confusing the test above.  Don't
7859          report a dynreloc miscount.  */
7860       if (*pp == NULL && info->gc_sections)
7861         return TRUE;
7862
7863       while ((p = *pp) != NULL)
7864         {
7865           if (p->sec == sec)
7866             {
7867               if (!must_be_dyn_reloc (info, r_type))
7868                 p->pc_count -= 1;
7869               p->count -= 1;
7870               if (p->count == 0)
7871                 *pp = p->next;
7872               return TRUE;
7873             }
7874           pp = &p->next;
7875         }
7876     }
7877   else
7878     {
7879       struct ppc_dyn_relocs *p;
7880       struct ppc_dyn_relocs **pp;
7881       void *vpp;
7882       bfd_boolean is_ifunc;
7883
7884       if (local_syms == NULL)
7885         sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7886       if (sym_sec == NULL)
7887         sym_sec = sec;
7888
7889       vpp = &elf_section_data (sym_sec)->local_dynrel;
7890       pp = (struct ppc_dyn_relocs **) vpp;
7891
7892       if (*pp == NULL && info->gc_sections)
7893         return TRUE;
7894
7895       is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7896       while ((p = *pp) != NULL)
7897         {
7898           if (p->sec == sec && p->ifunc == is_ifunc)
7899             {
7900               p->count -= 1;
7901               if (p->count == 0)
7902                 *pp = p->next;
7903               return TRUE;
7904             }
7905           pp = &p->next;
7906         }
7907     }
7908
7909   /* xgettext:c-format */
7910   info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7911                           sec->owner, sec);
7912   bfd_set_error (bfd_error_bad_value);
7913   return FALSE;
7914 }
7915
7916 /* Remove unused Official Procedure Descriptor entries.  Currently we
7917    only remove those associated with functions in discarded link-once
7918    sections, or weakly defined functions that have been overridden.  It
7919    would be possible to remove many more entries for statically linked
7920    applications.  */
7921
7922 bfd_boolean
7923 ppc64_elf_edit_opd (struct bfd_link_info *info)
7924 {
7925   bfd *ibfd;
7926   bfd_boolean some_edited = FALSE;
7927   asection *need_pad = NULL;
7928   struct ppc_link_hash_table *htab;
7929
7930   htab = ppc_hash_table (info);
7931   if (htab == NULL)
7932     return FALSE;
7933
7934   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
7935     {
7936       asection *sec;
7937       Elf_Internal_Rela *relstart, *rel, *relend;
7938       Elf_Internal_Shdr *symtab_hdr;
7939       Elf_Internal_Sym *local_syms;
7940       struct _opd_sec_data *opd;
7941       bfd_boolean need_edit, add_aux_fields, broken;
7942       bfd_size_type cnt_16b = 0;
7943
7944       if (!is_ppc64_elf (ibfd))
7945         continue;
7946
7947       sec = bfd_get_section_by_name (ibfd, ".opd");
7948       if (sec == NULL || sec->size == 0)
7949         continue;
7950
7951       if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7952         continue;
7953
7954       if (sec->output_section == bfd_abs_section_ptr)
7955         continue;
7956
7957       /* Look through the section relocs.  */
7958       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7959         continue;
7960
7961       local_syms = NULL;
7962       symtab_hdr = &elf_symtab_hdr (ibfd);
7963
7964       /* Read the relocations.  */
7965       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7966                                             info->keep_memory);
7967       if (relstart == NULL)
7968         return FALSE;
7969
7970       /* First run through the relocs to check they are sane, and to
7971          determine whether we need to edit this opd section.  */
7972       need_edit = FALSE;
7973       broken = FALSE;
7974       need_pad = sec;
7975       relend = relstart + sec->reloc_count;
7976       for (rel = relstart; rel < relend; )
7977         {
7978           enum elf_ppc64_reloc_type r_type;
7979           unsigned long r_symndx;
7980           asection *sym_sec;
7981           struct elf_link_hash_entry *h;
7982           Elf_Internal_Sym *sym;
7983           bfd_vma offset;
7984
7985           /* .opd contains an array of 16 or 24 byte entries.  We're
7986              only interested in the reloc pointing to a function entry
7987              point.  */
7988           offset = rel->r_offset;
7989           if (rel + 1 == relend
7990               || rel[1].r_offset != offset + 8)
7991             {
7992               /* If someone messes with .opd alignment then after a
7993                  "ld -r" we might have padding in the middle of .opd.
7994                  Also, there's nothing to prevent someone putting
7995                  something silly in .opd with the assembler.  No .opd
7996                  optimization for them!  */
7997             broken_opd:
7998               _bfd_error_handler
7999                 (_("%B: .opd is not a regular array of opd entries"), ibfd);
8000               broken = TRUE;
8001               break;
8002             }
8003
8004           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
8005               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
8006             {
8007               _bfd_error_handler
8008                 /* xgettext:c-format */
8009                 (_("%B: unexpected reloc type %u in .opd section"),
8010                  ibfd, r_type);
8011               broken = TRUE;
8012               break;
8013             }
8014
8015           r_symndx = ELF64_R_SYM (rel->r_info);
8016           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8017                           r_symndx, ibfd))
8018             goto error_ret;
8019
8020           if (sym_sec == NULL || sym_sec->owner == NULL)
8021             {
8022               const char *sym_name;
8023               if (h != NULL)
8024                 sym_name = h->root.root.string;
8025               else
8026                 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
8027                                              sym_sec);
8028
8029               _bfd_error_handler
8030                 /* xgettext:c-format */
8031                 (_("%B: undefined sym `%s' in .opd section"),
8032                  ibfd, sym_name);
8033               broken = TRUE;
8034               break;
8035             }
8036
8037           /* opd entries are always for functions defined in the
8038              current input bfd.  If the symbol isn't defined in the
8039              input bfd, then we won't be using the function in this
8040              bfd;  It must be defined in a linkonce section in another
8041              bfd, or is weak.  It's also possible that we are
8042              discarding the function due to a linker script /DISCARD/,
8043              which we test for via the output_section.  */
8044           if (sym_sec->owner != ibfd
8045               || sym_sec->output_section == bfd_abs_section_ptr)
8046             need_edit = TRUE;
8047
8048           rel += 2;
8049           if (rel + 1 == relend
8050               || (rel + 2 < relend
8051                   && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC))
8052             ++rel;
8053
8054           if (rel == relend)
8055             {
8056               if (sec->size == offset + 24)
8057                 {
8058                   need_pad = NULL;
8059                   break;
8060                 }
8061               if (sec->size == offset + 16)
8062                 {
8063                   cnt_16b++;
8064                   break;
8065                 }
8066               goto broken_opd;
8067             }
8068           else if (rel + 1 < relend
8069                    && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
8070                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
8071             {
8072               if (rel[0].r_offset == offset + 16)
8073                 cnt_16b++;
8074               else if (rel[0].r_offset != offset + 24)
8075                 goto broken_opd;
8076             }
8077           else
8078             goto broken_opd;
8079         }
8080
8081       add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
8082
8083       if (!broken && (need_edit || add_aux_fields))
8084         {
8085           Elf_Internal_Rela *write_rel;
8086           Elf_Internal_Shdr *rel_hdr;
8087           bfd_byte *rptr, *wptr;
8088           bfd_byte *new_contents;
8089           bfd_size_type amt;
8090
8091           new_contents = NULL;
8092           amt = OPD_NDX (sec->size) * sizeof (long);
8093           opd = &ppc64_elf_section_data (sec)->u.opd;
8094           opd->adjust = bfd_zalloc (sec->owner, amt);
8095           if (opd->adjust == NULL)
8096             return FALSE;
8097           ppc64_elf_section_data (sec)->sec_type = sec_opd;
8098
8099           /* This seems a waste of time as input .opd sections are all
8100              zeros as generated by gcc, but I suppose there's no reason
8101              this will always be so.  We might start putting something in
8102              the third word of .opd entries.  */
8103           if ((sec->flags & SEC_IN_MEMORY) == 0)
8104             {
8105               bfd_byte *loc;
8106               if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
8107                 {
8108                   if (loc != NULL)
8109                     free (loc);
8110                 error_ret:
8111                   if (local_syms != NULL
8112                       && symtab_hdr->contents != (unsigned char *) local_syms)
8113                     free (local_syms);
8114                   if (elf_section_data (sec)->relocs != relstart)
8115                     free (relstart);
8116                   return FALSE;
8117                 }
8118               sec->contents = loc;
8119               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8120             }
8121
8122           elf_section_data (sec)->relocs = relstart;
8123
8124           new_contents = sec->contents;
8125           if (add_aux_fields)
8126             {
8127               new_contents = bfd_malloc (sec->size + cnt_16b * 8);
8128               if (new_contents == NULL)
8129                 return FALSE;
8130               need_pad = NULL;
8131             }
8132           wptr = new_contents;
8133           rptr = sec->contents;
8134           write_rel = relstart;
8135           for (rel = relstart; rel < relend; )
8136             {
8137               unsigned long r_symndx;
8138               asection *sym_sec;
8139               struct elf_link_hash_entry *h;
8140               struct ppc_link_hash_entry *fdh = NULL;
8141               Elf_Internal_Sym *sym;
8142               long opd_ent_size;
8143               Elf_Internal_Rela *next_rel;
8144               bfd_boolean skip;
8145
8146               r_symndx = ELF64_R_SYM (rel->r_info);
8147               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8148                               r_symndx, ibfd))
8149                 goto error_ret;
8150
8151               next_rel = rel + 2;
8152               if (next_rel + 1 == relend
8153                   || (next_rel + 2 < relend
8154                       && ELF64_R_TYPE (next_rel[2].r_info) == R_PPC64_TOC))
8155                 ++next_rel;
8156
8157               /* See if the .opd entry is full 24 byte or
8158                  16 byte (with fd_aux entry overlapped with next
8159                  fd_func).  */
8160               opd_ent_size = 24;
8161               if (next_rel == relend)
8162                 {
8163                   if (sec->size == rel->r_offset + 16)
8164                     opd_ent_size = 16;
8165                 }
8166               else if (next_rel->r_offset == rel->r_offset + 16)
8167                 opd_ent_size = 16;
8168
8169               if (h != NULL
8170                   && h->root.root.string[0] == '.')
8171                 {
8172                   fdh = ((struct ppc_link_hash_entry *) h)->oh;
8173                   if (fdh != NULL)
8174                     {
8175                       fdh = ppc_follow_link (fdh);
8176                       if (fdh->elf.root.type != bfd_link_hash_defined
8177                           && fdh->elf.root.type != bfd_link_hash_defweak)
8178                         fdh = NULL;
8179                     }
8180                 }
8181
8182               skip = (sym_sec->owner != ibfd
8183                       || sym_sec->output_section == bfd_abs_section_ptr);
8184               if (skip)
8185                 {
8186                   if (fdh != NULL && sym_sec->owner == ibfd)
8187                     {
8188                       /* Arrange for the function descriptor sym
8189                          to be dropped.  */
8190                       fdh->elf.root.u.def.value = 0;
8191                       fdh->elf.root.u.def.section = sym_sec;
8192                     }
8193                   opd->adjust[OPD_NDX (rel->r_offset)] = -1;
8194
8195                   if (NO_OPD_RELOCS || bfd_link_relocatable (info))
8196                     rel = next_rel;
8197                   else
8198                     while (1)
8199                       {
8200                         if (!dec_dynrel_count (rel->r_info, sec, info,
8201                                                NULL, h, sym))
8202                           goto error_ret;
8203
8204                         if (++rel == next_rel)
8205                           break;
8206
8207                         r_symndx = ELF64_R_SYM (rel->r_info);
8208                         if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8209                                         r_symndx, ibfd))
8210                           goto error_ret;
8211                       }
8212                 }
8213               else
8214                 {
8215                   /* We'll be keeping this opd entry.  */
8216                   long adjust;
8217
8218                   if (fdh != NULL)
8219                     {
8220                       /* Redefine the function descriptor symbol to
8221                          this location in the opd section.  It is
8222                          necessary to update the value here rather
8223                          than using an array of adjustments as we do
8224                          for local symbols, because various places
8225                          in the generic ELF code use the value
8226                          stored in u.def.value.  */
8227                       fdh->elf.root.u.def.value = wptr - new_contents;
8228                       fdh->adjust_done = 1;
8229                     }
8230
8231                   /* Local syms are a bit tricky.  We could
8232                      tweak them as they can be cached, but
8233                      we'd need to look through the local syms
8234                      for the function descriptor sym which we
8235                      don't have at the moment.  So keep an
8236                      array of adjustments.  */
8237                   adjust = (wptr - new_contents) - (rptr - sec->contents);
8238                   opd->adjust[OPD_NDX (rel->r_offset)] = adjust;
8239
8240                   if (wptr != rptr)
8241                     memcpy (wptr, rptr, opd_ent_size);
8242                   wptr += opd_ent_size;
8243                   if (add_aux_fields && opd_ent_size == 16)
8244                     {
8245                       memset (wptr, '\0', 8);
8246                       wptr += 8;
8247                     }
8248
8249                   /* We need to adjust any reloc offsets to point to the
8250                      new opd entries.  */
8251                   for ( ; rel != next_rel; ++rel)
8252                     {
8253                       rel->r_offset += adjust;
8254                       if (write_rel != rel)
8255                         memcpy (write_rel, rel, sizeof (*rel));
8256                       ++write_rel;
8257                     }
8258                 }
8259
8260               rptr += opd_ent_size;
8261             }
8262
8263           sec->size = wptr - new_contents;
8264           sec->reloc_count = write_rel - relstart;
8265           if (add_aux_fields)
8266             {
8267               free (sec->contents);
8268               sec->contents = new_contents;
8269             }
8270
8271           /* Fudge the header size too, as this is used later in
8272              elf_bfd_final_link if we are emitting relocs.  */
8273           rel_hdr = _bfd_elf_single_rel_hdr (sec);
8274           rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
8275           some_edited = TRUE;
8276         }
8277       else if (elf_section_data (sec)->relocs != relstart)
8278         free (relstart);
8279
8280       if (local_syms != NULL
8281           && symtab_hdr->contents != (unsigned char *) local_syms)
8282         {
8283           if (!info->keep_memory)
8284             free (local_syms);
8285           else
8286             symtab_hdr->contents = (unsigned char *) local_syms;
8287         }
8288     }
8289
8290   if (some_edited)
8291     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
8292
8293   /* If we are doing a final link and the last .opd entry is just 16 byte
8294      long, add a 8 byte padding after it.  */
8295   if (need_pad != NULL && !bfd_link_relocatable (info))
8296     {
8297       bfd_byte *p;
8298
8299       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
8300         {
8301           BFD_ASSERT (need_pad->size > 0);
8302
8303           p = bfd_malloc (need_pad->size + 8);
8304           if (p == NULL)
8305             return FALSE;
8306
8307           if (! bfd_get_section_contents (need_pad->owner, need_pad,
8308                                           p, 0, need_pad->size))
8309             return FALSE;
8310
8311           need_pad->contents = p;
8312           need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8313         }
8314       else
8315         {
8316           p = bfd_realloc (need_pad->contents, need_pad->size + 8);
8317           if (p == NULL)
8318             return FALSE;
8319
8320           need_pad->contents = p;
8321         }
8322
8323       memset (need_pad->contents + need_pad->size, 0, 8);
8324       need_pad->size += 8;
8325     }
8326
8327   return TRUE;
8328 }
8329
8330 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
8331
8332 asection *
8333 ppc64_elf_tls_setup (struct bfd_link_info *info)
8334 {
8335   struct ppc_link_hash_table *htab;
8336
8337   htab = ppc_hash_table (info);
8338   if (htab == NULL)
8339     return NULL;
8340
8341   if (abiversion (info->output_bfd) == 1)
8342     htab->opd_abi = 1;
8343
8344   if (htab->params->no_multi_toc)
8345     htab->do_multi_toc = 0;
8346   else if (!htab->do_multi_toc)
8347     htab->params->no_multi_toc = 1;
8348
8349   if (htab->params->plt_localentry0 < 0)
8350     htab->params->plt_localentry0
8351       = elf_link_hash_lookup (&htab->elf, "GLIBC_2.26",
8352                               FALSE, FALSE, FALSE) != NULL;
8353
8354   htab->tls_get_addr = ((struct ppc_link_hash_entry *)
8355                         elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
8356                                               FALSE, FALSE, TRUE));
8357   /* Move dynamic linking info to the function descriptor sym.  */
8358   if (htab->tls_get_addr != NULL)
8359     func_desc_adjust (&htab->tls_get_addr->elf, info);
8360   htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
8361                            elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
8362                                                  FALSE, FALSE, TRUE));
8363   if (htab->params->tls_get_addr_opt)
8364     {
8365       struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
8366
8367       opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
8368                                   FALSE, FALSE, TRUE);
8369       if (opt != NULL)
8370         func_desc_adjust (opt, info);
8371       opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
8372                                      FALSE, FALSE, TRUE);
8373       if (opt_fd != NULL
8374           && (opt_fd->root.type == bfd_link_hash_defined
8375               || opt_fd->root.type == bfd_link_hash_defweak))
8376         {
8377           /* If glibc supports an optimized __tls_get_addr call stub,
8378              signalled by the presence of __tls_get_addr_opt, and we'll
8379              be calling __tls_get_addr via a plt call stub, then
8380              make __tls_get_addr point to __tls_get_addr_opt.  */
8381           tga_fd = &htab->tls_get_addr_fd->elf;
8382           if (htab->elf.dynamic_sections_created
8383               && tga_fd != NULL
8384               && (tga_fd->type == STT_FUNC
8385                   || tga_fd->needs_plt)
8386               && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
8387                    || UNDEFWEAK_NO_DYNAMIC_RELOC (info, tga_fd)))
8388             {
8389               struct plt_entry *ent;
8390
8391               for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
8392                 if (ent->plt.refcount > 0)
8393                   break;
8394               if (ent != NULL)
8395                 {
8396                   tga_fd->root.type = bfd_link_hash_indirect;
8397                   tga_fd->root.u.i.link = &opt_fd->root;
8398                   ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
8399                   opt_fd->mark = 1;
8400                   if (opt_fd->dynindx != -1)
8401                     {
8402                       /* Use __tls_get_addr_opt in dynamic relocations.  */
8403                       opt_fd->dynindx = -1;
8404                       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8405                                               opt_fd->dynstr_index);
8406                       if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8407                         return NULL;
8408                     }
8409                   htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8410                   tga = &htab->tls_get_addr->elf;
8411                   if (opt != NULL && tga != NULL)
8412                     {
8413                       tga->root.type = bfd_link_hash_indirect;
8414                       tga->root.u.i.link = &opt->root;
8415                       ppc64_elf_copy_indirect_symbol (info, opt, tga);
8416                       opt->mark = 1;
8417                       _bfd_elf_link_hash_hide_symbol (info, opt,
8418                                                       tga->forced_local);
8419                       htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8420                     }
8421                   htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8422                   htab->tls_get_addr_fd->is_func_descriptor = 1;
8423                   if (htab->tls_get_addr != NULL)
8424                     {
8425                       htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8426                       htab->tls_get_addr->is_func = 1;
8427                     }
8428                 }
8429             }
8430         }
8431       else if (htab->params->tls_get_addr_opt < 0)
8432         htab->params->tls_get_addr_opt = 0;
8433     }
8434   return _bfd_elf_tls_setup (info->output_bfd, info);
8435 }
8436
8437 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8438    HASH1 or HASH2.  */
8439
8440 static bfd_boolean
8441 branch_reloc_hash_match (const bfd *ibfd,
8442                          const Elf_Internal_Rela *rel,
8443                          const struct ppc_link_hash_entry *hash1,
8444                          const struct ppc_link_hash_entry *hash2)
8445 {
8446   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8447   enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8448   unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8449
8450   if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8451     {
8452       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8453       struct elf_link_hash_entry *h;
8454
8455       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8456       h = elf_follow_link (h);
8457       if (h == &hash1->elf || h == &hash2->elf)
8458         return TRUE;
8459     }
8460   return FALSE;
8461 }
8462
8463 /* Run through all the TLS relocs looking for optimization
8464    opportunities.  The linker has been hacked (see ppc64elf.em) to do
8465    a preliminary section layout so that we know the TLS segment
8466    offsets.  We can't optimize earlier because some optimizations need
8467    to know the tp offset, and we need to optimize before allocating
8468    dynamic relocations.  */
8469
8470 bfd_boolean
8471 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8472 {
8473   bfd *ibfd;
8474   asection *sec;
8475   struct ppc_link_hash_table *htab;
8476   unsigned char *toc_ref;
8477   int pass;
8478
8479   if (!bfd_link_executable (info))
8480     return TRUE;
8481
8482   htab = ppc_hash_table (info);
8483   if (htab == NULL)
8484     return FALSE;
8485
8486   /* Make two passes over the relocs.  On the first pass, mark toc
8487      entries involved with tls relocs, and check that tls relocs
8488      involved in setting up a tls_get_addr call are indeed followed by
8489      such a call.  If they are not, we can't do any tls optimization.
8490      On the second pass twiddle tls_mask flags to notify
8491      relocate_section that optimization can be done, and adjust got
8492      and plt refcounts.  */
8493   toc_ref = NULL;
8494   for (pass = 0; pass < 2; ++pass)
8495     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8496       {
8497         Elf_Internal_Sym *locsyms = NULL;
8498         asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8499
8500         for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8501           if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8502             {
8503               Elf_Internal_Rela *relstart, *rel, *relend;
8504               bfd_boolean found_tls_get_addr_arg = 0;
8505
8506               /* Read the relocations.  */
8507               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8508                                                     info->keep_memory);
8509               if (relstart == NULL)
8510                 {
8511                   free (toc_ref);
8512                   return FALSE;
8513                 }
8514
8515               relend = relstart + sec->reloc_count;
8516               for (rel = relstart; rel < relend; rel++)
8517                 {
8518                   enum elf_ppc64_reloc_type r_type;
8519                   unsigned long r_symndx;
8520                   struct elf_link_hash_entry *h;
8521                   Elf_Internal_Sym *sym;
8522                   asection *sym_sec;
8523                   unsigned char *tls_mask;
8524                   unsigned char tls_set, tls_clear, tls_type = 0;
8525                   bfd_vma value;
8526                   bfd_boolean ok_tprel, is_local;
8527                   long toc_ref_index = 0;
8528                   int expecting_tls_get_addr = 0;
8529                   bfd_boolean ret = FALSE;
8530
8531                   r_symndx = ELF64_R_SYM (rel->r_info);
8532                   if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8533                                   r_symndx, ibfd))
8534                     {
8535                     err_free_rel:
8536                       if (elf_section_data (sec)->relocs != relstart)
8537                         free (relstart);
8538                       if (toc_ref != NULL)
8539                         free (toc_ref);
8540                       if (locsyms != NULL
8541                           && (elf_symtab_hdr (ibfd).contents
8542                               != (unsigned char *) locsyms))
8543                         free (locsyms);
8544                       return ret;
8545                     }
8546
8547                   if (h != NULL)
8548                     {
8549                       if (h->root.type == bfd_link_hash_defined
8550                           || h->root.type == bfd_link_hash_defweak)
8551                         value = h->root.u.def.value;
8552                       else if (h->root.type == bfd_link_hash_undefweak)
8553                         value = 0;
8554                       else
8555                         {
8556                           found_tls_get_addr_arg = 0;
8557                           continue;
8558                         }
8559                     }
8560                   else
8561                     /* Symbols referenced by TLS relocs must be of type
8562                        STT_TLS.  So no need for .opd local sym adjust.  */
8563                     value = sym->st_value;
8564
8565                   ok_tprel = FALSE;
8566                   is_local = FALSE;
8567                   if (h == NULL
8568                       || !h->def_dynamic)
8569                     {
8570                       is_local = TRUE;
8571                       if (h != NULL
8572                           && h->root.type == bfd_link_hash_undefweak)
8573                         ok_tprel = TRUE;
8574                       else if (sym_sec != NULL
8575                                && sym_sec->output_section != NULL)
8576                         {
8577                           value += sym_sec->output_offset;
8578                           value += sym_sec->output_section->vma;
8579                           value -= htab->elf.tls_sec->vma;
8580                           ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8581                                       < (bfd_vma) 1 << 32);
8582                         }
8583                     }
8584
8585                   r_type = ELF64_R_TYPE (rel->r_info);
8586                   /* If this section has old-style __tls_get_addr calls
8587                      without marker relocs, then check that each
8588                      __tls_get_addr call reloc is preceded by a reloc
8589                      that conceivably belongs to the __tls_get_addr arg
8590                      setup insn.  If we don't find matching arg setup
8591                      relocs, don't do any tls optimization.  */
8592                   if (pass == 0
8593                       && sec->has_tls_get_addr_call
8594                       && h != NULL
8595                       && (h == &htab->tls_get_addr->elf
8596                           || h == &htab->tls_get_addr_fd->elf)
8597                       && !found_tls_get_addr_arg
8598                       && is_branch_reloc (r_type))
8599                     {
8600                       info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8601                                                 "TLS optimization disabled\n"),
8602                                               ibfd, sec, rel->r_offset);
8603                       ret = TRUE;
8604                       goto err_free_rel;
8605                     }
8606
8607                   found_tls_get_addr_arg = 0;
8608                   switch (r_type)
8609                     {
8610                     case R_PPC64_GOT_TLSLD16:
8611                     case R_PPC64_GOT_TLSLD16_LO:
8612                       expecting_tls_get_addr = 1;
8613                       found_tls_get_addr_arg = 1;
8614                       /* Fall through.  */
8615
8616                     case R_PPC64_GOT_TLSLD16_HI:
8617                     case R_PPC64_GOT_TLSLD16_HA:
8618                       /* These relocs should never be against a symbol
8619                          defined in a shared lib.  Leave them alone if
8620                          that turns out to be the case.  */
8621                       if (!is_local)
8622                         continue;
8623
8624                       /* LD -> LE */
8625                       tls_set = 0;
8626                       tls_clear = TLS_LD;
8627                       tls_type = TLS_TLS | TLS_LD;
8628                       break;
8629
8630                     case R_PPC64_GOT_TLSGD16:
8631                     case R_PPC64_GOT_TLSGD16_LO:
8632                       expecting_tls_get_addr = 1;
8633                       found_tls_get_addr_arg = 1;
8634                       /* Fall through. */
8635
8636                     case R_PPC64_GOT_TLSGD16_HI:
8637                     case R_PPC64_GOT_TLSGD16_HA:
8638                       if (ok_tprel)
8639                         /* GD -> LE */
8640                         tls_set = 0;
8641                       else
8642                         /* GD -> IE */
8643                         tls_set = TLS_TLS | TLS_TPRELGD;
8644                       tls_clear = TLS_GD;
8645                       tls_type = TLS_TLS | TLS_GD;
8646                       break;
8647
8648                     case R_PPC64_GOT_TPREL16_DS:
8649                     case R_PPC64_GOT_TPREL16_LO_DS:
8650                     case R_PPC64_GOT_TPREL16_HI:
8651                     case R_PPC64_GOT_TPREL16_HA:
8652                       if (ok_tprel)
8653                         {
8654                           /* IE -> LE */
8655                           tls_set = 0;
8656                           tls_clear = TLS_TPREL;
8657                           tls_type = TLS_TLS | TLS_TPREL;
8658                           break;
8659                         }
8660                       continue;
8661
8662                     case R_PPC64_TLSGD:
8663                     case R_PPC64_TLSLD:
8664                       found_tls_get_addr_arg = 1;
8665                       /* Fall through.  */
8666
8667                     case R_PPC64_TLS:
8668                     case R_PPC64_TOC16:
8669                     case R_PPC64_TOC16_LO:
8670                       if (sym_sec == NULL || sym_sec != toc)
8671                         continue;
8672
8673                       /* Mark this toc entry as referenced by a TLS
8674                          code sequence.  We can do that now in the
8675                          case of R_PPC64_TLS, and after checking for
8676                          tls_get_addr for the TOC16 relocs.  */
8677                       if (toc_ref == NULL)
8678                         toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8679                       if (toc_ref == NULL)
8680                         goto err_free_rel;
8681
8682                       if (h != NULL)
8683                         value = h->root.u.def.value;
8684                       else
8685                         value = sym->st_value;
8686                       value += rel->r_addend;
8687                       if (value % 8 != 0)
8688                         continue;
8689                       BFD_ASSERT (value < toc->size
8690                                   && toc->output_offset % 8 == 0);
8691                       toc_ref_index = (value + toc->output_offset) / 8;
8692                       if (r_type == R_PPC64_TLS
8693                           || r_type == R_PPC64_TLSGD
8694                           || r_type == R_PPC64_TLSLD)
8695                         {
8696                           toc_ref[toc_ref_index] = 1;
8697                           continue;
8698                         }
8699
8700                       if (pass != 0 && toc_ref[toc_ref_index] == 0)
8701                         continue;
8702
8703                       tls_set = 0;
8704                       tls_clear = 0;
8705                       expecting_tls_get_addr = 2;
8706                       break;
8707
8708                     case R_PPC64_TPREL64:
8709                       if (pass == 0
8710                           || sec != toc
8711                           || toc_ref == NULL
8712                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8713                         continue;
8714                       if (ok_tprel)
8715                         {
8716                           /* IE -> LE */
8717                           tls_set = TLS_EXPLICIT;
8718                           tls_clear = TLS_TPREL;
8719                           break;
8720                         }
8721                       continue;
8722
8723                     case R_PPC64_DTPMOD64:
8724                       if (pass == 0
8725                           || sec != toc
8726                           || toc_ref == NULL
8727                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8728                         continue;
8729                       if (rel + 1 < relend
8730                           && (rel[1].r_info
8731                               == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8732                           && rel[1].r_offset == rel->r_offset + 8)
8733                         {
8734                           if (ok_tprel)
8735                             /* GD -> LE */
8736                             tls_set = TLS_EXPLICIT | TLS_GD;
8737                           else
8738                             /* GD -> IE */
8739                             tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8740                           tls_clear = TLS_GD;
8741                         }
8742                       else
8743                         {
8744                           if (!is_local)
8745                             continue;
8746
8747                           /* LD -> LE */
8748                           tls_set = TLS_EXPLICIT;
8749                           tls_clear = TLS_LD;
8750                         }
8751                       break;
8752
8753                     default:
8754                       continue;
8755                     }
8756
8757                   if (pass == 0)
8758                     {
8759                       if (!expecting_tls_get_addr
8760                           || !sec->has_tls_get_addr_call)
8761                         continue;
8762
8763                       if (rel + 1 < relend
8764                           && branch_reloc_hash_match (ibfd, rel + 1,
8765                                                       htab->tls_get_addr,
8766                                                       htab->tls_get_addr_fd))
8767                         {
8768                           if (expecting_tls_get_addr == 2)
8769                             {
8770                               /* Check for toc tls entries.  */
8771                               unsigned char *toc_tls;
8772                               int retval;
8773
8774                               retval = get_tls_mask (&toc_tls, NULL, NULL,
8775                                                      &locsyms,
8776                                                      rel, ibfd);
8777                               if (retval == 0)
8778                                 goto err_free_rel;
8779                               if (toc_tls != NULL)
8780                                 {
8781                                   if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8782                                     found_tls_get_addr_arg = 1;
8783                                   if (retval > 1)
8784                                     toc_ref[toc_ref_index] = 1;
8785                                 }
8786                             }
8787                           continue;
8788                         }
8789
8790                       if (expecting_tls_get_addr != 1)
8791                         continue;
8792
8793                       /* Uh oh, we didn't find the expected call.  We
8794                          could just mark this symbol to exclude it
8795                          from tls optimization but it's safer to skip
8796                          the entire optimization.  */
8797                       /* xgettext:c-format */
8798                       info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8799                                                 "TLS optimization disabled\n"),
8800                                               ibfd, sec, rel->r_offset);
8801                       ret = TRUE;
8802                       goto err_free_rel;
8803                     }
8804
8805                   if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8806                     {
8807                       struct plt_entry *ent;
8808                       for (ent = htab->tls_get_addr->elf.plt.plist;
8809                            ent != NULL;
8810                            ent = ent->next)
8811                         if (ent->addend == 0)
8812                           {
8813                             if (ent->plt.refcount > 0)
8814                               {
8815                                 ent->plt.refcount -= 1;
8816                                 expecting_tls_get_addr = 0;
8817                               }
8818                             break;
8819                           }
8820                     }
8821
8822                   if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8823                     {
8824                       struct plt_entry *ent;
8825                       for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8826                            ent != NULL;
8827                            ent = ent->next)
8828                         if (ent->addend == 0)
8829                           {
8830                             if (ent->plt.refcount > 0)
8831                               ent->plt.refcount -= 1;
8832                             break;
8833                           }
8834                     }
8835
8836                   if (tls_clear == 0)
8837                     continue;
8838
8839                   if ((tls_set & TLS_EXPLICIT) == 0)
8840                     {
8841                       struct got_entry *ent;
8842
8843                       /* Adjust got entry for this reloc.  */
8844                       if (h != NULL)
8845                         ent = h->got.glist;
8846                       else
8847                         ent = elf_local_got_ents (ibfd)[r_symndx];
8848
8849                       for (; ent != NULL; ent = ent->next)
8850                         if (ent->addend == rel->r_addend
8851                             && ent->owner == ibfd
8852                             && ent->tls_type == tls_type)
8853                           break;
8854                       if (ent == NULL)
8855                         abort ();
8856
8857                       if (tls_set == 0)
8858                         {
8859                           /* We managed to get rid of a got entry.  */
8860                           if (ent->got.refcount > 0)
8861                             ent->got.refcount -= 1;
8862                         }
8863                     }
8864                   else
8865                     {
8866                       /* If we got rid of a DTPMOD/DTPREL reloc pair then
8867                          we'll lose one or two dyn relocs.  */
8868                       if (!dec_dynrel_count (rel->r_info, sec, info,
8869                                              NULL, h, sym))
8870                         return FALSE;
8871
8872                       if (tls_set == (TLS_EXPLICIT | TLS_GD))
8873                         {
8874                           if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8875                                                  NULL, h, sym))
8876                             return FALSE;
8877                         }
8878                     }
8879
8880                   *tls_mask |= tls_set;
8881                   *tls_mask &= ~tls_clear;
8882                 }
8883
8884               if (elf_section_data (sec)->relocs != relstart)
8885                 free (relstart);
8886             }
8887
8888         if (locsyms != NULL
8889             && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8890           {
8891             if (!info->keep_memory)
8892               free (locsyms);
8893             else
8894               elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8895           }
8896       }
8897
8898   if (toc_ref != NULL)
8899     free (toc_ref);
8900   return TRUE;
8901 }
8902
8903 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8904    the values of any global symbols in a toc section that has been
8905    edited.  Globals in toc sections should be a rarity, so this function
8906    sets a flag if any are found in toc sections other than the one just
8907    edited, so that further hash table traversals can be avoided.  */
8908
8909 struct adjust_toc_info
8910 {
8911   asection *toc;
8912   unsigned long *skip;
8913   bfd_boolean global_toc_syms;
8914 };
8915
8916 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8917
8918 static bfd_boolean
8919 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8920 {
8921   struct ppc_link_hash_entry *eh;
8922   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8923   unsigned long i;
8924
8925   if (h->root.type != bfd_link_hash_defined
8926       && h->root.type != bfd_link_hash_defweak)
8927     return TRUE;
8928
8929   eh = (struct ppc_link_hash_entry *) h;
8930   if (eh->adjust_done)
8931     return TRUE;
8932
8933   if (eh->elf.root.u.def.section == toc_inf->toc)
8934     {
8935       if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8936         i = toc_inf->toc->rawsize >> 3;
8937       else
8938         i = eh->elf.root.u.def.value >> 3;
8939
8940       if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8941         {
8942           _bfd_error_handler
8943             (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8944           do
8945             ++i;
8946           while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8947           eh->elf.root.u.def.value = (bfd_vma) i << 3;
8948         }
8949
8950       eh->elf.root.u.def.value -= toc_inf->skip[i];
8951       eh->adjust_done = 1;
8952     }
8953   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8954     toc_inf->global_toc_syms = TRUE;
8955
8956   return TRUE;
8957 }
8958
8959 /* Return TRUE iff INSN with a relocation of R_TYPE is one we expect
8960    on a _LO variety toc/got reloc.  */
8961
8962 static bfd_boolean
8963 ok_lo_toc_insn (unsigned int insn, enum elf_ppc64_reloc_type r_type)
8964 {
8965   return ((insn & (0x3f << 26)) == 12u << 26 /* addic */
8966           || (insn & (0x3f << 26)) == 14u << 26 /* addi */
8967           || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8968           || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8969           || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8970           || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8971           || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8972           || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8973           || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8974           || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8975           || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8976           || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8977           || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8978           || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8979           || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8980           || (insn & (0x3f << 26)) == 56u << 26 /* lq,lfq */
8981           || ((insn & (0x3f << 26)) == 57u << 26 /* lxsd,lxssp,lfdp */
8982               /* Exclude lfqu by testing reloc.  If relocs are ever
8983                  defined for the reduced D field in psq_lu then those
8984                  will need testing too.  */
8985               && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
8986           || ((insn & (0x3f << 26)) == 58u << 26 /* ld,lwa */
8987               && (insn & 1) == 0)
8988           || (insn & (0x3f << 26)) == 60u << 26 /* stfq */
8989           || ((insn & (0x3f << 26)) == 61u << 26 /* lxv,stx{v,sd,ssp},stfdp */
8990               /* Exclude stfqu.  psq_stu as above for psq_lu.  */
8991               && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
8992           || ((insn & (0x3f << 26)) == 62u << 26 /* std,stq */
8993               && (insn & 1) == 0));
8994 }
8995
8996 /* Examine all relocs referencing .toc sections in order to remove
8997    unused .toc entries.  */
8998
8999 bfd_boolean
9000 ppc64_elf_edit_toc (struct bfd_link_info *info)
9001 {
9002   bfd *ibfd;
9003   struct adjust_toc_info toc_inf;
9004   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9005
9006   htab->do_toc_opt = 1;
9007   toc_inf.global_toc_syms = TRUE;
9008   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9009     {
9010       asection *toc, *sec;
9011       Elf_Internal_Shdr *symtab_hdr;
9012       Elf_Internal_Sym *local_syms;
9013       Elf_Internal_Rela *relstart, *rel, *toc_relocs;
9014       unsigned long *skip, *drop;
9015       unsigned char *used;
9016       unsigned char *keep, last, some_unused;
9017
9018       if (!is_ppc64_elf (ibfd))
9019         continue;
9020
9021       toc = bfd_get_section_by_name (ibfd, ".toc");
9022       if (toc == NULL
9023           || toc->size == 0
9024           || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
9025           || discarded_section (toc))
9026         continue;
9027
9028       toc_relocs = NULL;
9029       local_syms = NULL;
9030       symtab_hdr = &elf_symtab_hdr (ibfd);
9031
9032       /* Look at sections dropped from the final link.  */
9033       skip = NULL;
9034       relstart = NULL;
9035       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9036         {
9037           if (sec->reloc_count == 0
9038               || !discarded_section (sec)
9039               || get_opd_info (sec)
9040               || (sec->flags & SEC_ALLOC) == 0
9041               || (sec->flags & SEC_DEBUGGING) != 0)
9042             continue;
9043
9044           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
9045           if (relstart == NULL)
9046             goto error_ret;
9047
9048           /* Run through the relocs to see which toc entries might be
9049              unused.  */
9050           for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9051             {
9052               enum elf_ppc64_reloc_type r_type;
9053               unsigned long r_symndx;
9054               asection *sym_sec;
9055               struct elf_link_hash_entry *h;
9056               Elf_Internal_Sym *sym;
9057               bfd_vma val;
9058
9059               r_type = ELF64_R_TYPE (rel->r_info);
9060               switch (r_type)
9061                 {
9062                 default:
9063                   continue;
9064
9065                 case R_PPC64_TOC16:
9066                 case R_PPC64_TOC16_LO:
9067                 case R_PPC64_TOC16_HI:
9068                 case R_PPC64_TOC16_HA:
9069                 case R_PPC64_TOC16_DS:
9070                 case R_PPC64_TOC16_LO_DS:
9071                   break;
9072                 }
9073
9074               r_symndx = ELF64_R_SYM (rel->r_info);
9075               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9076                               r_symndx, ibfd))
9077                 goto error_ret;
9078
9079               if (sym_sec != toc)
9080                 continue;
9081
9082               if (h != NULL)
9083                 val = h->root.u.def.value;
9084               else
9085                 val = sym->st_value;
9086               val += rel->r_addend;
9087
9088               if (val >= toc->size)
9089                 continue;
9090
9091               /* Anything in the toc ought to be aligned to 8 bytes.
9092                  If not, don't mark as unused.  */
9093               if (val & 7)
9094                 continue;
9095
9096               if (skip == NULL)
9097                 {
9098                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9099                   if (skip == NULL)
9100                     goto error_ret;
9101                 }
9102
9103               skip[val >> 3] = ref_from_discarded;
9104             }
9105
9106           if (elf_section_data (sec)->relocs != relstart)
9107             free (relstart);
9108         }
9109
9110       /* For largetoc loads of address constants, we can convert
9111          .  addis rx,2,addr@got@ha
9112          .  ld ry,addr@got@l(rx)
9113          to
9114          .  addis rx,2,addr@toc@ha
9115          .  addi ry,rx,addr@toc@l
9116          when addr is within 2G of the toc pointer.  This then means
9117          that the word storing "addr" in the toc is no longer needed.  */
9118
9119       if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
9120           && toc->output_section->rawsize < (bfd_vma) 1 << 31
9121           && toc->reloc_count != 0)
9122         {
9123           /* Read toc relocs.  */
9124           toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9125                                                   info->keep_memory);
9126           if (toc_relocs == NULL)
9127             goto error_ret;
9128
9129           for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9130             {
9131               enum elf_ppc64_reloc_type r_type;
9132               unsigned long r_symndx;
9133               asection *sym_sec;
9134               struct elf_link_hash_entry *h;
9135               Elf_Internal_Sym *sym;
9136               bfd_vma val, addr;
9137
9138               r_type = ELF64_R_TYPE (rel->r_info);
9139               if (r_type != R_PPC64_ADDR64)
9140                 continue;
9141
9142               r_symndx = ELF64_R_SYM (rel->r_info);
9143               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9144                               r_symndx, ibfd))
9145                 goto error_ret;
9146
9147               if (sym_sec == NULL
9148                   || sym_sec->output_section == NULL
9149                   || discarded_section (sym_sec))
9150                 continue;
9151
9152               if (!SYMBOL_REFERENCES_LOCAL (info, h))
9153                 continue;
9154
9155               if (h != NULL)
9156                 {
9157                   if (h->type == STT_GNU_IFUNC)
9158                     continue;
9159                   val = h->root.u.def.value;
9160                 }
9161               else
9162                 {
9163                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
9164                     continue;
9165                   val = sym->st_value;
9166                 }
9167               val += rel->r_addend;
9168               val += sym_sec->output_section->vma + sym_sec->output_offset;
9169
9170               /* We don't yet know the exact toc pointer value, but we
9171                  know it will be somewhere in the toc section.  Don't
9172                  optimize if the difference from any possible toc
9173                  pointer is outside [ff..f80008000, 7fff7fff].  */
9174               addr = toc->output_section->vma + TOC_BASE_OFF;
9175               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9176                 continue;
9177
9178               addr = toc->output_section->vma + toc->output_section->rawsize;
9179               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9180                 continue;
9181
9182               if (skip == NULL)
9183                 {
9184                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9185                   if (skip == NULL)
9186                     goto error_ret;
9187                 }
9188
9189               skip[rel->r_offset >> 3]
9190                 |= can_optimize | ((rel - toc_relocs) << 2);
9191             }
9192         }
9193
9194       if (skip == NULL)
9195         continue;
9196
9197       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
9198       if (used == NULL)
9199         {
9200         error_ret:
9201           if (local_syms != NULL
9202               && symtab_hdr->contents != (unsigned char *) local_syms)
9203             free (local_syms);
9204           if (sec != NULL
9205               && relstart != NULL
9206               && elf_section_data (sec)->relocs != relstart)
9207             free (relstart);
9208           if (toc_relocs != NULL
9209               && elf_section_data (toc)->relocs != toc_relocs)
9210             free (toc_relocs);
9211           if (skip != NULL)
9212             free (skip);
9213           return FALSE;
9214         }
9215
9216       /* Now check all kept sections that might reference the toc.
9217          Check the toc itself last.  */
9218       for (sec = (ibfd->sections == toc && toc->next ? toc->next
9219                   : ibfd->sections);
9220            sec != NULL;
9221            sec = (sec == toc ? NULL
9222                   : sec->next == NULL ? toc
9223                   : sec->next == toc && toc->next ? toc->next
9224                   : sec->next))
9225         {
9226           int repeat;
9227
9228           if (sec->reloc_count == 0
9229               || discarded_section (sec)
9230               || get_opd_info (sec)
9231               || (sec->flags & SEC_ALLOC) == 0
9232               || (sec->flags & SEC_DEBUGGING) != 0)
9233             continue;
9234
9235           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9236                                                 info->keep_memory);
9237           if (relstart == NULL)
9238             {
9239               free (used);
9240               goto error_ret;
9241             }
9242
9243           /* Mark toc entries referenced as used.  */
9244           do
9245             {
9246               repeat = 0;
9247               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9248                 {
9249                   enum elf_ppc64_reloc_type r_type;
9250                   unsigned long r_symndx;
9251                   asection *sym_sec;
9252                   struct elf_link_hash_entry *h;
9253                   Elf_Internal_Sym *sym;
9254                   bfd_vma val;
9255                   enum {no_check, check_lo, check_ha} insn_check;
9256
9257                   r_type = ELF64_R_TYPE (rel->r_info);
9258                   switch (r_type)
9259                     {
9260                     default:
9261                       insn_check = no_check;
9262                       break;
9263
9264                     case R_PPC64_GOT_TLSLD16_HA:
9265                     case R_PPC64_GOT_TLSGD16_HA:
9266                     case R_PPC64_GOT_TPREL16_HA:
9267                     case R_PPC64_GOT_DTPREL16_HA:
9268                     case R_PPC64_GOT16_HA:
9269                     case R_PPC64_TOC16_HA:
9270                       insn_check = check_ha;
9271                       break;
9272
9273                     case R_PPC64_GOT_TLSLD16_LO:
9274                     case R_PPC64_GOT_TLSGD16_LO:
9275                     case R_PPC64_GOT_TPREL16_LO_DS:
9276                     case R_PPC64_GOT_DTPREL16_LO_DS:
9277                     case R_PPC64_GOT16_LO:
9278                     case R_PPC64_GOT16_LO_DS:
9279                     case R_PPC64_TOC16_LO:
9280                     case R_PPC64_TOC16_LO_DS:
9281                       insn_check = check_lo;
9282                       break;
9283                     }
9284
9285                   if (insn_check != no_check)
9286                     {
9287                       bfd_vma off = rel->r_offset & ~3;
9288                       unsigned char buf[4];
9289                       unsigned int insn;
9290
9291                       if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
9292                         {
9293                           free (used);
9294                           goto error_ret;
9295                         }
9296                       insn = bfd_get_32 (ibfd, buf);
9297                       if (insn_check == check_lo
9298                           ? !ok_lo_toc_insn (insn, r_type)
9299                           : ((insn & ((0x3f << 26) | 0x1f << 16))
9300                              != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9301                         {
9302                           char str[12];
9303
9304                           ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
9305                           sprintf (str, "%#08x", insn);
9306                           info->callbacks->einfo
9307                             /* xgettext:c-format */
9308                             (_("%H: toc optimization is not supported for"
9309                                " %s instruction.\n"),
9310                              ibfd, sec, rel->r_offset & ~3, str);
9311                         }
9312                     }
9313
9314                   switch (r_type)
9315                     {
9316                     case R_PPC64_TOC16:
9317                     case R_PPC64_TOC16_LO:
9318                     case R_PPC64_TOC16_HI:
9319                     case R_PPC64_TOC16_HA:
9320                     case R_PPC64_TOC16_DS:
9321                     case R_PPC64_TOC16_LO_DS:
9322                       /* In case we're taking addresses of toc entries.  */
9323                     case R_PPC64_ADDR64:
9324                       break;
9325
9326                     default:
9327                       continue;
9328                     }
9329
9330                   r_symndx = ELF64_R_SYM (rel->r_info);
9331                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9332                                   r_symndx, ibfd))
9333                     {
9334                       free (used);
9335                       goto error_ret;
9336                     }
9337
9338                   if (sym_sec != toc)
9339                     continue;
9340
9341                   if (h != NULL)
9342                     val = h->root.u.def.value;
9343                   else
9344                     val = sym->st_value;
9345                   val += rel->r_addend;
9346
9347                   if (val >= toc->size)
9348                     continue;
9349
9350                   if ((skip[val >> 3] & can_optimize) != 0)
9351                     {
9352                       bfd_vma off;
9353                       unsigned char opc;
9354
9355                       switch (r_type)
9356                         {
9357                         case R_PPC64_TOC16_HA:
9358                           break;
9359
9360                         case R_PPC64_TOC16_LO_DS:
9361                           off = rel->r_offset;
9362                           off += (bfd_big_endian (ibfd) ? -2 : 3);
9363                           if (!bfd_get_section_contents (ibfd, sec, &opc,
9364                                                          off, 1))
9365                             {
9366                               free (used);
9367                               goto error_ret;
9368                             }
9369                           if ((opc & (0x3f << 2)) == (58u << 2))
9370                             break;
9371                           /* Fall through.  */
9372
9373                         default:
9374                           /* Wrong sort of reloc, or not a ld.  We may
9375                              as well clear ref_from_discarded too.  */
9376                           skip[val >> 3] = 0;
9377                         }
9378                     }
9379
9380                   if (sec != toc)
9381                     used[val >> 3] = 1;
9382                   /* For the toc section, we only mark as used if this
9383                      entry itself isn't unused.  */
9384                   else if ((used[rel->r_offset >> 3]
9385                             || !(skip[rel->r_offset >> 3] & ref_from_discarded))
9386                            && !used[val >> 3])
9387                     {
9388                       /* Do all the relocs again, to catch reference
9389                          chains.  */
9390                       repeat = 1;
9391                       used[val >> 3] = 1;
9392                     }
9393                 }
9394             }
9395           while (repeat);
9396
9397           if (elf_section_data (sec)->relocs != relstart)
9398             free (relstart);
9399         }
9400
9401       /* Merge the used and skip arrays.  Assume that TOC
9402          doublewords not appearing as either used or unused belong
9403          to an entry more than one doubleword in size.  */
9404       for (drop = skip, keep = used, last = 0, some_unused = 0;
9405            drop < skip + (toc->size + 7) / 8;
9406            ++drop, ++keep)
9407         {
9408           if (*keep)
9409             {
9410               *drop &= ~ref_from_discarded;
9411               if ((*drop & can_optimize) != 0)
9412                 some_unused = 1;
9413               last = 0;
9414             }
9415           else if ((*drop & ref_from_discarded) != 0)
9416             {
9417               some_unused = 1;
9418               last = ref_from_discarded;
9419             }
9420           else
9421             *drop = last;
9422         }
9423
9424       free (used);
9425
9426       if (some_unused)
9427         {
9428           bfd_byte *contents, *src;
9429           unsigned long off;
9430           Elf_Internal_Sym *sym;
9431           bfd_boolean local_toc_syms = FALSE;
9432
9433           /* Shuffle the toc contents, and at the same time convert the
9434              skip array from booleans into offsets.  */
9435           if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9436             goto error_ret;
9437
9438           elf_section_data (toc)->this_hdr.contents = contents;
9439
9440           for (src = contents, off = 0, drop = skip;
9441                src < contents + toc->size;
9442                src += 8, ++drop)
9443             {
9444               if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9445                 off += 8;
9446               else if (off != 0)
9447                 {
9448                   *drop = off;
9449                   memcpy (src - off, src, 8);
9450                 }
9451             }
9452           *drop = off;
9453           toc->rawsize = toc->size;
9454           toc->size = src - contents - off;
9455
9456           /* Adjust addends for relocs against the toc section sym,
9457              and optimize any accesses we can.  */
9458           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9459             {
9460               if (sec->reloc_count == 0
9461                   || discarded_section (sec))
9462                 continue;
9463
9464               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9465                                                     info->keep_memory);
9466               if (relstart == NULL)
9467                 goto error_ret;
9468
9469               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9470                 {
9471                   enum elf_ppc64_reloc_type r_type;
9472                   unsigned long r_symndx;
9473                   asection *sym_sec;
9474                   struct elf_link_hash_entry *h;
9475                   bfd_vma val;
9476
9477                   r_type = ELF64_R_TYPE (rel->r_info);
9478                   switch (r_type)
9479                     {
9480                     default:
9481                       continue;
9482
9483                     case R_PPC64_TOC16:
9484                     case R_PPC64_TOC16_LO:
9485                     case R_PPC64_TOC16_HI:
9486                     case R_PPC64_TOC16_HA:
9487                     case R_PPC64_TOC16_DS:
9488                     case R_PPC64_TOC16_LO_DS:
9489                     case R_PPC64_ADDR64:
9490                       break;
9491                     }
9492
9493                   r_symndx = ELF64_R_SYM (rel->r_info);
9494                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9495                                   r_symndx, ibfd))
9496                     goto error_ret;
9497
9498                   if (sym_sec != toc)
9499                     continue;
9500
9501                   if (h != NULL)
9502                     val = h->root.u.def.value;
9503                   else
9504                     {
9505                       val = sym->st_value;
9506                       if (val != 0)
9507                         local_toc_syms = TRUE;
9508                     }
9509
9510                   val += rel->r_addend;
9511
9512                   if (val > toc->rawsize)
9513                     val = toc->rawsize;
9514                   else if ((skip[val >> 3] & ref_from_discarded) != 0)
9515                     continue;
9516                   else if ((skip[val >> 3] & can_optimize) != 0)
9517                     {
9518                       Elf_Internal_Rela *tocrel
9519                         = toc_relocs + (skip[val >> 3] >> 2);
9520                       unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9521
9522                       switch (r_type)
9523                         {
9524                         case R_PPC64_TOC16_HA:
9525                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9526                           break;
9527
9528                         case R_PPC64_TOC16_LO_DS:
9529                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9530                           break;
9531
9532                         default:
9533                           if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9534                             ppc_howto_init ();
9535                           info->callbacks->einfo
9536                             /* xgettext:c-format */
9537                             (_("%H: %s references "
9538                                "optimized away TOC entry\n"),
9539                              ibfd, sec, rel->r_offset,
9540                              ppc64_elf_howto_table[r_type]->name);
9541                           bfd_set_error (bfd_error_bad_value);
9542                           goto error_ret;
9543                         }
9544                       rel->r_addend = tocrel->r_addend;
9545                       elf_section_data (sec)->relocs = relstart;
9546                       continue;
9547                     }
9548
9549                   if (h != NULL || sym->st_value != 0)
9550                     continue;
9551
9552                   rel->r_addend -= skip[val >> 3];
9553                   elf_section_data (sec)->relocs = relstart;
9554                 }
9555
9556               if (elf_section_data (sec)->relocs != relstart)
9557                 free (relstart);
9558             }
9559
9560           /* We shouldn't have local or global symbols defined in the TOC,
9561              but handle them anyway.  */
9562           if (local_syms != NULL)
9563             for (sym = local_syms;
9564                  sym < local_syms + symtab_hdr->sh_info;
9565                  ++sym)
9566               if (sym->st_value != 0
9567                   && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9568                 {
9569                   unsigned long i;
9570
9571                   if (sym->st_value > toc->rawsize)
9572                     i = toc->rawsize >> 3;
9573                   else
9574                     i = sym->st_value >> 3;
9575
9576                   if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9577                     {
9578                       if (local_toc_syms)
9579                         _bfd_error_handler
9580                           (_("%s defined on removed toc entry"),
9581                            bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9582                       do
9583                         ++i;
9584                       while ((skip[i] & (ref_from_discarded | can_optimize)));
9585                       sym->st_value = (bfd_vma) i << 3;
9586                     }
9587
9588                   sym->st_value -= skip[i];
9589                   symtab_hdr->contents = (unsigned char *) local_syms;
9590                 }
9591
9592           /* Adjust any global syms defined in this toc input section.  */
9593           if (toc_inf.global_toc_syms)
9594             {
9595               toc_inf.toc = toc;
9596               toc_inf.skip = skip;
9597               toc_inf.global_toc_syms = FALSE;
9598               elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9599                                       &toc_inf);
9600             }
9601
9602           if (toc->reloc_count != 0)
9603             {
9604               Elf_Internal_Shdr *rel_hdr;
9605               Elf_Internal_Rela *wrel;
9606               bfd_size_type sz;
9607
9608               /* Remove unused toc relocs, and adjust those we keep.  */
9609               if (toc_relocs == NULL)
9610                 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9611                                                         info->keep_memory);
9612               if (toc_relocs == NULL)
9613                 goto error_ret;
9614
9615               wrel = toc_relocs;
9616               for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9617                 if ((skip[rel->r_offset >> 3]
9618                      & (ref_from_discarded | can_optimize)) == 0)
9619                   {
9620                     wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9621                     wrel->r_info = rel->r_info;
9622                     wrel->r_addend = rel->r_addend;
9623                     ++wrel;
9624                   }
9625                 else if (!dec_dynrel_count (rel->r_info, toc, info,
9626                                             &local_syms, NULL, NULL))
9627                   goto error_ret;
9628
9629               elf_section_data (toc)->relocs = toc_relocs;
9630               toc->reloc_count = wrel - toc_relocs;
9631               rel_hdr = _bfd_elf_single_rel_hdr (toc);
9632               sz = rel_hdr->sh_entsize;
9633               rel_hdr->sh_size = toc->reloc_count * sz;
9634             }
9635         }
9636       else if (toc_relocs != NULL
9637                && elf_section_data (toc)->relocs != toc_relocs)
9638         free (toc_relocs);
9639
9640       if (local_syms != NULL
9641           && symtab_hdr->contents != (unsigned char *) local_syms)
9642         {
9643           if (!info->keep_memory)
9644             free (local_syms);
9645           else
9646             symtab_hdr->contents = (unsigned char *) local_syms;
9647         }
9648       free (skip);
9649     }
9650
9651   return TRUE;
9652 }
9653
9654 /* Return true iff input section I references the TOC using
9655    instructions limited to +/-32k offsets.  */
9656
9657 bfd_boolean
9658 ppc64_elf_has_small_toc_reloc (asection *i)
9659 {
9660   return (is_ppc64_elf (i->owner)
9661           && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9662 }
9663
9664 /* Allocate space for one GOT entry.  */
9665
9666 static void
9667 allocate_got (struct elf_link_hash_entry *h,
9668               struct bfd_link_info *info,
9669               struct got_entry *gent)
9670 {
9671   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9672   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9673   int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9674                  ? 16 : 8);
9675   int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9676                   ? 2 : 1) * sizeof (Elf64_External_Rela);
9677   asection *got = ppc64_elf_tdata (gent->owner)->got;
9678
9679   gent->got.offset = got->size;
9680   got->size += entsize;
9681
9682   if (h->type == STT_GNU_IFUNC)
9683     {
9684       htab->elf.irelplt->size += rentsize;
9685       htab->got_reli_size += rentsize;
9686     }
9687   else if ((bfd_link_pic (info)
9688             || (htab->elf.dynamic_sections_created
9689                 && h->dynindx != -1
9690                 && !SYMBOL_REFERENCES_LOCAL (info, h)))
9691            && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
9692     {
9693       asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9694       relgot->size += rentsize;
9695     }
9696 }
9697
9698 /* This function merges got entries in the same toc group.  */
9699
9700 static void
9701 merge_got_entries (struct got_entry **pent)
9702 {
9703   struct got_entry *ent, *ent2;
9704
9705   for (ent = *pent; ent != NULL; ent = ent->next)
9706     if (!ent->is_indirect)
9707       for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9708         if (!ent2->is_indirect
9709             && ent2->addend == ent->addend
9710             && ent2->tls_type == ent->tls_type
9711             && elf_gp (ent2->owner) == elf_gp (ent->owner))
9712           {
9713             ent2->is_indirect = TRUE;
9714             ent2->got.ent = ent;
9715           }
9716 }
9717
9718 /* If H is undefined weak, make it dynamic if that makes sense.  */
9719
9720 static bfd_boolean
9721 ensure_undefweak_dynamic (struct bfd_link_info *info,
9722                           struct elf_link_hash_entry *h)
9723 {
9724   struct elf_link_hash_table *htab = elf_hash_table (info);
9725
9726   if (htab->dynamic_sections_created
9727       && info->dynamic_undefined_weak != 0
9728       && h->root.type == bfd_link_hash_undefweak
9729       && h->dynindx == -1
9730       && !h->forced_local
9731       && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
9732     return bfd_elf_link_record_dynamic_symbol (info, h);
9733   return TRUE;
9734 }
9735
9736 /* Allocate space in .plt, .got and associated reloc sections for
9737    dynamic relocs.  */
9738
9739 static bfd_boolean
9740 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9741 {
9742   struct bfd_link_info *info;
9743   struct ppc_link_hash_table *htab;
9744   asection *s;
9745   struct ppc_link_hash_entry *eh;
9746   struct got_entry **pgent, *gent;
9747
9748   if (h->root.type == bfd_link_hash_indirect)
9749     return TRUE;
9750
9751   info = (struct bfd_link_info *) inf;
9752   htab = ppc_hash_table (info);
9753   if (htab == NULL)
9754     return FALSE;
9755
9756   eh = (struct ppc_link_hash_entry *) h;
9757   /* Run through the TLS GD got entries first if we're changing them
9758      to TPREL.  */
9759   if ((eh->tls_mask & TLS_TPRELGD) != 0)
9760     for (gent = h->got.glist; gent != NULL; gent = gent->next)
9761       if (gent->got.refcount > 0
9762           && (gent->tls_type & TLS_GD) != 0)
9763         {
9764           /* This was a GD entry that has been converted to TPREL.  If
9765              there happens to be a TPREL entry we can use that one.  */
9766           struct got_entry *ent;
9767           for (ent = h->got.glist; ent != NULL; ent = ent->next)
9768             if (ent->got.refcount > 0
9769                 && (ent->tls_type & TLS_TPREL) != 0
9770                 && ent->addend == gent->addend
9771                 && ent->owner == gent->owner)
9772               {
9773                 gent->got.refcount = 0;
9774                 break;
9775               }
9776
9777           /* If not, then we'll be using our own TPREL entry.  */
9778           if (gent->got.refcount != 0)
9779             gent->tls_type = TLS_TLS | TLS_TPREL;
9780         }
9781
9782   /* Remove any list entry that won't generate a word in the GOT before
9783      we call merge_got_entries.  Otherwise we risk merging to empty
9784      entries.  */
9785   pgent = &h->got.glist;
9786   while ((gent = *pgent) != NULL)
9787     if (gent->got.refcount > 0)
9788       {
9789         if ((gent->tls_type & TLS_LD) != 0
9790             && !h->def_dynamic)
9791           {
9792             ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9793             *pgent = gent->next;
9794           }
9795         else
9796           pgent = &gent->next;
9797       }
9798     else
9799       *pgent = gent->next;
9800
9801   if (!htab->do_multi_toc)
9802     merge_got_entries (&h->got.glist);
9803
9804   for (gent = h->got.glist; gent != NULL; gent = gent->next)
9805     if (!gent->is_indirect)
9806       {
9807         /* Make sure this symbol is output as a dynamic symbol.
9808            Undefined weak syms won't yet be marked as dynamic.  */
9809         if (!ensure_undefweak_dynamic (info, h))
9810           return FALSE;
9811
9812         if (!is_ppc64_elf (gent->owner))
9813           abort ();
9814
9815         allocate_got (h, info, gent);
9816       }
9817
9818   /* If no dynamic sections we can't have dynamic relocs, except for
9819      IFUNCs which are handled even in static executables.  */
9820   if (!htab->elf.dynamic_sections_created
9821       && h->type != STT_GNU_IFUNC)
9822     eh->dyn_relocs = NULL;
9823
9824   /* Also discard relocs on undefined weak syms with non-default
9825      visibility, or when dynamic_undefined_weak says so.  */
9826   else if (UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
9827     eh->dyn_relocs = NULL;
9828
9829   if (eh->dyn_relocs != NULL)
9830     {
9831       struct elf_dyn_relocs *p, **pp;
9832
9833       /* In the shared -Bsymbolic case, discard space allocated for
9834          dynamic pc-relative relocs against symbols which turn out to
9835          be defined in regular objects.  For the normal shared case,
9836          discard space for relocs that have become local due to symbol
9837          visibility changes.  */
9838
9839       if (bfd_link_pic (info))
9840         {
9841           /* Relocs that use pc_count are those that appear on a call
9842              insn, or certain REL relocs (see must_be_dyn_reloc) that
9843              can be generated via assembly.  We want calls to
9844              protected symbols to resolve directly to the function
9845              rather than going via the plt.  If people want function
9846              pointer comparisons to work as expected then they should
9847              avoid writing weird assembly.  */
9848           if (SYMBOL_CALLS_LOCAL (info, h))
9849             {
9850               for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9851                 {
9852                   p->count -= p->pc_count;
9853                   p->pc_count = 0;
9854                   if (p->count == 0)
9855                     *pp = p->next;
9856                   else
9857                     pp = &p->next;
9858                 }
9859             }
9860
9861           if (eh->dyn_relocs != NULL)
9862             {
9863               /* Make sure this symbol is output as a dynamic symbol.
9864                  Undefined weak syms won't yet be marked as dynamic.  */
9865               if (!ensure_undefweak_dynamic (info, h))
9866                 return FALSE;
9867             }
9868         }
9869       else if (h->type == STT_GNU_IFUNC)
9870         {
9871           /* A plt entry is always created when making direct calls to
9872              an ifunc, even when building a static executable, but
9873              that doesn't cover all cases.  We may have only an ifunc
9874              initialised function pointer for a given ifunc symbol.
9875
9876              For ELFv2, dynamic relocations are not required when
9877              generating a global entry PLT stub.  */
9878           if (abiversion (info->output_bfd) >= 2)
9879             {
9880               if (global_entry_stub (h))
9881                 eh->dyn_relocs = NULL;
9882             }
9883
9884           /* For ELFv1 we have function descriptors.  Descriptors need
9885              to be treated like PLT entries and thus have dynamic
9886              relocations.  One exception is when the function
9887              descriptor is copied into .dynbss (which should only
9888              happen with ancient versions of gcc).  */
9889           else if (h->needs_copy)
9890             eh->dyn_relocs = NULL;
9891         }
9892       else if (ELIMINATE_COPY_RELOCS)
9893         {
9894           /* For the non-pic case, discard space for relocs against
9895              symbols which turn out to need copy relocs or are not
9896              dynamic.  */
9897           if (!h->non_got_ref
9898               && !h->def_regular)
9899             {
9900               /* Make sure this symbol is output as a dynamic symbol.
9901                  Undefined weak syms won't yet be marked as dynamic.  */
9902               if (!ensure_undefweak_dynamic (info, h))
9903                 return FALSE;
9904
9905               if (h->dynindx == -1)
9906                 eh->dyn_relocs = NULL;
9907             }
9908           else
9909             eh->dyn_relocs = NULL;
9910         }
9911
9912       /* Finally, allocate space.  */
9913       for (p = eh->dyn_relocs; p != NULL; p = p->next)
9914         {
9915           asection *sreloc = elf_section_data (p->sec)->sreloc;
9916           if (eh->elf.type == STT_GNU_IFUNC)
9917             sreloc = htab->elf.irelplt;
9918           sreloc->size += p->count * sizeof (Elf64_External_Rela);
9919         }
9920     }
9921
9922   if ((htab->elf.dynamic_sections_created
9923        && h->dynindx != -1)
9924       || h->type == STT_GNU_IFUNC)
9925     {
9926       struct plt_entry *pent;
9927       bfd_boolean doneone = FALSE;
9928       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9929         if (pent->plt.refcount > 0)
9930           {
9931             if (!htab->elf.dynamic_sections_created
9932                 || h->dynindx == -1)
9933               {
9934                 s = htab->elf.iplt;
9935                 pent->plt.offset = s->size;
9936                 s->size += PLT_ENTRY_SIZE (htab);
9937                 s = htab->elf.irelplt;
9938               }
9939             else
9940               {
9941                 /* If this is the first .plt entry, make room for the special
9942                    first entry.  */
9943                 s = htab->elf.splt;
9944                 if (s->size == 0)
9945                   s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9946
9947                 pent->plt.offset = s->size;
9948
9949                 /* Make room for this entry.  */
9950                 s->size += PLT_ENTRY_SIZE (htab);
9951
9952                 /* Make room for the .glink code.  */
9953                 s = htab->glink;
9954                 if (s->size == 0)
9955                   s->size += GLINK_CALL_STUB_SIZE;
9956                 if (htab->opd_abi)
9957                   {
9958                     /* We need bigger stubs past index 32767.  */
9959                     if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9960                       s->size += 4;
9961                     s->size += 2*4;
9962                   }
9963                 else
9964                   s->size += 4;
9965
9966                 /* We also need to make an entry in the .rela.plt section.  */
9967                 s = htab->elf.srelplt;
9968               }
9969             s->size += sizeof (Elf64_External_Rela);
9970             doneone = TRUE;
9971           }
9972         else
9973           pent->plt.offset = (bfd_vma) -1;
9974       if (!doneone)
9975         {
9976           h->plt.plist = NULL;
9977           h->needs_plt = 0;
9978         }
9979     }
9980   else
9981     {
9982       h->plt.plist = NULL;
9983       h->needs_plt = 0;
9984     }
9985
9986   return TRUE;
9987 }
9988
9989 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9990    to set up space for global entry stubs.  These are put in glink,
9991    after the branch table.  */
9992
9993 static bfd_boolean
9994 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
9995 {
9996   struct bfd_link_info *info;
9997   struct ppc_link_hash_table *htab;
9998   struct plt_entry *pent;
9999   asection *s;
10000
10001   if (h->root.type == bfd_link_hash_indirect)
10002     return TRUE;
10003
10004   if (!h->pointer_equality_needed)
10005     return TRUE;
10006
10007   if (h->def_regular)
10008     return TRUE;
10009
10010   info = inf;
10011   htab = ppc_hash_table (info);
10012   if (htab == NULL)
10013     return FALSE;
10014
10015   s = htab->glink;
10016   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
10017     if (pent->plt.offset != (bfd_vma) -1
10018         && pent->addend == 0)
10019       {
10020         /* For ELFv2, if this symbol is not defined in a regular file
10021            and we are not generating a shared library or pie, then we
10022            need to define the symbol in the executable on a call stub.
10023            This is to avoid text relocations.  */
10024         s->size = (s->size + 15) & -16;
10025         h->root.type = bfd_link_hash_defined;
10026         h->root.u.def.section = s;
10027         h->root.u.def.value = s->size;
10028         s->size += 16;
10029         break;
10030       }
10031   return TRUE;
10032 }
10033
10034 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
10035    read-only sections.  */
10036
10037 static bfd_boolean
10038 maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
10039 {
10040   if (h->root.type == bfd_link_hash_indirect)
10041     return TRUE;
10042
10043   if (readonly_dynrelocs (h))
10044     {
10045       ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
10046
10047       /* Not an error, just cut short the traversal.  */
10048       return FALSE;
10049     }
10050   return TRUE;
10051 }
10052
10053 /* Set the sizes of the dynamic sections.  */
10054
10055 static bfd_boolean
10056 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
10057                                  struct bfd_link_info *info)
10058 {
10059   struct ppc_link_hash_table *htab;
10060   bfd *dynobj;
10061   asection *s;
10062   bfd_boolean relocs;
10063   bfd *ibfd;
10064   struct got_entry *first_tlsld;
10065
10066   htab = ppc_hash_table (info);
10067   if (htab == NULL)
10068     return FALSE;
10069
10070   dynobj = htab->elf.dynobj;
10071   if (dynobj == NULL)
10072     abort ();
10073
10074   if (htab->elf.dynamic_sections_created)
10075     {
10076       /* Set the contents of the .interp section to the interpreter.  */
10077       if (bfd_link_executable (info) && !info->nointerp)
10078         {
10079           s = bfd_get_linker_section (dynobj, ".interp");
10080           if (s == NULL)
10081             abort ();
10082           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
10083           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
10084         }
10085     }
10086
10087   /* Set up .got offsets for local syms, and space for local dynamic
10088      relocs.  */
10089   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10090     {
10091       struct got_entry **lgot_ents;
10092       struct got_entry **end_lgot_ents;
10093       struct plt_entry **local_plt;
10094       struct plt_entry **end_local_plt;
10095       unsigned char *lgot_masks;
10096       bfd_size_type locsymcount;
10097       Elf_Internal_Shdr *symtab_hdr;
10098
10099       if (!is_ppc64_elf (ibfd))
10100         continue;
10101
10102       for (s = ibfd->sections; s != NULL; s = s->next)
10103         {
10104           struct ppc_dyn_relocs *p;
10105
10106           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
10107             {
10108               if (!bfd_is_abs_section (p->sec)
10109                   && bfd_is_abs_section (p->sec->output_section))
10110                 {
10111                   /* Input section has been discarded, either because
10112                      it is a copy of a linkonce section or due to
10113                      linker script /DISCARD/, so we'll be discarding
10114                      the relocs too.  */
10115                 }
10116               else if (p->count != 0)
10117                 {
10118                   asection *srel = elf_section_data (p->sec)->sreloc;
10119                   if (p->ifunc)
10120                     srel = htab->elf.irelplt;
10121                   srel->size += p->count * sizeof (Elf64_External_Rela);
10122                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
10123                     info->flags |= DF_TEXTREL;
10124                 }
10125             }
10126         }
10127
10128       lgot_ents = elf_local_got_ents (ibfd);
10129       if (!lgot_ents)
10130         continue;
10131
10132       symtab_hdr = &elf_symtab_hdr (ibfd);
10133       locsymcount = symtab_hdr->sh_info;
10134       end_lgot_ents = lgot_ents + locsymcount;
10135       local_plt = (struct plt_entry **) end_lgot_ents;
10136       end_local_plt = local_plt + locsymcount;
10137       lgot_masks = (unsigned char *) end_local_plt;
10138       s = ppc64_elf_tdata (ibfd)->got;
10139       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
10140         {
10141           struct got_entry **pent, *ent;
10142
10143           pent = lgot_ents;
10144           while ((ent = *pent) != NULL)
10145             if (ent->got.refcount > 0)
10146               {
10147                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
10148                   {
10149                     ppc64_tlsld_got (ibfd)->got.refcount += 1;
10150                     *pent = ent->next;
10151                   }
10152                 else
10153                   {
10154                     unsigned int ent_size = 8;
10155                     unsigned int rel_size = sizeof (Elf64_External_Rela);
10156
10157                     ent->got.offset = s->size;
10158                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
10159                       {
10160                         ent_size *= 2;
10161                         rel_size *= 2;
10162                       }
10163                     s->size += ent_size;
10164                     if ((*lgot_masks & PLT_IFUNC) != 0)
10165                       {
10166                         htab->elf.irelplt->size += rel_size;
10167                         htab->got_reli_size += rel_size;
10168                       }
10169                     else if (bfd_link_pic (info))
10170                       {
10171                         asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10172                         srel->size += rel_size;
10173                       }
10174                     pent = &ent->next;
10175                   }
10176               }
10177             else
10178               *pent = ent->next;
10179         }
10180
10181       /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt.  */
10182       for (; local_plt < end_local_plt; ++local_plt)
10183         {
10184           struct plt_entry *ent;
10185
10186           for (ent = *local_plt; ent != NULL; ent = ent->next)
10187             if (ent->plt.refcount > 0)
10188               {
10189                 s = htab->elf.iplt;
10190                 ent->plt.offset = s->size;
10191                 s->size += PLT_ENTRY_SIZE (htab);
10192
10193                 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
10194               }
10195             else
10196               ent->plt.offset = (bfd_vma) -1;
10197         }
10198     }
10199
10200   /* Allocate global sym .plt and .got entries, and space for global
10201      sym dynamic relocs.  */
10202   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
10203   /* Stash the end of glink branch table.  */
10204   if (htab->glink != NULL)
10205     htab->glink->rawsize = htab->glink->size;
10206
10207   if (!htab->opd_abi && !bfd_link_pic (info))
10208     elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
10209
10210   first_tlsld = NULL;
10211   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10212     {
10213       struct got_entry *ent;
10214
10215       if (!is_ppc64_elf (ibfd))
10216         continue;
10217
10218       ent = ppc64_tlsld_got (ibfd);
10219       if (ent->got.refcount > 0)
10220         {
10221           if (!htab->do_multi_toc && first_tlsld != NULL)
10222             {
10223               ent->is_indirect = TRUE;
10224               ent->got.ent = first_tlsld;
10225             }
10226           else
10227             {
10228               if (first_tlsld == NULL)
10229                 first_tlsld = ent;
10230               s = ppc64_elf_tdata (ibfd)->got;
10231               ent->got.offset = s->size;
10232               ent->owner = ibfd;
10233               s->size += 16;
10234               if (bfd_link_pic (info))
10235                 {
10236                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10237                   srel->size += sizeof (Elf64_External_Rela);
10238                 }
10239             }
10240         }
10241       else
10242         ent->got.offset = (bfd_vma) -1;
10243     }
10244
10245   /* We now have determined the sizes of the various dynamic sections.
10246      Allocate memory for them.  */
10247   relocs = FALSE;
10248   for (s = dynobj->sections; s != NULL; s = s->next)
10249     {
10250       if ((s->flags & SEC_LINKER_CREATED) == 0)
10251         continue;
10252
10253       if (s == htab->brlt || s == htab->relbrlt)
10254         /* These haven't been allocated yet;  don't strip.  */
10255         continue;
10256       else if (s == htab->elf.sgot
10257                || s == htab->elf.splt
10258                || s == htab->elf.iplt
10259                || s == htab->glink
10260                || s == htab->elf.sdynbss
10261                || s == htab->elf.sdynrelro)
10262         {
10263           /* Strip this section if we don't need it; see the
10264              comment below.  */
10265         }
10266       else if (s == htab->glink_eh_frame)
10267         {
10268           if (!bfd_is_abs_section (s->output_section))
10269             /* Not sized yet.  */
10270             continue;
10271         }
10272       else if (CONST_STRNEQ (s->name, ".rela"))
10273         {
10274           if (s->size != 0)
10275             {
10276               if (s != htab->elf.srelplt)
10277                 relocs = TRUE;
10278
10279               /* We use the reloc_count field as a counter if we need
10280                  to copy relocs into the output file.  */
10281               s->reloc_count = 0;
10282             }
10283         }
10284       else
10285         {
10286           /* It's not one of our sections, so don't allocate space.  */
10287           continue;
10288         }
10289
10290       if (s->size == 0)
10291         {
10292           /* If we don't need this section, strip it from the
10293              output file.  This is mostly to handle .rela.bss and
10294              .rela.plt.  We must create both sections in
10295              create_dynamic_sections, because they must be created
10296              before the linker maps input sections to output
10297              sections.  The linker does that before
10298              adjust_dynamic_symbol is called, and it is that
10299              function which decides whether anything needs to go
10300              into these sections.  */
10301           s->flags |= SEC_EXCLUDE;
10302           continue;
10303         }
10304
10305       if ((s->flags & SEC_HAS_CONTENTS) == 0)
10306         continue;
10307
10308       /* Allocate memory for the section contents.  We use bfd_zalloc
10309          here in case unused entries are not reclaimed before the
10310          section's contents are written out.  This should not happen,
10311          but this way if it does we get a R_PPC64_NONE reloc in .rela
10312          sections instead of garbage.
10313          We also rely on the section contents being zero when writing
10314          the GOT and .dynrelro.  */
10315       s->contents = bfd_zalloc (dynobj, s->size);
10316       if (s->contents == NULL)
10317         return FALSE;
10318     }
10319
10320   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10321     {
10322       if (!is_ppc64_elf (ibfd))
10323         continue;
10324
10325       s = ppc64_elf_tdata (ibfd)->got;
10326       if (s != NULL && s != htab->elf.sgot)
10327         {
10328           if (s->size == 0)
10329             s->flags |= SEC_EXCLUDE;
10330           else
10331             {
10332               s->contents = bfd_zalloc (ibfd, s->size);
10333               if (s->contents == NULL)
10334                 return FALSE;
10335             }
10336         }
10337       s = ppc64_elf_tdata (ibfd)->relgot;
10338       if (s != NULL)
10339         {
10340           if (s->size == 0)
10341             s->flags |= SEC_EXCLUDE;
10342           else
10343             {
10344               s->contents = bfd_zalloc (ibfd, s->size);
10345               if (s->contents == NULL)
10346                 return FALSE;
10347               relocs = TRUE;
10348               s->reloc_count = 0;
10349             }
10350         }
10351     }
10352
10353   if (htab->elf.dynamic_sections_created)
10354     {
10355       bfd_boolean tls_opt;
10356
10357       /* Add some entries to the .dynamic section.  We fill in the
10358          values later, in ppc64_elf_finish_dynamic_sections, but we
10359          must add the entries now so that we get the correct size for
10360          the .dynamic section.  The DT_DEBUG entry is filled in by the
10361          dynamic linker and used by the debugger.  */
10362 #define add_dynamic_entry(TAG, VAL) \
10363   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10364
10365       if (bfd_link_executable (info))
10366         {
10367           if (!add_dynamic_entry (DT_DEBUG, 0))
10368             return FALSE;
10369         }
10370
10371       if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
10372         {
10373           if (!add_dynamic_entry (DT_PLTGOT, 0)
10374               || !add_dynamic_entry (DT_PLTRELSZ, 0)
10375               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
10376               || !add_dynamic_entry (DT_JMPREL, 0)
10377               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
10378             return FALSE;
10379         }
10380
10381       if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
10382         {
10383           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
10384               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
10385             return FALSE;
10386         }
10387
10388       tls_opt = (htab->params->tls_get_addr_opt
10389                  && htab->tls_get_addr_fd != NULL
10390                  && htab->tls_get_addr_fd->elf.plt.plist != NULL);
10391       if (tls_opt || !htab->opd_abi)
10392         {
10393           if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
10394             return FALSE;
10395         }
10396
10397       if (relocs)
10398         {
10399           if (!add_dynamic_entry (DT_RELA, 0)
10400               || !add_dynamic_entry (DT_RELASZ, 0)
10401               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
10402             return FALSE;
10403
10404           /* If any dynamic relocs apply to a read-only section,
10405              then we need a DT_TEXTREL entry.  */
10406           if ((info->flags & DF_TEXTREL) == 0)
10407             elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
10408
10409           if ((info->flags & DF_TEXTREL) != 0)
10410             {
10411               if (!add_dynamic_entry (DT_TEXTREL, 0))
10412                 return FALSE;
10413             }
10414         }
10415     }
10416 #undef add_dynamic_entry
10417
10418   return TRUE;
10419 }
10420
10421 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
10422
10423 static bfd_boolean
10424 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
10425 {
10426   if (h->plt.plist != NULL
10427       && !h->def_regular
10428       && !h->pointer_equality_needed)
10429     return FALSE;
10430
10431   return _bfd_elf_hash_symbol (h);
10432 }
10433
10434 /* Determine the type of stub needed, if any, for a call.  */
10435
10436 static inline enum ppc_stub_type
10437 ppc_type_of_stub (asection *input_sec,
10438                   const Elf_Internal_Rela *rel,
10439                   struct ppc_link_hash_entry **hash,
10440                   struct plt_entry **plt_ent,
10441                   bfd_vma destination,
10442                   unsigned long local_off)
10443 {
10444   struct ppc_link_hash_entry *h = *hash;
10445   bfd_vma location;
10446   bfd_vma branch_offset;
10447   bfd_vma max_branch_offset;
10448   enum elf_ppc64_reloc_type r_type;
10449
10450   if (h != NULL)
10451     {
10452       struct plt_entry *ent;
10453       struct ppc_link_hash_entry *fdh = h;
10454       if (h->oh != NULL
10455           && h->oh->is_func_descriptor)
10456         {
10457           fdh = ppc_follow_link (h->oh);
10458           *hash = fdh;
10459         }
10460
10461       for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10462         if (ent->addend == rel->r_addend
10463             && ent->plt.offset != (bfd_vma) -1)
10464           {
10465             *plt_ent = ent;
10466             return ppc_stub_plt_call;
10467           }
10468
10469       /* Here, we know we don't have a plt entry.  If we don't have a
10470          either a defined function descriptor or a defined entry symbol
10471          in a regular object file, then it is pointless trying to make
10472          any other type of stub.  */
10473       if (!is_static_defined (&fdh->elf)
10474           && !is_static_defined (&h->elf))
10475         return ppc_stub_none;
10476     }
10477   else if (elf_local_got_ents (input_sec->owner) != NULL)
10478     {
10479       Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10480       struct plt_entry **local_plt = (struct plt_entry **)
10481         elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10482       unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10483
10484       if (local_plt[r_symndx] != NULL)
10485         {
10486           struct plt_entry *ent;
10487
10488           for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10489             if (ent->addend == rel->r_addend
10490                 && ent->plt.offset != (bfd_vma) -1)
10491               {
10492                 *plt_ent = ent;
10493                 return ppc_stub_plt_call;
10494               }
10495         }
10496     }
10497
10498   /* Determine where the call point is.  */
10499   location = (input_sec->output_offset
10500               + input_sec->output_section->vma
10501               + rel->r_offset);
10502
10503   branch_offset = destination - location;
10504   r_type = ELF64_R_TYPE (rel->r_info);
10505
10506   /* Determine if a long branch stub is needed.  */
10507   max_branch_offset = 1 << 25;
10508   if (r_type != R_PPC64_REL24)
10509     max_branch_offset = 1 << 15;
10510
10511   if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10512     /* We need a stub.  Figure out whether a long_branch or plt_branch
10513        is needed later.  */
10514     return ppc_stub_long_branch;
10515
10516   return ppc_stub_none;
10517 }
10518
10519 /* With power7 weakly ordered memory model, it is possible for ld.so
10520    to update a plt entry in one thread and have another thread see a
10521    stale zero toc entry.  To avoid this we need some sort of acquire
10522    barrier in the call stub.  One solution is to make the load of the
10523    toc word seem to appear to depend on the load of the function entry
10524    word.  Another solution is to test for r2 being zero, and branch to
10525    the appropriate glink entry if so.
10526
10527    .    fake dep barrier        compare
10528    .    ld 12,xxx(2)            ld 12,xxx(2)
10529    .    mtctr 12                mtctr 12
10530    .    xor 11,12,12            ld 2,xxx+8(2)
10531    .    add 2,2,11              cmpldi 2,0
10532    .    ld 2,xxx+8(2)           bnectr+
10533    .    bctr                    b <glink_entry>
10534
10535    The solution involving the compare turns out to be faster, so
10536    that's what we use unless the branch won't reach.  */
10537
10538 #define ALWAYS_USE_FAKE_DEP 0
10539 #define ALWAYS_EMIT_R2SAVE 0
10540
10541 #define PPC_LO(v) ((v) & 0xffff)
10542 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10543 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10544
10545 static inline unsigned int
10546 plt_stub_size (struct ppc_link_hash_table *htab,
10547                struct ppc_stub_hash_entry *stub_entry,
10548                bfd_vma off)
10549 {
10550   unsigned size = 12;
10551
10552   if (ALWAYS_EMIT_R2SAVE
10553       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10554     size += 4;
10555   if (PPC_HA (off) != 0)
10556     size += 4;
10557   if (htab->opd_abi)
10558     {
10559       size += 4;
10560       if (htab->params->plt_static_chain)
10561         size += 4;
10562       if (htab->params->plt_thread_safe
10563           && htab->elf.dynamic_sections_created
10564           && stub_entry->h != NULL
10565           && stub_entry->h->elf.dynindx != -1)
10566         size += 8;
10567       if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
10568         size += 4;
10569     }
10570   if (stub_entry->h != NULL
10571       && (stub_entry->h == htab->tls_get_addr_fd
10572           || stub_entry->h == htab->tls_get_addr)
10573       && htab->params->tls_get_addr_opt)
10574     {
10575       size += 7 * 4;
10576       if (ALWAYS_EMIT_R2SAVE
10577           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10578         size += 6 * 4;
10579     }
10580   return size;
10581 }
10582
10583 /* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
10584    then return the padding needed to do so.  */
10585 static inline unsigned int
10586 plt_stub_pad (struct ppc_link_hash_table *htab,
10587               struct ppc_stub_hash_entry *stub_entry,
10588               bfd_vma plt_off)
10589 {
10590   int stub_align = 1 << htab->params->plt_stub_align;
10591   unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10592   bfd_vma stub_off = stub_entry->group->stub_sec->size;
10593
10594   if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10595       > ((stub_size - 1) & -stub_align))
10596     return stub_align - (stub_off & (stub_align - 1));
10597   return 0;
10598 }
10599
10600 /* Build a .plt call stub.  */
10601
10602 static inline bfd_byte *
10603 build_plt_stub (struct ppc_link_hash_table *htab,
10604                 struct ppc_stub_hash_entry *stub_entry,
10605                 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10606 {
10607   bfd *obfd = htab->params->stub_bfd;
10608   bfd_boolean plt_load_toc = htab->opd_abi;
10609   bfd_boolean plt_static_chain = htab->params->plt_static_chain;
10610   bfd_boolean plt_thread_safe = (htab->params->plt_thread_safe
10611                                  && htab->elf.dynamic_sections_created
10612                                  && stub_entry->h != NULL
10613                                  && stub_entry->h->elf.dynindx != -1);
10614   bfd_boolean use_fake_dep = plt_thread_safe;
10615   bfd_vma cmp_branch_off = 0;
10616
10617   if (!ALWAYS_USE_FAKE_DEP
10618       && plt_load_toc
10619       && plt_thread_safe
10620       && !((stub_entry->h == htab->tls_get_addr_fd
10621             || stub_entry->h == htab->tls_get_addr)
10622            && htab->params->tls_get_addr_opt))
10623     {
10624       bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10625       bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10626                           / PLT_ENTRY_SIZE (htab));
10627       bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10628       bfd_vma to, from;
10629
10630       if (pltindex > 32768)
10631         glinkoff += (pltindex - 32768) * 4;
10632       to = (glinkoff
10633             + htab->glink->output_offset
10634             + htab->glink->output_section->vma);
10635       from = (p - stub_entry->group->stub_sec->contents
10636               + 4 * (ALWAYS_EMIT_R2SAVE
10637                      || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10638               + 4 * (PPC_HA (offset) != 0)
10639               + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10640                      != PPC_HA (offset))
10641               + 4 * (plt_static_chain != 0)
10642               + 20
10643               + stub_entry->group->stub_sec->output_offset
10644               + stub_entry->group->stub_sec->output_section->vma);
10645       cmp_branch_off = to - from;
10646       use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10647     }
10648
10649   if (PPC_HA (offset) != 0)
10650     {
10651       if (r != NULL)
10652         {
10653           if (ALWAYS_EMIT_R2SAVE
10654               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10655             r[0].r_offset += 4;
10656           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10657           r[1].r_offset = r[0].r_offset + 4;
10658           r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10659           r[1].r_addend = r[0].r_addend;
10660           if (plt_load_toc)
10661             {
10662               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10663                 {
10664                   r[2].r_offset = r[1].r_offset + 4;
10665                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10666                   r[2].r_addend = r[0].r_addend;
10667                 }
10668               else
10669                 {
10670                   r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10671                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10672                   r[2].r_addend = r[0].r_addend + 8;
10673                   if (plt_static_chain)
10674                     {
10675                       r[3].r_offset = r[2].r_offset + 4;
10676                       r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10677                       r[3].r_addend = r[0].r_addend + 16;
10678                     }
10679                 }
10680             }
10681         }
10682       if (ALWAYS_EMIT_R2SAVE
10683           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10684         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10685       if (plt_load_toc)
10686         {
10687           bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10688           bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p),  p += 4;
10689         }
10690       else
10691         {
10692           bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
10693           bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p),  p += 4;
10694         }
10695       if (plt_load_toc
10696           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10697         {
10698           bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10699           offset = 0;
10700         }
10701       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10702       if (plt_load_toc)
10703         {
10704           if (use_fake_dep)
10705             {
10706               bfd_put_32 (obfd, XOR_R2_R12_R12, p),             p += 4;
10707               bfd_put_32 (obfd, ADD_R11_R11_R2, p),             p += 4;
10708             }
10709           bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10710           if (plt_static_chain)
10711             bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10712         }
10713     }
10714   else
10715     {
10716       if (r != NULL)
10717         {
10718           if (ALWAYS_EMIT_R2SAVE
10719               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10720             r[0].r_offset += 4;
10721           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10722           if (plt_load_toc)
10723             {
10724               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10725                 {
10726                   r[1].r_offset = r[0].r_offset + 4;
10727                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10728                   r[1].r_addend = r[0].r_addend;
10729                 }
10730               else
10731                 {
10732                   r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10733                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10734                   r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10735                   if (plt_static_chain)
10736                     {
10737                       r[2].r_offset = r[1].r_offset + 4;
10738                       r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10739                       r[2].r_addend = r[0].r_addend + 8;
10740                     }
10741                 }
10742             }
10743         }
10744       if (ALWAYS_EMIT_R2SAVE
10745           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10746         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10747       bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p),       p += 4;
10748       if (plt_load_toc
10749           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10750         {
10751           bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),   p += 4;
10752           offset = 0;
10753         }
10754       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10755       if (plt_load_toc)
10756         {
10757           if (use_fake_dep)
10758             {
10759               bfd_put_32 (obfd, XOR_R11_R12_R12, p),            p += 4;
10760               bfd_put_32 (obfd, ADD_R2_R2_R11, p),              p += 4;
10761             }
10762           if (plt_static_chain)
10763             bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10764           bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10765         }
10766     }
10767   if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10768     {
10769       bfd_put_32 (obfd, CMPLDI_R2_0, p),                        p += 4;
10770       bfd_put_32 (obfd, BNECTR_P4, p),                          p += 4;
10771       bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10772     }
10773   else
10774     bfd_put_32 (obfd, BCTR, p),                                 p += 4;
10775   return p;
10776 }
10777
10778 /* Build a special .plt call stub for __tls_get_addr.  */
10779
10780 #define LD_R11_0R3      0xe9630000
10781 #define LD_R12_0R3      0xe9830000
10782 #define MR_R0_R3        0x7c601b78
10783 #define CMPDI_R11_0     0x2c2b0000
10784 #define ADD_R3_R12_R13  0x7c6c6a14
10785 #define BEQLR           0x4d820020
10786 #define MR_R3_R0        0x7c030378
10787 #define STD_R11_0R1     0xf9610000
10788 #define BCTRL           0x4e800421
10789 #define LD_R11_0R1      0xe9610000
10790 #define MTLR_R11        0x7d6803a6
10791
10792 static inline bfd_byte *
10793 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10794                          struct ppc_stub_hash_entry *stub_entry,
10795                          bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10796 {
10797   bfd *obfd = htab->params->stub_bfd;
10798
10799   bfd_put_32 (obfd, LD_R11_0R3 + 0, p),         p += 4;
10800   bfd_put_32 (obfd, LD_R12_0R3 + 8, p),         p += 4;
10801   bfd_put_32 (obfd, MR_R0_R3, p),               p += 4;
10802   bfd_put_32 (obfd, CMPDI_R11_0, p),            p += 4;
10803   bfd_put_32 (obfd, ADD_R3_R12_R13, p),         p += 4;
10804   bfd_put_32 (obfd, BEQLR, p),                  p += 4;
10805   bfd_put_32 (obfd, MR_R3_R0, p),               p += 4;
10806   if (r != NULL)
10807     r[0].r_offset += 7 * 4;
10808   if (!ALWAYS_EMIT_R2SAVE
10809       && stub_entry->stub_type != ppc_stub_plt_call_r2save)
10810     return build_plt_stub (htab, stub_entry, p, offset, r);
10811
10812   bfd_put_32 (obfd, MFLR_R11, p),               p += 4;
10813   bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10814
10815   if (r != NULL)
10816     r[0].r_offset += 2 * 4;
10817   p = build_plt_stub (htab, stub_entry, p, offset, r);
10818   bfd_put_32 (obfd, BCTRL, p - 4);
10819
10820   bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p),     p += 4;
10821   bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10822   bfd_put_32 (obfd, MTLR_R11, p),               p += 4;
10823   bfd_put_32 (obfd, BLR, p),                    p += 4;
10824
10825   return p;
10826 }
10827
10828 static Elf_Internal_Rela *
10829 get_relocs (asection *sec, int count)
10830 {
10831   Elf_Internal_Rela *relocs;
10832   struct bfd_elf_section_data *elfsec_data;
10833
10834   elfsec_data = elf_section_data (sec);
10835   relocs = elfsec_data->relocs;
10836   if (relocs == NULL)
10837     {
10838       bfd_size_type relsize;
10839       relsize = sec->reloc_count * sizeof (*relocs);
10840       relocs = bfd_alloc (sec->owner, relsize);
10841       if (relocs == NULL)
10842         return NULL;
10843       elfsec_data->relocs = relocs;
10844       elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10845                                           sizeof (Elf_Internal_Shdr));
10846       if (elfsec_data->rela.hdr == NULL)
10847         return NULL;
10848       elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10849                                         * sizeof (Elf64_External_Rela));
10850       elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10851       sec->reloc_count = 0;
10852     }
10853   relocs += sec->reloc_count;
10854   sec->reloc_count += count;
10855   return relocs;
10856 }
10857
10858 static bfd_vma
10859 get_r2off (struct bfd_link_info *info,
10860            struct ppc_stub_hash_entry *stub_entry)
10861 {
10862   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10863   bfd_vma r2off = htab->sec_info[stub_entry->target_section->id].toc_off;
10864
10865   if (r2off == 0)
10866     {
10867       /* Support linking -R objects.  Get the toc pointer from the
10868          opd entry.  */
10869       char buf[8];
10870       if (!htab->opd_abi)
10871         return r2off;
10872       asection *opd = stub_entry->h->elf.root.u.def.section;
10873       bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10874
10875       if (strcmp (opd->name, ".opd") != 0
10876           || opd->reloc_count != 0)
10877         {
10878           info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
10879                                   stub_entry->h->elf.root.root.string);
10880           bfd_set_error (bfd_error_bad_value);
10881           return (bfd_vma) -1;
10882         }
10883       if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10884         return (bfd_vma) -1;
10885       r2off = bfd_get_64 (opd->owner, buf);
10886       r2off -= elf_gp (info->output_bfd);
10887     }
10888   r2off -= htab->sec_info[stub_entry->group->link_sec->id].toc_off;
10889   return r2off;
10890 }
10891
10892 static bfd_boolean
10893 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10894 {
10895   struct ppc_stub_hash_entry *stub_entry;
10896   struct ppc_branch_hash_entry *br_entry;
10897   struct bfd_link_info *info;
10898   struct ppc_link_hash_table *htab;
10899   bfd_byte *loc;
10900   bfd_byte *p;
10901   bfd_vma dest, off;
10902   int size;
10903   Elf_Internal_Rela *r;
10904   asection *plt;
10905
10906   /* Massage our args to the form they really have.  */
10907   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10908   info = in_arg;
10909
10910   htab = ppc_hash_table (info);
10911   if (htab == NULL)
10912     return FALSE;
10913
10914   /* Make a note of the offset within the stubs for this entry.  */
10915   stub_entry->stub_offset = stub_entry->group->stub_sec->size;
10916   loc = stub_entry->group->stub_sec->contents + stub_entry->stub_offset;
10917
10918   htab->stub_count[stub_entry->stub_type - 1] += 1;
10919   switch (stub_entry->stub_type)
10920     {
10921     case ppc_stub_long_branch:
10922     case ppc_stub_long_branch_r2off:
10923       /* Branches are relative.  This is where we are going to.  */
10924       dest = (stub_entry->target_value
10925               + stub_entry->target_section->output_offset
10926               + stub_entry->target_section->output_section->vma);
10927       dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10928       off = dest;
10929
10930       /* And this is where we are coming from.  */
10931       off -= (stub_entry->stub_offset
10932               + stub_entry->group->stub_sec->output_offset
10933               + stub_entry->group->stub_sec->output_section->vma);
10934
10935       size = 4;
10936       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10937         {
10938           bfd_vma r2off = get_r2off (info, stub_entry);
10939
10940           if (r2off == (bfd_vma) -1)
10941             {
10942               htab->stub_error = TRUE;
10943               return FALSE;
10944             }
10945           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10946           loc += 4;
10947           size = 8;
10948           if (PPC_HA (r2off) != 0)
10949             {
10950               bfd_put_32 (htab->params->stub_bfd,
10951                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
10952               loc += 4;
10953               size += 4;
10954             }
10955           if (PPC_LO (r2off) != 0)
10956             {
10957               bfd_put_32 (htab->params->stub_bfd,
10958                           ADDI_R2_R2 | PPC_LO (r2off), loc);
10959               loc += 4;
10960               size += 4;
10961             }
10962           off -= size - 4;
10963         }
10964       bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10965
10966       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10967         {
10968           info->callbacks->einfo
10969             (_("%P: long branch stub `%s' offset overflow\n"),
10970              stub_entry->root.string);
10971           htab->stub_error = TRUE;
10972           return FALSE;
10973         }
10974
10975       if (info->emitrelocations)
10976         {
10977           r = get_relocs (stub_entry->group->stub_sec, 1);
10978           if (r == NULL)
10979             return FALSE;
10980           r->r_offset = loc - stub_entry->group->stub_sec->contents;
10981           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10982           r->r_addend = dest;
10983           if (stub_entry->h != NULL)
10984             {
10985               struct elf_link_hash_entry **hashes;
10986               unsigned long symndx;
10987               struct ppc_link_hash_entry *h;
10988
10989               hashes = elf_sym_hashes (htab->params->stub_bfd);
10990               if (hashes == NULL)
10991                 {
10992                   bfd_size_type hsize;
10993
10994                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10995                   hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
10996                   if (hashes == NULL)
10997                     return FALSE;
10998                   elf_sym_hashes (htab->params->stub_bfd) = hashes;
10999                   htab->stub_globals = 1;
11000                 }
11001               symndx = htab->stub_globals++;
11002               h = stub_entry->h;
11003               hashes[symndx] = &h->elf;
11004               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
11005               if (h->oh != NULL && h->oh->is_func)
11006                 h = ppc_follow_link (h->oh);
11007               if (h->elf.root.u.def.section != stub_entry->target_section)
11008                 /* H is an opd symbol.  The addend must be zero.  */
11009                 r->r_addend = 0;
11010               else
11011                 {
11012                   off = (h->elf.root.u.def.value
11013                          + h->elf.root.u.def.section->output_offset
11014                          + h->elf.root.u.def.section->output_section->vma);
11015                   r->r_addend -= off;
11016                 }
11017             }
11018         }
11019       break;
11020
11021     case ppc_stub_plt_branch:
11022     case ppc_stub_plt_branch_r2off:
11023       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11024                                          stub_entry->root.string + 9,
11025                                          FALSE, FALSE);
11026       if (br_entry == NULL)
11027         {
11028           info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
11029                                   stub_entry->root.string);
11030           htab->stub_error = TRUE;
11031           return FALSE;
11032         }
11033
11034       dest = (stub_entry->target_value
11035               + stub_entry->target_section->output_offset
11036               + stub_entry->target_section->output_section->vma);
11037       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11038         dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11039
11040       bfd_put_64 (htab->brlt->owner, dest,
11041                   htab->brlt->contents + br_entry->offset);
11042
11043       if (br_entry->iter == htab->stub_iteration)
11044         {
11045           br_entry->iter = 0;
11046
11047           if (htab->relbrlt != NULL)
11048             {
11049               /* Create a reloc for the branch lookup table entry.  */
11050               Elf_Internal_Rela rela;
11051               bfd_byte *rl;
11052
11053               rela.r_offset = (br_entry->offset
11054                                + htab->brlt->output_offset
11055                                + htab->brlt->output_section->vma);
11056               rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
11057               rela.r_addend = dest;
11058
11059               rl = htab->relbrlt->contents;
11060               rl += (htab->relbrlt->reloc_count++
11061                      * sizeof (Elf64_External_Rela));
11062               bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
11063             }
11064           else if (info->emitrelocations)
11065             {
11066               r = get_relocs (htab->brlt, 1);
11067               if (r == NULL)
11068                 return FALSE;
11069               /* brlt, being SEC_LINKER_CREATED does not go through the
11070                  normal reloc processing.  Symbols and offsets are not
11071                  translated from input file to output file form, so
11072                  set up the offset per the output file.  */
11073               r->r_offset = (br_entry->offset
11074                              + htab->brlt->output_offset
11075                              + htab->brlt->output_section->vma);
11076               r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
11077               r->r_addend = dest;
11078             }
11079         }
11080
11081       dest = (br_entry->offset
11082               + htab->brlt->output_offset
11083               + htab->brlt->output_section->vma);
11084
11085       off = (dest
11086              - elf_gp (htab->brlt->output_section->owner)
11087              - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11088
11089       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11090         {
11091           info->callbacks->einfo
11092             (_("%P: linkage table error against `%T'\n"),
11093              stub_entry->root.string);
11094           bfd_set_error (bfd_error_bad_value);
11095           htab->stub_error = TRUE;
11096           return FALSE;
11097         }
11098
11099       if (info->emitrelocations)
11100         {
11101           r = get_relocs (stub_entry->group->stub_sec, 1 + (PPC_HA (off) != 0));
11102           if (r == NULL)
11103             return FALSE;
11104           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11105           if (bfd_big_endian (info->output_bfd))
11106             r[0].r_offset += 2;
11107           if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
11108             r[0].r_offset += 4;
11109           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
11110           r[0].r_addend = dest;
11111           if (PPC_HA (off) != 0)
11112             {
11113               r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
11114               r[1].r_offset = r[0].r_offset + 4;
11115               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
11116               r[1].r_addend = r[0].r_addend;
11117             }
11118         }
11119
11120       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11121         {
11122           if (PPC_HA (off) != 0)
11123             {
11124               size = 16;
11125               bfd_put_32 (htab->params->stub_bfd,
11126                           ADDIS_R12_R2 | PPC_HA (off), loc);
11127               loc += 4;
11128               bfd_put_32 (htab->params->stub_bfd,
11129                           LD_R12_0R12 | PPC_LO (off), loc);
11130             }
11131           else
11132             {
11133               size = 12;
11134               bfd_put_32 (htab->params->stub_bfd,
11135                           LD_R12_0R2 | PPC_LO (off), loc);
11136             }
11137         }
11138       else
11139         {
11140           bfd_vma r2off = get_r2off (info, stub_entry);
11141
11142           if (r2off == (bfd_vma) -1)
11143             {
11144               htab->stub_error = TRUE;
11145               return FALSE;
11146             }
11147
11148           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
11149           loc += 4;
11150           size = 16;
11151           if (PPC_HA (off) != 0)
11152             {
11153               size += 4;
11154               bfd_put_32 (htab->params->stub_bfd,
11155                           ADDIS_R12_R2 | PPC_HA (off), loc);
11156               loc += 4;
11157               bfd_put_32 (htab->params->stub_bfd,
11158                           LD_R12_0R12 | PPC_LO (off), loc);
11159             }
11160           else
11161             bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
11162
11163           if (PPC_HA (r2off) != 0)
11164             {
11165               size += 4;
11166               loc += 4;
11167               bfd_put_32 (htab->params->stub_bfd,
11168                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
11169             }
11170           if (PPC_LO (r2off) != 0)
11171             {
11172               size += 4;
11173               loc += 4;
11174               bfd_put_32 (htab->params->stub_bfd,
11175                           ADDI_R2_R2 | PPC_LO (r2off), loc);
11176             }
11177         }
11178       loc += 4;
11179       bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, loc);
11180       loc += 4;
11181       bfd_put_32 (htab->params->stub_bfd, BCTR, loc);
11182       break;
11183
11184     case ppc_stub_plt_call:
11185     case ppc_stub_plt_call_r2save:
11186       if (stub_entry->h != NULL
11187           && stub_entry->h->is_func_descriptor
11188           && stub_entry->h->oh != NULL)
11189         {
11190           struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
11191
11192           /* If the old-ABI "dot-symbol" is undefined make it weak so
11193              we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.  */
11194           if (fh->elf.root.type == bfd_link_hash_undefined
11195               && (stub_entry->h->elf.root.type == bfd_link_hash_defined
11196                   || stub_entry->h->elf.root.type == bfd_link_hash_defweak))
11197             fh->elf.root.type = bfd_link_hash_undefweak;
11198         }
11199
11200       /* Now build the stub.  */
11201       dest = stub_entry->plt_ent->plt.offset & ~1;
11202       if (dest >= (bfd_vma) -2)
11203         abort ();
11204
11205       plt = htab->elf.splt;
11206       if (!htab->elf.dynamic_sections_created
11207           || stub_entry->h == NULL
11208           || stub_entry->h->elf.dynindx == -1)
11209         plt = htab->elf.iplt;
11210
11211       dest += plt->output_offset + plt->output_section->vma;
11212
11213       if (stub_entry->h == NULL
11214           && (stub_entry->plt_ent->plt.offset & 1) == 0)
11215         {
11216           Elf_Internal_Rela rela;
11217           bfd_byte *rl;
11218
11219           rela.r_offset = dest;
11220           if (htab->opd_abi)
11221             rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
11222           else
11223             rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
11224           rela.r_addend = (stub_entry->target_value
11225                            + stub_entry->target_section->output_offset
11226                            + stub_entry->target_section->output_section->vma);
11227
11228           rl = (htab->elf.irelplt->contents
11229                 + (htab->elf.irelplt->reloc_count++
11230                    * sizeof (Elf64_External_Rela)));
11231           bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
11232           stub_entry->plt_ent->plt.offset |= 1;
11233           htab->local_ifunc_resolver = 1;
11234         }
11235
11236       off = (dest
11237              - elf_gp (plt->output_section->owner)
11238              - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11239
11240       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11241         {
11242           info->callbacks->einfo
11243             /* xgettext:c-format */
11244             (_("%P: linkage table error against `%T'\n"),
11245              stub_entry->h != NULL
11246              ? stub_entry->h->elf.root.root.string
11247              : "<local sym>");
11248           bfd_set_error (bfd_error_bad_value);
11249           htab->stub_error = TRUE;
11250           return FALSE;
11251         }
11252
11253       if (htab->params->plt_stub_align != 0)
11254         {
11255           unsigned pad = plt_stub_pad (htab, stub_entry, off);
11256
11257           stub_entry->group->stub_sec->size += pad;
11258           stub_entry->stub_offset = stub_entry->group->stub_sec->size;
11259           loc += pad;
11260         }
11261
11262       r = NULL;
11263       if (info->emitrelocations)
11264         {
11265           r = get_relocs (stub_entry->group->stub_sec,
11266                           ((PPC_HA (off) != 0)
11267                            + (htab->opd_abi
11268                               ? 2 + (htab->params->plt_static_chain
11269                                      && PPC_HA (off + 16) == PPC_HA (off))
11270                               : 1)));
11271           if (r == NULL)
11272             return FALSE;
11273           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11274           if (bfd_big_endian (info->output_bfd))
11275             r[0].r_offset += 2;
11276           r[0].r_addend = dest;
11277         }
11278       if (stub_entry->h != NULL
11279           && (stub_entry->h == htab->tls_get_addr_fd
11280               || stub_entry->h == htab->tls_get_addr)
11281           && htab->params->tls_get_addr_opt)
11282         p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
11283       else
11284         p = build_plt_stub (htab, stub_entry, loc, off, r);
11285       size = p - loc;
11286       break;
11287
11288     case ppc_stub_save_res:
11289       return TRUE;
11290
11291     default:
11292       BFD_FAIL ();
11293       return FALSE;
11294     }
11295
11296   stub_entry->group->stub_sec->size += size;
11297
11298   if (htab->params->emit_stub_syms)
11299     {
11300       struct elf_link_hash_entry *h;
11301       size_t len1, len2;
11302       char *name;
11303       const char *const stub_str[] = { "long_branch",
11304                                        "long_branch_r2off",
11305                                        "plt_branch",
11306                                        "plt_branch_r2off",
11307                                        "plt_call",
11308                                        "plt_call" };
11309
11310       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
11311       len2 = strlen (stub_entry->root.string);
11312       name = bfd_malloc (len1 + len2 + 2);
11313       if (name == NULL)
11314         return FALSE;
11315       memcpy (name, stub_entry->root.string, 9);
11316       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
11317       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
11318       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
11319       if (h == NULL)
11320         return FALSE;
11321       if (h->root.type == bfd_link_hash_new)
11322         {
11323           h->root.type = bfd_link_hash_defined;
11324           h->root.u.def.section = stub_entry->group->stub_sec;
11325           h->root.u.def.value = stub_entry->stub_offset;
11326           h->ref_regular = 1;
11327           h->def_regular = 1;
11328           h->ref_regular_nonweak = 1;
11329           h->forced_local = 1;
11330           h->non_elf = 0;
11331           h->root.linker_def = 1;
11332         }
11333     }
11334
11335   return TRUE;
11336 }
11337
11338 /* As above, but don't actually build the stub.  Just bump offset so
11339    we know stub section sizes, and select plt_branch stubs where
11340    long_branch stubs won't do.  */
11341
11342 static bfd_boolean
11343 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11344 {
11345   struct ppc_stub_hash_entry *stub_entry;
11346   struct bfd_link_info *info;
11347   struct ppc_link_hash_table *htab;
11348   bfd_vma off;
11349   int size;
11350
11351   /* Massage our args to the form they really have.  */
11352   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11353   info = in_arg;
11354
11355   htab = ppc_hash_table (info);
11356   if (htab == NULL)
11357     return FALSE;
11358
11359   if (stub_entry->h != NULL
11360       && stub_entry->h->save_res
11361       && stub_entry->h->elf.root.type == bfd_link_hash_defined
11362       && stub_entry->h->elf.root.u.def.section == htab->sfpr)
11363     {
11364       /* Don't make stubs to out-of-line register save/restore
11365          functions.  Instead, emit copies of the functions.  */
11366       stub_entry->group->needs_save_res = 1;
11367       stub_entry->stub_type = ppc_stub_save_res;
11368       return TRUE;
11369     }
11370
11371   if (stub_entry->stub_type == ppc_stub_plt_call
11372       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11373     {
11374       asection *plt;
11375       off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
11376       if (off >= (bfd_vma) -2)
11377         abort ();
11378       plt = htab->elf.splt;
11379       if (!htab->elf.dynamic_sections_created
11380           || stub_entry->h == NULL
11381           || stub_entry->h->elf.dynindx == -1)
11382         plt = htab->elf.iplt;
11383       off += (plt->output_offset
11384               + plt->output_section->vma
11385               - elf_gp (plt->output_section->owner)
11386               - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11387
11388       size = plt_stub_size (htab, stub_entry, off);
11389       if (htab->params->plt_stub_align)
11390         size += plt_stub_pad (htab, stub_entry, off);
11391       if (info->emitrelocations)
11392         {
11393           stub_entry->group->stub_sec->reloc_count
11394             += ((PPC_HA (off) != 0)
11395                 + (htab->opd_abi
11396                    ? 2 + (htab->params->plt_static_chain
11397                           && PPC_HA (off + 16) == PPC_HA (off))
11398                    : 1));
11399           stub_entry->group->stub_sec->flags |= SEC_RELOC;
11400         }
11401     }
11402   else
11403     {
11404       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
11405          variants.  */
11406       bfd_vma r2off = 0;
11407       bfd_vma local_off = 0;
11408
11409       off = (stub_entry->target_value
11410              + stub_entry->target_section->output_offset
11411              + stub_entry->target_section->output_section->vma);
11412       off -= (stub_entry->group->stub_sec->size
11413               + stub_entry->group->stub_sec->output_offset
11414               + stub_entry->group->stub_sec->output_section->vma);
11415
11416       /* Reset the stub type from the plt variant in case we now
11417          can reach with a shorter stub.  */
11418       if (stub_entry->stub_type >= ppc_stub_plt_branch)
11419         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
11420
11421       size = 4;
11422       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11423         {
11424           r2off = get_r2off (info, stub_entry);
11425           if (r2off == (bfd_vma) -1)
11426             {
11427               htab->stub_error = TRUE;
11428               return FALSE;
11429             }
11430           size = 8;
11431           if (PPC_HA (r2off) != 0)
11432             size += 4;
11433           if (PPC_LO (r2off) != 0)
11434             size += 4;
11435           off -= size - 4;
11436         }
11437
11438       local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11439
11440       /* If the branch offset if too big, use a ppc_stub_plt_branch.
11441          Do the same for -R objects without function descriptors.  */
11442       if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
11443           || (stub_entry->stub_type == ppc_stub_long_branch_r2off
11444               && r2off == 0
11445               && htab->sec_info[stub_entry->target_section->id].toc_off == 0))
11446         {
11447           struct ppc_branch_hash_entry *br_entry;
11448
11449           br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11450                                              stub_entry->root.string + 9,
11451                                              TRUE, FALSE);
11452           if (br_entry == NULL)
11453             {
11454               info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
11455                                       stub_entry->root.string);
11456               htab->stub_error = TRUE;
11457               return FALSE;
11458             }
11459
11460           if (br_entry->iter != htab->stub_iteration)
11461             {
11462               br_entry->iter = htab->stub_iteration;
11463               br_entry->offset = htab->brlt->size;
11464               htab->brlt->size += 8;
11465
11466               if (htab->relbrlt != NULL)
11467                 htab->relbrlt->size += sizeof (Elf64_External_Rela);
11468               else if (info->emitrelocations)
11469                 {
11470                   htab->brlt->reloc_count += 1;
11471                   htab->brlt->flags |= SEC_RELOC;
11472                 }
11473             }
11474
11475           stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
11476           off = (br_entry->offset
11477                  + htab->brlt->output_offset
11478                  + htab->brlt->output_section->vma
11479                  - elf_gp (htab->brlt->output_section->owner)
11480                  - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11481
11482           if (info->emitrelocations)
11483             {
11484               stub_entry->group->stub_sec->reloc_count
11485                 += 1 + (PPC_HA (off) != 0);
11486               stub_entry->group->stub_sec->flags |= SEC_RELOC;
11487             }
11488
11489           if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11490             {
11491               size = 12;
11492               if (PPC_HA (off) != 0)
11493                 size = 16;
11494             }
11495           else
11496             {
11497               size = 16;
11498               if (PPC_HA (off) != 0)
11499                 size += 4;
11500
11501               if (PPC_HA (r2off) != 0)
11502                 size += 4;
11503               if (PPC_LO (r2off) != 0)
11504                 size += 4;
11505             }
11506         }
11507       else if (info->emitrelocations)
11508         {
11509           stub_entry->group->stub_sec->reloc_count += 1;
11510           stub_entry->group->stub_sec->flags |= SEC_RELOC;
11511         }
11512     }
11513
11514   stub_entry->group->stub_sec->size += size;
11515   return TRUE;
11516 }
11517
11518 /* Set up various things so that we can make a list of input sections
11519    for each output section included in the link.  Returns -1 on error,
11520    0 when no stubs will be needed, and 1 on success.  */
11521
11522 int
11523 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
11524 {
11525   unsigned int id;
11526   bfd_size_type amt;
11527   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11528
11529   if (htab == NULL)
11530     return -1;
11531
11532   htab->sec_info_arr_size = bfd_get_next_section_id ();
11533   amt = sizeof (*htab->sec_info) * (htab->sec_info_arr_size);
11534   htab->sec_info = bfd_zmalloc (amt);
11535   if (htab->sec_info == NULL)
11536     return -1;
11537
11538   /* Set toc_off for com, und, abs and ind sections.  */
11539   for (id = 0; id < 3; id++)
11540     htab->sec_info[id].toc_off = TOC_BASE_OFF;
11541
11542   return 1;
11543 }
11544
11545 /* Set up for first pass at multitoc partitioning.  */
11546
11547 void
11548 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11549 {
11550   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11551
11552   htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11553   htab->toc_bfd = NULL;
11554   htab->toc_first_sec = NULL;
11555 }
11556
11557 /* The linker repeatedly calls this function for each TOC input section
11558    and linker generated GOT section.  Group input bfds such that the toc
11559    within a group is less than 64k in size.  */
11560
11561 bfd_boolean
11562 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11563 {
11564   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11565   bfd_vma addr, off, limit;
11566
11567   if (htab == NULL)
11568     return FALSE;
11569
11570   if (!htab->second_toc_pass)
11571     {
11572       /* Keep track of the first .toc or .got section for this input bfd.  */
11573       bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11574
11575       if (new_bfd)
11576         {
11577           htab->toc_bfd = isec->owner;
11578           htab->toc_first_sec = isec;
11579         }
11580
11581       addr = isec->output_offset + isec->output_section->vma;
11582       off = addr - htab->toc_curr;
11583       limit = 0x80008000;
11584       if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11585         limit = 0x10000;
11586       if (off + isec->size > limit)
11587         {
11588           addr = (htab->toc_first_sec->output_offset
11589                   + htab->toc_first_sec->output_section->vma);
11590           htab->toc_curr = addr;
11591           htab->toc_curr &= -TOC_BASE_ALIGN;
11592         }
11593
11594       /* toc_curr is the base address of this toc group.  Set elf_gp
11595          for the input section to be the offset relative to the
11596          output toc base plus 0x8000.  Making the input elf_gp an
11597          offset allows us to move the toc as a whole without
11598          recalculating input elf_gp.  */
11599       off = htab->toc_curr - elf_gp (isec->output_section->owner);
11600       off += TOC_BASE_OFF;
11601
11602       /* Die if someone uses a linker script that doesn't keep input
11603          file .toc and .got together.  */
11604       if (new_bfd
11605           && elf_gp (isec->owner) != 0
11606           && elf_gp (isec->owner) != off)
11607         return FALSE;
11608
11609       elf_gp (isec->owner) = off;
11610       return TRUE;
11611     }
11612
11613   /* During the second pass toc_first_sec points to the start of
11614      a toc group, and toc_curr is used to track the old elf_gp.
11615      We use toc_bfd to ensure we only look at each bfd once.  */
11616   if (htab->toc_bfd == isec->owner)
11617     return TRUE;
11618   htab->toc_bfd = isec->owner;
11619
11620   if (htab->toc_first_sec == NULL
11621       || htab->toc_curr != elf_gp (isec->owner))
11622     {
11623       htab->toc_curr = elf_gp (isec->owner);
11624       htab->toc_first_sec = isec;
11625     }
11626   addr = (htab->toc_first_sec->output_offset
11627           + htab->toc_first_sec->output_section->vma);
11628   off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
11629   elf_gp (isec->owner) = off;
11630
11631   return TRUE;
11632 }
11633
11634 /* Called via elf_link_hash_traverse to merge GOT entries for global
11635    symbol H.  */
11636
11637 static bfd_boolean
11638 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11639 {
11640   if (h->root.type == bfd_link_hash_indirect)
11641     return TRUE;
11642
11643   merge_got_entries (&h->got.glist);
11644
11645   return TRUE;
11646 }
11647
11648 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11649    symbol H.  */
11650
11651 static bfd_boolean
11652 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11653 {
11654   struct got_entry *gent;
11655
11656   if (h->root.type == bfd_link_hash_indirect)
11657     return TRUE;
11658
11659   for (gent = h->got.glist; gent != NULL; gent = gent->next)
11660     if (!gent->is_indirect)
11661       allocate_got (h, (struct bfd_link_info *) inf, gent);
11662   return TRUE;
11663 }
11664
11665 /* Called on the first multitoc pass after the last call to
11666    ppc64_elf_next_toc_section.  This function removes duplicate GOT
11667    entries.  */
11668
11669 bfd_boolean
11670 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11671 {
11672   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11673   struct bfd *ibfd, *ibfd2;
11674   bfd_boolean done_something;
11675
11676   htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11677
11678   if (!htab->do_multi_toc)
11679     return FALSE;
11680
11681   /* Merge global sym got entries within a toc group.  */
11682   elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11683
11684   /* And tlsld_got.  */
11685   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11686     {
11687       struct got_entry *ent, *ent2;
11688
11689       if (!is_ppc64_elf (ibfd))
11690         continue;
11691
11692       ent = ppc64_tlsld_got (ibfd);
11693       if (!ent->is_indirect
11694           && ent->got.offset != (bfd_vma) -1)
11695         {
11696           for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
11697             {
11698               if (!is_ppc64_elf (ibfd2))
11699                 continue;
11700
11701               ent2 = ppc64_tlsld_got (ibfd2);
11702               if (!ent2->is_indirect
11703                   && ent2->got.offset != (bfd_vma) -1
11704                   && elf_gp (ibfd2) == elf_gp (ibfd))
11705                 {
11706                   ent2->is_indirect = TRUE;
11707                   ent2->got.ent = ent;
11708                 }
11709             }
11710         }
11711     }
11712
11713   /* Zap sizes of got sections.  */
11714   htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11715   htab->elf.irelplt->size -= htab->got_reli_size;
11716   htab->got_reli_size = 0;
11717
11718   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11719     {
11720       asection *got, *relgot;
11721
11722       if (!is_ppc64_elf (ibfd))
11723         continue;
11724
11725       got = ppc64_elf_tdata (ibfd)->got;
11726       if (got != NULL)
11727         {
11728           got->rawsize = got->size;
11729           got->size = 0;
11730           relgot = ppc64_elf_tdata (ibfd)->relgot;
11731           relgot->rawsize = relgot->size;
11732           relgot->size = 0;
11733         }
11734     }
11735
11736   /* Now reallocate the got, local syms first.  We don't need to
11737      allocate section contents again since we never increase size.  */
11738   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11739     {
11740       struct got_entry **lgot_ents;
11741       struct got_entry **end_lgot_ents;
11742       struct plt_entry **local_plt;
11743       struct plt_entry **end_local_plt;
11744       unsigned char *lgot_masks;
11745       bfd_size_type locsymcount;
11746       Elf_Internal_Shdr *symtab_hdr;
11747       asection *s;
11748
11749       if (!is_ppc64_elf (ibfd))
11750         continue;
11751
11752       lgot_ents = elf_local_got_ents (ibfd);
11753       if (!lgot_ents)
11754         continue;
11755
11756       symtab_hdr = &elf_symtab_hdr (ibfd);
11757       locsymcount = symtab_hdr->sh_info;
11758       end_lgot_ents = lgot_ents + locsymcount;
11759       local_plt = (struct plt_entry **) end_lgot_ents;
11760       end_local_plt = local_plt + locsymcount;
11761       lgot_masks = (unsigned char *) end_local_plt;
11762       s = ppc64_elf_tdata (ibfd)->got;
11763       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11764         {
11765           struct got_entry *ent;
11766
11767           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11768             {
11769               unsigned int ent_size = 8;
11770               unsigned int rel_size = sizeof (Elf64_External_Rela);
11771
11772               ent->got.offset = s->size;
11773               if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11774                 {
11775                   ent_size *= 2;
11776                   rel_size *= 2;
11777                 }
11778               s->size += ent_size;
11779               if ((*lgot_masks & PLT_IFUNC) != 0)
11780                 {
11781                   htab->elf.irelplt->size += rel_size;
11782                   htab->got_reli_size += rel_size;
11783                 }
11784               else if (bfd_link_pic (info))
11785                 {
11786                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11787                   srel->size += rel_size;
11788                 }
11789             }
11790         }
11791     }
11792
11793   elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11794
11795   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11796     {
11797       struct got_entry *ent;
11798
11799       if (!is_ppc64_elf (ibfd))
11800         continue;
11801
11802       ent = ppc64_tlsld_got (ibfd);
11803       if (!ent->is_indirect
11804           && ent->got.offset != (bfd_vma) -1)
11805         {
11806           asection *s = ppc64_elf_tdata (ibfd)->got;
11807           ent->got.offset = s->size;
11808           s->size += 16;
11809           if (bfd_link_pic (info))
11810             {
11811               asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11812               srel->size += sizeof (Elf64_External_Rela);
11813             }
11814         }
11815     }
11816
11817   done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11818   if (!done_something)
11819     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11820       {
11821         asection *got;
11822
11823         if (!is_ppc64_elf (ibfd))
11824           continue;
11825
11826         got = ppc64_elf_tdata (ibfd)->got;
11827         if (got != NULL)
11828           {
11829             done_something = got->rawsize != got->size;
11830             if (done_something)
11831               break;
11832           }
11833       }
11834
11835   if (done_something)
11836     (*htab->params->layout_sections_again) ();
11837
11838   /* Set up for second pass over toc sections to recalculate elf_gp
11839      on input sections.  */
11840   htab->toc_bfd = NULL;
11841   htab->toc_first_sec = NULL;
11842   htab->second_toc_pass = TRUE;
11843   return done_something;
11844 }
11845
11846 /* Called after second pass of multitoc partitioning.  */
11847
11848 void
11849 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11850 {
11851   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11852
11853   /* After the second pass, toc_curr tracks the TOC offset used
11854      for code sections below in ppc64_elf_next_input_section.  */
11855   htab->toc_curr = TOC_BASE_OFF;
11856 }
11857
11858 /* No toc references were found in ISEC.  If the code in ISEC makes no
11859    calls, then there's no need to use toc adjusting stubs when branching
11860    into ISEC.  Actually, indirect calls from ISEC are OK as they will
11861    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
11862    needed, and 2 if a cyclical call-graph was found but no other reason
11863    for a stub was detected.  If called from the top level, a return of
11864    2 means the same as a return of 0.  */
11865
11866 static int
11867 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11868 {
11869   int ret;
11870
11871   /* Mark this section as checked.  */
11872   isec->call_check_done = 1;
11873
11874   /* We know none of our code bearing sections will need toc stubs.  */
11875   if ((isec->flags & SEC_LINKER_CREATED) != 0)
11876     return 0;
11877
11878   if (isec->size == 0)
11879     return 0;
11880
11881   if (isec->output_section == NULL)
11882     return 0;
11883
11884   ret = 0;
11885   if (isec->reloc_count != 0)
11886     {
11887       Elf_Internal_Rela *relstart, *rel;
11888       Elf_Internal_Sym *local_syms;
11889       struct ppc_link_hash_table *htab;
11890
11891       relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11892                                             info->keep_memory);
11893       if (relstart == NULL)
11894         return -1;
11895
11896       /* Look for branches to outside of this section.  */
11897       local_syms = NULL;
11898       htab = ppc_hash_table (info);
11899       if (htab == NULL)
11900         return -1;
11901
11902       for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11903         {
11904           enum elf_ppc64_reloc_type r_type;
11905           unsigned long r_symndx;
11906           struct elf_link_hash_entry *h;
11907           struct ppc_link_hash_entry *eh;
11908           Elf_Internal_Sym *sym;
11909           asection *sym_sec;
11910           struct _opd_sec_data *opd;
11911           bfd_vma sym_value;
11912           bfd_vma dest;
11913
11914           r_type = ELF64_R_TYPE (rel->r_info);
11915           if (r_type != R_PPC64_REL24
11916               && r_type != R_PPC64_REL14
11917               && r_type != R_PPC64_REL14_BRTAKEN
11918               && r_type != R_PPC64_REL14_BRNTAKEN)
11919             continue;
11920
11921           r_symndx = ELF64_R_SYM (rel->r_info);
11922           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11923                           isec->owner))
11924             {
11925               ret = -1;
11926               break;
11927             }
11928
11929           /* Calls to dynamic lib functions go through a plt call stub
11930              that uses r2.  */
11931           eh = (struct ppc_link_hash_entry *) h;
11932           if (eh != NULL
11933               && (eh->elf.plt.plist != NULL
11934                   || (eh->oh != NULL
11935                       && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11936             {
11937               ret = 1;
11938               break;
11939             }
11940
11941           if (sym_sec == NULL)
11942             /* Ignore other undefined symbols.  */
11943             continue;
11944
11945           /* Assume branches to other sections not included in the
11946              link need stubs too, to cover -R and absolute syms.  */
11947           if (sym_sec->output_section == NULL)
11948             {
11949               ret = 1;
11950               break;
11951             }
11952
11953           if (h == NULL)
11954             sym_value = sym->st_value;
11955           else
11956             {
11957               if (h->root.type != bfd_link_hash_defined
11958                   && h->root.type != bfd_link_hash_defweak)
11959                 abort ();
11960               sym_value = h->root.u.def.value;
11961             }
11962           sym_value += rel->r_addend;
11963
11964           /* If this branch reloc uses an opd sym, find the code section.  */
11965           opd = get_opd_info (sym_sec);
11966           if (opd != NULL)
11967             {
11968               if (h == NULL && opd->adjust != NULL)
11969                 {
11970                   long adjust;
11971
11972                   adjust = opd->adjust[OPD_NDX (sym_value)];
11973                   if (adjust == -1)
11974                     /* Assume deleted functions won't ever be called.  */
11975                     continue;
11976                   sym_value += adjust;
11977                 }
11978
11979               dest = opd_entry_value (sym_sec, sym_value,
11980                                       &sym_sec, NULL, FALSE);
11981               if (dest == (bfd_vma) -1)
11982                 continue;
11983             }
11984           else
11985             dest = (sym_value
11986                     + sym_sec->output_offset
11987                     + sym_sec->output_section->vma);
11988
11989           /* Ignore branch to self.  */
11990           if (sym_sec == isec)
11991             continue;
11992
11993           /* If the called function uses the toc, we need a stub.  */
11994           if (sym_sec->has_toc_reloc
11995               || sym_sec->makes_toc_func_call)
11996             {
11997               ret = 1;
11998               break;
11999             }
12000
12001           /* Assume any branch that needs a long branch stub might in fact
12002              need a plt_branch stub.  A plt_branch stub uses r2.  */
12003           else if (dest - (isec->output_offset
12004                            + isec->output_section->vma
12005                            + rel->r_offset) + (1 << 25)
12006                    >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
12007                                                              ? h->other
12008                                                              : sym->st_other))
12009             {
12010               ret = 1;
12011               break;
12012             }
12013
12014           /* If calling back to a section in the process of being
12015              tested, we can't say for sure that no toc adjusting stubs
12016              are needed, so don't return zero.  */
12017           else if (sym_sec->call_check_in_progress)
12018             ret = 2;
12019
12020           /* Branches to another section that itself doesn't have any TOC
12021              references are OK.  Recursively call ourselves to check.  */
12022           else if (!sym_sec->call_check_done)
12023             {
12024               int recur;
12025
12026               /* Mark current section as indeterminate, so that other
12027                  sections that call back to current won't be marked as
12028                  known.  */
12029               isec->call_check_in_progress = 1;
12030               recur = toc_adjusting_stub_needed (info, sym_sec);
12031               isec->call_check_in_progress = 0;
12032
12033               if (recur != 0)
12034                 {
12035                   ret = recur;
12036                   if (recur != 2)
12037                     break;
12038                 }
12039             }
12040         }
12041
12042       if (local_syms != NULL
12043           && (elf_symtab_hdr (isec->owner).contents
12044               != (unsigned char *) local_syms))
12045         free (local_syms);
12046       if (elf_section_data (isec)->relocs != relstart)
12047         free (relstart);
12048     }
12049
12050   if ((ret & 1) == 0
12051       && isec->map_head.s != NULL
12052       && (strcmp (isec->output_section->name, ".init") == 0
12053           || strcmp (isec->output_section->name, ".fini") == 0))
12054     {
12055       if (isec->map_head.s->has_toc_reloc
12056           || isec->map_head.s->makes_toc_func_call)
12057         ret = 1;
12058       else if (!isec->map_head.s->call_check_done)
12059         {
12060           int recur;
12061           isec->call_check_in_progress = 1;
12062           recur = toc_adjusting_stub_needed (info, isec->map_head.s);
12063           isec->call_check_in_progress = 0;
12064           if (recur != 0)
12065             ret = recur;
12066         }
12067     }
12068
12069   if (ret == 1)
12070     isec->makes_toc_func_call = 1;
12071
12072   return ret;
12073 }
12074
12075 /* The linker repeatedly calls this function for each input section,
12076    in the order that input sections are linked into output sections.
12077    Build lists of input sections to determine groupings between which
12078    we may insert linker stubs.  */
12079
12080 bfd_boolean
12081 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
12082 {
12083   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12084
12085   if (htab == NULL)
12086     return FALSE;
12087
12088   if ((isec->output_section->flags & SEC_CODE) != 0
12089       && isec->output_section->id < htab->sec_info_arr_size)
12090     {
12091       /* This happens to make the list in reverse order,
12092          which is what we want.  */
12093       htab->sec_info[isec->id].u.list
12094         = htab->sec_info[isec->output_section->id].u.list;
12095       htab->sec_info[isec->output_section->id].u.list = isec;
12096     }
12097
12098   if (htab->multi_toc_needed)
12099     {
12100       /* Analyse sections that aren't already flagged as needing a
12101          valid toc pointer.  Exclude .fixup for the linux kernel.
12102          .fixup contains branches, but only back to the function that
12103          hit an exception.  */
12104       if (!(isec->has_toc_reloc
12105             || (isec->flags & SEC_CODE) == 0
12106             || strcmp (isec->name, ".fixup") == 0
12107             || isec->call_check_done))
12108         {
12109           if (toc_adjusting_stub_needed (info, isec) < 0)
12110             return FALSE;
12111         }
12112       /* Make all sections use the TOC assigned for this object file.
12113          This will be wrong for pasted sections;  We fix that in
12114          check_pasted_section().  */
12115       if (elf_gp (isec->owner) != 0)
12116         htab->toc_curr = elf_gp (isec->owner);
12117     }
12118
12119   htab->sec_info[isec->id].toc_off = htab->toc_curr;
12120   return TRUE;
12121 }
12122
12123 /* Check that all .init and .fini sections use the same toc, if they
12124    have toc relocs.  */
12125
12126 static bfd_boolean
12127 check_pasted_section (struct bfd_link_info *info, const char *name)
12128 {
12129   asection *o = bfd_get_section_by_name (info->output_bfd, name);
12130
12131   if (o != NULL)
12132     {
12133       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12134       bfd_vma toc_off = 0;
12135       asection *i;
12136
12137       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12138         if (i->has_toc_reloc)
12139           {
12140             if (toc_off == 0)
12141               toc_off = htab->sec_info[i->id].toc_off;
12142             else if (toc_off != htab->sec_info[i->id].toc_off)
12143               return FALSE;
12144           }
12145
12146       if (toc_off == 0)
12147         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12148           if (i->makes_toc_func_call)
12149             {
12150               toc_off = htab->sec_info[i->id].toc_off;
12151               break;
12152             }
12153
12154       /* Make sure the whole pasted function uses the same toc offset.  */
12155       if (toc_off != 0)
12156         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12157           htab->sec_info[i->id].toc_off = toc_off;
12158     }
12159   return TRUE;
12160 }
12161
12162 bfd_boolean
12163 ppc64_elf_check_init_fini (struct bfd_link_info *info)
12164 {
12165   return (check_pasted_section (info, ".init")
12166           & check_pasted_section (info, ".fini"));
12167 }
12168
12169 /* See whether we can group stub sections together.  Grouping stub
12170    sections may result in fewer stubs.  More importantly, we need to
12171    put all .init* and .fini* stubs at the beginning of the .init or
12172    .fini output sections respectively, because glibc splits the
12173    _init and _fini functions into multiple parts.  Putting a stub in
12174    the middle of a function is not a good idea.  */
12175
12176 static bfd_boolean
12177 group_sections (struct bfd_link_info *info,
12178                 bfd_size_type stub_group_size,
12179                 bfd_boolean stubs_always_before_branch)
12180 {
12181   struct ppc_link_hash_table *htab;
12182   asection *osec;
12183   bfd_boolean suppress_size_errors;
12184
12185   htab = ppc_hash_table (info);
12186   if (htab == NULL)
12187     return FALSE;
12188
12189   suppress_size_errors = FALSE;
12190   if (stub_group_size == 1)
12191     {
12192       /* Default values.  */
12193       if (stubs_always_before_branch)
12194         stub_group_size = 0x1e00000;
12195       else
12196         stub_group_size = 0x1c00000;
12197       suppress_size_errors = TRUE;
12198     }
12199
12200   for (osec = info->output_bfd->sections; osec != NULL; osec = osec->next)
12201     {
12202       asection *tail;
12203
12204       if (osec->id >= htab->sec_info_arr_size)
12205         continue;
12206
12207       tail = htab->sec_info[osec->id].u.list;
12208       while (tail != NULL)
12209         {
12210           asection *curr;
12211           asection *prev;
12212           bfd_size_type total;
12213           bfd_boolean big_sec;
12214           bfd_vma curr_toc;
12215           struct map_stub *group;
12216           bfd_size_type group_size;
12217
12218           curr = tail;
12219           total = tail->size;
12220           group_size = (ppc64_elf_section_data (tail) != NULL
12221                         && ppc64_elf_section_data (tail)->has_14bit_branch
12222                         ? stub_group_size >> 10 : stub_group_size);
12223
12224           big_sec = total > group_size;
12225           if (big_sec && !suppress_size_errors)
12226             /* xgettext:c-format */
12227             _bfd_error_handler (_("%B section %A exceeds stub group size"),
12228                                 tail->owner, tail);
12229           curr_toc = htab->sec_info[tail->id].toc_off;
12230
12231           while ((prev = htab->sec_info[curr->id].u.list) != NULL
12232                  && ((total += curr->output_offset - prev->output_offset)
12233                      < (ppc64_elf_section_data (prev) != NULL
12234                         && ppc64_elf_section_data (prev)->has_14bit_branch
12235                         ? (group_size = stub_group_size >> 10) : group_size))
12236                  && htab->sec_info[prev->id].toc_off == curr_toc)
12237             curr = prev;
12238
12239           /* OK, the size from the start of CURR to the end is less
12240              than group_size and thus can be handled by one stub
12241              section.  (or the tail section is itself larger than
12242              group_size, in which case we may be toast.)  We should
12243              really be keeping track of the total size of stubs added
12244              here, as stubs contribute to the final output section
12245              size.  That's a little tricky, and this way will only
12246              break if stubs added make the total size more than 2^25,
12247              ie. for the default stub_group_size, if stubs total more
12248              than 2097152 bytes, or nearly 75000 plt call stubs.  */
12249           group = bfd_alloc (curr->owner, sizeof (*group));
12250           if (group == NULL)
12251             return FALSE;
12252           group->link_sec = curr;
12253           group->stub_sec = NULL;
12254           group->needs_save_res = 0;
12255           group->next = htab->group;
12256           htab->group = group;
12257           do
12258             {
12259               prev = htab->sec_info[tail->id].u.list;
12260               /* Set up this stub group.  */
12261               htab->sec_info[tail->id].u.group = group;
12262             }
12263           while (tail != curr && (tail = prev) != NULL);
12264
12265           /* But wait, there's more!  Input sections up to group_size
12266              bytes before the stub section can be handled by it too.
12267              Don't do this if we have a really large section after the
12268              stubs, as adding more stubs increases the chance that
12269              branches may not reach into the stub section.  */
12270           if (!stubs_always_before_branch && !big_sec)
12271             {
12272               total = 0;
12273               while (prev != NULL
12274                      && ((total += tail->output_offset - prev->output_offset)
12275                          < (ppc64_elf_section_data (prev) != NULL
12276                             && ppc64_elf_section_data (prev)->has_14bit_branch
12277                             ? (group_size = stub_group_size >> 10) : group_size))
12278                      && htab->sec_info[prev->id].toc_off == curr_toc)
12279                 {
12280                   tail = prev;
12281                   prev = htab->sec_info[tail->id].u.list;
12282                   htab->sec_info[tail->id].u.group = group;
12283                 }
12284             }
12285           tail = prev;
12286         }
12287     }
12288   return TRUE;
12289 }
12290
12291 static const unsigned char glink_eh_frame_cie[] =
12292 {
12293   0, 0, 0, 16,                          /* length.  */
12294   0, 0, 0, 0,                           /* id.  */
12295   1,                                    /* CIE version.  */
12296   'z', 'R', 0,                          /* Augmentation string.  */
12297   4,                                    /* Code alignment.  */
12298   0x78,                                 /* Data alignment.  */
12299   65,                                   /* RA reg.  */
12300   1,                                    /* Augmentation size.  */
12301   DW_EH_PE_pcrel | DW_EH_PE_sdata4,     /* FDE encoding.  */
12302   DW_CFA_def_cfa, 1, 0                  /* def_cfa: r1 offset 0.  */
12303 };
12304
12305 /* Stripping output sections is normally done before dynamic section
12306    symbols have been allocated.  This function is called later, and
12307    handles cases like htab->brlt which is mapped to its own output
12308    section.  */
12309
12310 static void
12311 maybe_strip_output (struct bfd_link_info *info, asection *isec)
12312 {
12313   if (isec->size == 0
12314       && isec->output_section->size == 0
12315       && !(isec->output_section->flags & SEC_KEEP)
12316       && !bfd_section_removed_from_list (info->output_bfd,
12317                                          isec->output_section)
12318       && elf_section_data (isec->output_section)->dynindx == 0)
12319     {
12320       isec->output_section->flags |= SEC_EXCLUDE;
12321       bfd_section_list_remove (info->output_bfd, isec->output_section);
12322       info->output_bfd->section_count--;
12323     }
12324 }
12325
12326 /* Determine and set the size of the stub section for a final link.
12327
12328    The basic idea here is to examine all the relocations looking for
12329    PC-relative calls to a target that is unreachable with a "bl"
12330    instruction.  */
12331
12332 bfd_boolean
12333 ppc64_elf_size_stubs (struct bfd_link_info *info)
12334 {
12335   bfd_size_type stub_group_size;
12336   bfd_boolean stubs_always_before_branch;
12337   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12338
12339   if (htab == NULL)
12340     return FALSE;
12341
12342   if (htab->params->plt_thread_safe == -1 && !bfd_link_executable (info))
12343     htab->params->plt_thread_safe = 1;
12344   if (!htab->opd_abi)
12345     htab->params->plt_thread_safe = 0;
12346   else if (htab->params->plt_thread_safe == -1)
12347     {
12348       static const char *const thread_starter[] =
12349         {
12350           "pthread_create",
12351           /* libstdc++ */
12352           "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
12353           /* librt */
12354           "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
12355           "mq_notify", "create_timer",
12356           /* libanl */
12357           "getaddrinfo_a",
12358           /* libgomp */
12359           "GOMP_parallel",
12360           "GOMP_parallel_start",
12361           "GOMP_parallel_loop_static",
12362           "GOMP_parallel_loop_static_start",
12363           "GOMP_parallel_loop_dynamic",
12364           "GOMP_parallel_loop_dynamic_start",
12365           "GOMP_parallel_loop_guided",
12366           "GOMP_parallel_loop_guided_start",
12367           "GOMP_parallel_loop_runtime",
12368           "GOMP_parallel_loop_runtime_start",
12369           "GOMP_parallel_sections",
12370           "GOMP_parallel_sections_start",
12371           /* libgo */
12372           "__go_go",
12373         };
12374       unsigned i;
12375
12376       for (i = 0; i < ARRAY_SIZE (thread_starter); i++)
12377         {
12378           struct elf_link_hash_entry *h;
12379           h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
12380                                     FALSE, FALSE, TRUE);
12381           htab->params->plt_thread_safe = h != NULL && h->ref_regular;
12382           if (htab->params->plt_thread_safe)
12383             break;
12384         }
12385     }
12386   stubs_always_before_branch = htab->params->group_size < 0;
12387   if (htab->params->group_size < 0)
12388     stub_group_size = -htab->params->group_size;
12389   else
12390     stub_group_size = htab->params->group_size;
12391
12392   if (!group_sections (info, stub_group_size, stubs_always_before_branch))
12393     return FALSE;
12394
12395 #define STUB_SHRINK_ITER 20
12396   /* Loop until no stubs added.  After iteration 20 of this loop we may
12397      exit on a stub section shrinking.  This is to break out of a
12398      pathological case where adding stubs on one iteration decreases
12399      section gaps (perhaps due to alignment), which then requires
12400      fewer or smaller stubs on the next iteration.  */
12401
12402   while (1)
12403     {
12404       bfd *input_bfd;
12405       unsigned int bfd_indx;
12406       struct map_stub *group;
12407       asection *stub_sec;
12408
12409       htab->stub_iteration += 1;
12410
12411       for (input_bfd = info->input_bfds, bfd_indx = 0;
12412            input_bfd != NULL;
12413            input_bfd = input_bfd->link.next, bfd_indx++)
12414         {
12415           Elf_Internal_Shdr *symtab_hdr;
12416           asection *section;
12417           Elf_Internal_Sym *local_syms = NULL;
12418
12419           if (!is_ppc64_elf (input_bfd))
12420             continue;
12421
12422           /* We'll need the symbol table in a second.  */
12423           symtab_hdr = &elf_symtab_hdr (input_bfd);
12424           if (symtab_hdr->sh_info == 0)
12425             continue;
12426
12427           /* Walk over each section attached to the input bfd.  */
12428           for (section = input_bfd->sections;
12429                section != NULL;
12430                section = section->next)
12431             {
12432               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
12433
12434               /* If there aren't any relocs, then there's nothing more
12435                  to do.  */
12436               if ((section->flags & SEC_RELOC) == 0
12437                   || (section->flags & SEC_ALLOC) == 0
12438                   || (section->flags & SEC_LOAD) == 0
12439                   || (section->flags & SEC_CODE) == 0
12440                   || section->reloc_count == 0)
12441                 continue;
12442
12443               /* If this section is a link-once section that will be
12444                  discarded, then don't create any stubs.  */
12445               if (section->output_section == NULL
12446                   || section->output_section->owner != info->output_bfd)
12447                 continue;
12448
12449               /* Get the relocs.  */
12450               internal_relocs
12451                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
12452                                              info->keep_memory);
12453               if (internal_relocs == NULL)
12454                 goto error_ret_free_local;
12455
12456               /* Now examine each relocation.  */
12457               irela = internal_relocs;
12458               irelaend = irela + section->reloc_count;
12459               for (; irela < irelaend; irela++)
12460                 {
12461                   enum elf_ppc64_reloc_type r_type;
12462                   unsigned int r_indx;
12463                   enum ppc_stub_type stub_type;
12464                   struct ppc_stub_hash_entry *stub_entry;
12465                   asection *sym_sec, *code_sec;
12466                   bfd_vma sym_value, code_value;
12467                   bfd_vma destination;
12468                   unsigned long local_off;
12469                   bfd_boolean ok_dest;
12470                   struct ppc_link_hash_entry *hash;
12471                   struct ppc_link_hash_entry *fdh;
12472                   struct elf_link_hash_entry *h;
12473                   Elf_Internal_Sym *sym;
12474                   char *stub_name;
12475                   const asection *id_sec;
12476                   struct _opd_sec_data *opd;
12477                   struct plt_entry *plt_ent;
12478
12479                   r_type = ELF64_R_TYPE (irela->r_info);
12480                   r_indx = ELF64_R_SYM (irela->r_info);
12481
12482                   if (r_type >= R_PPC64_max)
12483                     {
12484                       bfd_set_error (bfd_error_bad_value);
12485                       goto error_ret_free_internal;
12486                     }
12487
12488                   /* Only look for stubs on branch instructions.  */
12489                   if (r_type != R_PPC64_REL24
12490                       && r_type != R_PPC64_REL14
12491                       && r_type != R_PPC64_REL14_BRTAKEN
12492                       && r_type != R_PPC64_REL14_BRNTAKEN)
12493                     continue;
12494
12495                   /* Now determine the call target, its name, value,
12496                      section.  */
12497                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12498                                   r_indx, input_bfd))
12499                     goto error_ret_free_internal;
12500                   hash = (struct ppc_link_hash_entry *) h;
12501
12502                   ok_dest = FALSE;
12503                   fdh = NULL;
12504                   sym_value = 0;
12505                   if (hash == NULL)
12506                     {
12507                       sym_value = sym->st_value;
12508                       if (sym_sec != NULL
12509                           && sym_sec->output_section != NULL)
12510                         ok_dest = TRUE;
12511                     }
12512                   else if (hash->elf.root.type == bfd_link_hash_defined
12513                            || hash->elf.root.type == bfd_link_hash_defweak)
12514                     {
12515                       sym_value = hash->elf.root.u.def.value;
12516                       if (sym_sec->output_section != NULL)
12517                         ok_dest = TRUE;
12518                     }
12519                   else if (hash->elf.root.type == bfd_link_hash_undefweak
12520                            || hash->elf.root.type == bfd_link_hash_undefined)
12521                     {
12522                       /* Recognise an old ABI func code entry sym, and
12523                          use the func descriptor sym instead if it is
12524                          defined.  */
12525                       if (hash->elf.root.root.string[0] == '.'
12526                           && hash->oh != NULL)
12527                         {
12528                           fdh = ppc_follow_link (hash->oh);
12529                           if (fdh->elf.root.type == bfd_link_hash_defined
12530                               || fdh->elf.root.type == bfd_link_hash_defweak)
12531                             {
12532                               sym_sec = fdh->elf.root.u.def.section;
12533                               sym_value = fdh->elf.root.u.def.value;
12534                               if (sym_sec->output_section != NULL)
12535                                 ok_dest = TRUE;
12536                             }
12537                           else
12538                             fdh = NULL;
12539                         }
12540                     }
12541                   else
12542                     {
12543                       bfd_set_error (bfd_error_bad_value);
12544                       goto error_ret_free_internal;
12545                     }
12546
12547                   destination = 0;
12548                   local_off = 0;
12549                   if (ok_dest)
12550                     {
12551                       sym_value += irela->r_addend;
12552                       destination = (sym_value
12553                                      + sym_sec->output_offset
12554                                      + sym_sec->output_section->vma);
12555                       local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12556                                                             ? hash->elf.other
12557                                                             : sym->st_other);
12558                     }
12559
12560                   code_sec = sym_sec;
12561                   code_value = sym_value;
12562                   opd = get_opd_info (sym_sec);
12563                   if (opd != NULL)
12564                     {
12565                       bfd_vma dest;
12566
12567                       if (hash == NULL && opd->adjust != NULL)
12568                         {
12569                           long adjust = opd->adjust[OPD_NDX (sym_value)];
12570                           if (adjust == -1)
12571                             continue;
12572                           code_value += adjust;
12573                           sym_value += adjust;
12574                         }
12575                       dest = opd_entry_value (sym_sec, sym_value,
12576                                               &code_sec, &code_value, FALSE);
12577                       if (dest != (bfd_vma) -1)
12578                         {
12579                           destination = dest;
12580                           if (fdh != NULL)
12581                             {
12582                               /* Fixup old ABI sym to point at code
12583                                  entry.  */
12584                               hash->elf.root.type = bfd_link_hash_defweak;
12585                               hash->elf.root.u.def.section = code_sec;
12586                               hash->elf.root.u.def.value = code_value;
12587                             }
12588                         }
12589                     }
12590
12591                   /* Determine what (if any) linker stub is needed.  */
12592                   plt_ent = NULL;
12593                   stub_type = ppc_type_of_stub (section, irela, &hash,
12594                                                 &plt_ent, destination,
12595                                                 local_off);
12596
12597                   if (stub_type != ppc_stub_plt_call)
12598                     {
12599                       /* Check whether we need a TOC adjusting stub.
12600                          Since the linker pastes together pieces from
12601                          different object files when creating the
12602                          _init and _fini functions, it may be that a
12603                          call to what looks like a local sym is in
12604                          fact a call needing a TOC adjustment.  */
12605                       if (code_sec != NULL
12606                           && code_sec->output_section != NULL
12607                           && (htab->sec_info[code_sec->id].toc_off
12608                               != htab->sec_info[section->id].toc_off)
12609                           && (code_sec->has_toc_reloc
12610                               || code_sec->makes_toc_func_call))
12611                         stub_type = ppc_stub_long_branch_r2off;
12612                     }
12613
12614                   if (stub_type == ppc_stub_none)
12615                     continue;
12616
12617                   /* __tls_get_addr calls might be eliminated.  */
12618                   if (stub_type != ppc_stub_plt_call
12619                       && hash != NULL
12620                       && (hash == htab->tls_get_addr
12621                           || hash == htab->tls_get_addr_fd)
12622                       && section->has_tls_reloc
12623                       && irela != internal_relocs)
12624                     {
12625                       /* Get tls info.  */
12626                       unsigned char *tls_mask;
12627
12628                       if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12629                                          irela - 1, input_bfd))
12630                         goto error_ret_free_internal;
12631                       if (*tls_mask != 0)
12632                         continue;
12633                     }
12634
12635                   if (stub_type == ppc_stub_plt_call)
12636                     {
12637                       if (!htab->opd_abi
12638                           && htab->params->plt_localentry0 != 0
12639                           && is_elfv2_localentry0 (&hash->elf))
12640                         htab->has_plt_localentry0 = 1;
12641                       else if (irela + 1 < irelaend
12642                                && irela[1].r_offset == irela->r_offset + 4
12643                                && (ELF64_R_TYPE (irela[1].r_info)
12644                                    == R_PPC64_TOCSAVE))
12645                         {
12646                           if (!tocsave_find (htab, INSERT,
12647                                              &local_syms, irela + 1, input_bfd))
12648                             goto error_ret_free_internal;
12649                         }
12650                       else
12651                         stub_type = ppc_stub_plt_call_r2save;
12652                     }
12653
12654                   /* Support for grouping stub sections.  */
12655                   id_sec = htab->sec_info[section->id].u.group->link_sec;
12656
12657                   /* Get the name of this stub.  */
12658                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12659                   if (!stub_name)
12660                     goto error_ret_free_internal;
12661
12662                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12663                                                      stub_name, FALSE, FALSE);
12664                   if (stub_entry != NULL)
12665                     {
12666                       /* The proper stub has already been created.  */
12667                       free (stub_name);
12668                       if (stub_type == ppc_stub_plt_call_r2save)
12669                         stub_entry->stub_type = stub_type;
12670                       continue;
12671                     }
12672
12673                   stub_entry = ppc_add_stub (stub_name, section, info);
12674                   if (stub_entry == NULL)
12675                     {
12676                       free (stub_name);
12677                     error_ret_free_internal:
12678                       if (elf_section_data (section)->relocs == NULL)
12679                         free (internal_relocs);
12680                     error_ret_free_local:
12681                       if (local_syms != NULL
12682                           && (symtab_hdr->contents
12683                               != (unsigned char *) local_syms))
12684                         free (local_syms);
12685                       return FALSE;
12686                     }
12687
12688                   stub_entry->stub_type = stub_type;
12689                   if (stub_type != ppc_stub_plt_call
12690                       && stub_type != ppc_stub_plt_call_r2save)
12691                     {
12692                       stub_entry->target_value = code_value;
12693                       stub_entry->target_section = code_sec;
12694                     }
12695                   else
12696                     {
12697                       stub_entry->target_value = sym_value;
12698                       stub_entry->target_section = sym_sec;
12699                     }
12700                   stub_entry->h = hash;
12701                   stub_entry->plt_ent = plt_ent;
12702                   stub_entry->other = hash ? hash->elf.other : sym->st_other;
12703
12704                   if (stub_entry->h != NULL)
12705                     htab->stub_globals += 1;
12706                 }
12707
12708               /* We're done with the internal relocs, free them.  */
12709               if (elf_section_data (section)->relocs != internal_relocs)
12710                 free (internal_relocs);
12711             }
12712
12713           if (local_syms != NULL
12714               && symtab_hdr->contents != (unsigned char *) local_syms)
12715             {
12716               if (!info->keep_memory)
12717                 free (local_syms);
12718               else
12719                 symtab_hdr->contents = (unsigned char *) local_syms;
12720             }
12721         }
12722
12723       /* We may have added some stubs.  Find out the new size of the
12724          stub sections.  */
12725       for (stub_sec = htab->params->stub_bfd->sections;
12726            stub_sec != NULL;
12727            stub_sec = stub_sec->next)
12728         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12729           {
12730             if (htab->stub_iteration <= STUB_SHRINK_ITER
12731                 || stub_sec->rawsize < stub_sec->size)
12732               /* Past STUB_SHRINK_ITER, rawsize is the max size seen.  */
12733               stub_sec->rawsize = stub_sec->size;
12734             stub_sec->size = 0;
12735             stub_sec->reloc_count = 0;
12736             stub_sec->flags &= ~SEC_RELOC;
12737           }
12738
12739       htab->brlt->size = 0;
12740       htab->brlt->reloc_count = 0;
12741       htab->brlt->flags &= ~SEC_RELOC;
12742       if (htab->relbrlt != NULL)
12743         htab->relbrlt->size = 0;
12744
12745       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12746
12747       for (group = htab->group; group != NULL; group = group->next)
12748         if (group->needs_save_res)
12749           group->stub_sec->size += htab->sfpr->size;
12750
12751       if (info->emitrelocations
12752           && htab->glink != NULL && htab->glink->size != 0)
12753         {
12754           htab->glink->reloc_count = 1;
12755           htab->glink->flags |= SEC_RELOC;
12756         }
12757
12758       if (htab->glink_eh_frame != NULL
12759           && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12760           && htab->glink_eh_frame->output_section->size != 0)
12761         {
12762           size_t size = 0, align = 4;
12763
12764           for (stub_sec = htab->params->stub_bfd->sections;
12765                stub_sec != NULL;
12766                stub_sec = stub_sec->next)
12767             if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12768               size += (17 + align - 1) & -align;
12769           if (htab->glink != NULL && htab->glink->size != 0)
12770             size += (24 + align - 1) & -align;
12771           if (size != 0)
12772             size += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
12773           align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
12774           size = (size + align - 1) & -align;
12775           htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12776           htab->glink_eh_frame->size = size;
12777         }
12778
12779       if (htab->params->plt_stub_align != 0)
12780         for (stub_sec = htab->params->stub_bfd->sections;
12781              stub_sec != NULL;
12782              stub_sec = stub_sec->next)
12783           if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12784             stub_sec->size = ((stub_sec->size
12785                                + (1 << htab->params->plt_stub_align) - 1)
12786                               & -(1 << htab->params->plt_stub_align));
12787
12788       for (stub_sec = htab->params->stub_bfd->sections;
12789            stub_sec != NULL;
12790            stub_sec = stub_sec->next)
12791         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12792             && stub_sec->rawsize != stub_sec->size
12793             && (htab->stub_iteration <= STUB_SHRINK_ITER
12794                 || stub_sec->rawsize < stub_sec->size))
12795           break;
12796
12797       if (stub_sec == NULL
12798           && (htab->glink_eh_frame == NULL
12799               || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12800         break;
12801
12802       /* Ask the linker to do its stuff.  */
12803       (*htab->params->layout_sections_again) ();
12804     }
12805
12806   if (htab->glink_eh_frame != NULL
12807       && htab->glink_eh_frame->size != 0)
12808     {
12809       bfd_vma val;
12810       bfd_byte *p, *last_fde;
12811       size_t last_fde_len, size, align, pad;
12812       asection *stub_sec;
12813
12814       p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12815       if (p == NULL)
12816         return FALSE;
12817       htab->glink_eh_frame->contents = p;
12818       last_fde = p;
12819       align = 4;
12820
12821       memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12822       /* CIE length (rewrite in case little-endian).  */
12823       last_fde_len = ((sizeof (glink_eh_frame_cie) + align - 1) & -align) - 4;
12824       bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12825       p += last_fde_len + 4;
12826
12827       for (stub_sec = htab->params->stub_bfd->sections;
12828            stub_sec != NULL;
12829            stub_sec = stub_sec->next)
12830         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12831           {
12832             last_fde = p;
12833             last_fde_len = ((17 + align - 1) & -align) - 4;
12834             /* FDE length.  */
12835             bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12836             p += 4;
12837             /* CIE pointer.  */
12838             val = p - htab->glink_eh_frame->contents;
12839             bfd_put_32 (htab->elf.dynobj, val, p);
12840             p += 4;
12841             /* Offset to stub section, written later.  */
12842             p += 4;
12843             /* stub section size.  */
12844             bfd_put_32 (htab->elf.dynobj, stub_sec->size, p);
12845             p += 4;
12846             /* Augmentation.  */
12847             p += 1;
12848             /* Pad.  */
12849             p += ((17 + align - 1) & -align) - 17;
12850           }
12851       if (htab->glink != NULL && htab->glink->size != 0)
12852         {
12853           last_fde = p;
12854           last_fde_len = ((24 + align - 1) & -align) - 4;
12855           /* FDE length.  */
12856           bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12857           p += 4;
12858           /* CIE pointer.  */
12859           val = p - htab->glink_eh_frame->contents;
12860           bfd_put_32 (htab->elf.dynobj, val, p);
12861           p += 4;
12862           /* Offset to .glink, written later.  */
12863           p += 4;
12864           /* .glink size.  */
12865           bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12866           p += 4;
12867           /* Augmentation.  */
12868           p += 1;
12869
12870           *p++ = DW_CFA_advance_loc + 1;
12871           *p++ = DW_CFA_register;
12872           *p++ = 65;
12873           *p++ = htab->opd_abi ? 12 : 0;
12874           *p++ = DW_CFA_advance_loc + 4;
12875           *p++ = DW_CFA_restore_extended;
12876           *p++ = 65;
12877           p += ((24 + align - 1) & -align) - 24;
12878         }
12879       /* Subsume any padding into the last FDE if user .eh_frame
12880          sections are aligned more than glink_eh_frame.  Otherwise any
12881          zero padding will be seen as a terminator.  */
12882       align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
12883       size = p - htab->glink_eh_frame->contents;
12884       pad = ((size + align - 1) & -align) - size;
12885       htab->glink_eh_frame->size = size + pad;
12886       bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12887     }
12888
12889   maybe_strip_output (info, htab->brlt);
12890   if (htab->glink_eh_frame != NULL)
12891     maybe_strip_output (info, htab->glink_eh_frame);
12892
12893   return TRUE;
12894 }
12895
12896 /* Called after we have determined section placement.  If sections
12897    move, we'll be called again.  Provide a value for TOCstart.  */
12898
12899 bfd_vma
12900 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12901 {
12902   asection *s;
12903   bfd_vma TOCstart, adjust;
12904
12905   if (info != NULL)
12906     {
12907       struct elf_link_hash_entry *h;
12908       struct elf_link_hash_table *htab = elf_hash_table (info);
12909
12910       if (is_elf_hash_table (htab)
12911           && htab->hgot != NULL)
12912         h = htab->hgot;
12913       else
12914         {
12915           h = elf_link_hash_lookup (htab, ".TOC.", FALSE, FALSE, TRUE);
12916           if (is_elf_hash_table (htab))
12917             htab->hgot = h;
12918         }
12919       if (h != NULL
12920           && h->root.type == bfd_link_hash_defined
12921           && !h->root.linker_def
12922           && (!is_elf_hash_table (htab)
12923               || h->def_regular))
12924         {
12925           TOCstart = (h->root.u.def.value - TOC_BASE_OFF
12926                       + h->root.u.def.section->output_offset
12927                       + h->root.u.def.section->output_section->vma);
12928           _bfd_set_gp_value (obfd, TOCstart);
12929           return TOCstart;
12930         }
12931     }
12932
12933   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12934      order.  The TOC starts where the first of these sections starts.  */
12935   s = bfd_get_section_by_name (obfd, ".got");
12936   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12937     s = bfd_get_section_by_name (obfd, ".toc");
12938   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12939     s = bfd_get_section_by_name (obfd, ".tocbss");
12940   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12941     s = bfd_get_section_by_name (obfd, ".plt");
12942   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12943     {
12944       /* This may happen for
12945          o  references to TOC base (SYM@toc / TOC[tc0]) without a
12946          .toc directive
12947          o  bad linker script
12948          o --gc-sections and empty TOC sections
12949
12950          FIXME: Warn user?  */
12951
12952       /* Look for a likely section.  We probably won't even be
12953          using TOCstart.  */
12954       for (s = obfd->sections; s != NULL; s = s->next)
12955         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
12956                          | SEC_EXCLUDE))
12957             == (SEC_ALLOC | SEC_SMALL_DATA))
12958           break;
12959       if (s == NULL)
12960         for (s = obfd->sections; s != NULL; s = s->next)
12961           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
12962               == (SEC_ALLOC | SEC_SMALL_DATA))
12963             break;
12964       if (s == NULL)
12965         for (s = obfd->sections; s != NULL; s = s->next)
12966           if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
12967               == SEC_ALLOC)
12968             break;
12969       if (s == NULL)
12970         for (s = obfd->sections; s != NULL; s = s->next)
12971           if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
12972             break;
12973     }
12974
12975   TOCstart = 0;
12976   if (s != NULL)
12977     TOCstart = s->output_section->vma + s->output_offset;
12978
12979   /* Force alignment.  */
12980   adjust = TOCstart & (TOC_BASE_ALIGN - 1);
12981   TOCstart -= adjust;
12982   _bfd_set_gp_value (obfd, TOCstart);
12983
12984   if (info != NULL && s != NULL)
12985     {
12986       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12987
12988       if (htab != NULL)
12989         {
12990           if (htab->elf.hgot != NULL)
12991             {
12992               htab->elf.hgot->root.u.def.value = TOC_BASE_OFF - adjust;
12993               htab->elf.hgot->root.u.def.section = s;
12994             }
12995         }
12996       else
12997         {
12998           struct bfd_link_hash_entry *bh = NULL;
12999           _bfd_generic_link_add_one_symbol (info, obfd, ".TOC.", BSF_GLOBAL,
13000                                             s, TOC_BASE_OFF - adjust,
13001                                             NULL, FALSE, FALSE, &bh);
13002         }
13003     }
13004   return TOCstart;
13005 }
13006
13007 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
13008    write out any global entry stubs.  */
13009
13010 static bfd_boolean
13011 build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
13012 {
13013   struct bfd_link_info *info;
13014   struct ppc_link_hash_table *htab;
13015   struct plt_entry *pent;
13016   asection *s;
13017
13018   if (h->root.type == bfd_link_hash_indirect)
13019     return TRUE;
13020
13021   if (!h->pointer_equality_needed)
13022     return TRUE;
13023
13024   if (h->def_regular)
13025     return TRUE;
13026
13027   info = inf;
13028   htab = ppc_hash_table (info);
13029   if (htab == NULL)
13030     return FALSE;
13031
13032   s = htab->glink;
13033   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
13034     if (pent->plt.offset != (bfd_vma) -1
13035         && pent->addend == 0)
13036       {
13037         bfd_byte *p;
13038         asection *plt;
13039         bfd_vma off;
13040
13041         p = s->contents + h->root.u.def.value;
13042         plt = htab->elf.splt;
13043         if (!htab->elf.dynamic_sections_created
13044             || h->dynindx == -1)
13045           plt = htab->elf.iplt;
13046         off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
13047         off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
13048
13049         if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
13050           {
13051             info->callbacks->einfo
13052               (_("%P: linkage table error against `%T'\n"),
13053                h->root.root.string);
13054             bfd_set_error (bfd_error_bad_value);
13055             htab->stub_error = TRUE;
13056           }
13057
13058         htab->stub_count[ppc_stub_global_entry - 1] += 1;
13059         if (htab->params->emit_stub_syms)
13060           {
13061             size_t len = strlen (h->root.root.string);
13062             char *name = bfd_malloc (sizeof "12345678.global_entry." + len);
13063
13064             if (name == NULL)
13065               return FALSE;
13066
13067             sprintf (name, "%08x.global_entry.%s", s->id, h->root.root.string);
13068             h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
13069             if (h == NULL)
13070               return FALSE;
13071             if (h->root.type == bfd_link_hash_new)
13072               {
13073                 h->root.type = bfd_link_hash_defined;
13074                 h->root.u.def.section = s;
13075                 h->root.u.def.value = p - s->contents;
13076                 h->ref_regular = 1;
13077                 h->def_regular = 1;
13078                 h->ref_regular_nonweak = 1;
13079                 h->forced_local = 1;
13080                 h->non_elf = 0;
13081                 h->root.linker_def = 1;
13082               }
13083           }
13084
13085         if (PPC_HA (off) != 0)
13086           {
13087             bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
13088             p += 4;
13089           }
13090         bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
13091         p += 4;
13092         bfd_put_32 (s->owner, MTCTR_R12, p);
13093         p += 4;
13094         bfd_put_32 (s->owner, BCTR, p);
13095         break;
13096       }
13097   return TRUE;
13098 }
13099
13100 /* Build all the stubs associated with the current output file.
13101    The stubs are kept in a hash table attached to the main linker
13102    hash table.  This function is called via gldelf64ppc_finish.  */
13103
13104 bfd_boolean
13105 ppc64_elf_build_stubs (struct bfd_link_info *info,
13106                        char **stats)
13107 {
13108   struct ppc_link_hash_table *htab = ppc_hash_table (info);
13109   struct map_stub *group;
13110   asection *stub_sec;
13111   bfd_byte *p;
13112   int stub_sec_count = 0;
13113
13114   if (htab == NULL)
13115     return FALSE;
13116
13117   /* Allocate memory to hold the linker stubs.  */
13118   for (stub_sec = htab->params->stub_bfd->sections;
13119        stub_sec != NULL;
13120        stub_sec = stub_sec->next)
13121     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
13122         && stub_sec->size != 0)
13123       {
13124         stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
13125         if (stub_sec->contents == NULL)
13126           return FALSE;
13127         stub_sec->size = 0;
13128       }
13129
13130   if (htab->glink != NULL && htab->glink->size != 0)
13131     {
13132       unsigned int indx;
13133       bfd_vma plt0;
13134
13135       /* Build the .glink plt call stub.  */
13136       if (htab->params->emit_stub_syms)
13137         {
13138           struct elf_link_hash_entry *h;
13139           h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
13140                                     TRUE, FALSE, FALSE);
13141           if (h == NULL)
13142             return FALSE;
13143           if (h->root.type == bfd_link_hash_new)
13144             {
13145               h->root.type = bfd_link_hash_defined;
13146               h->root.u.def.section = htab->glink;
13147               h->root.u.def.value = 8;
13148               h->ref_regular = 1;
13149               h->def_regular = 1;
13150               h->ref_regular_nonweak = 1;
13151               h->forced_local = 1;
13152               h->non_elf = 0;
13153               h->root.linker_def = 1;
13154             }
13155         }
13156       plt0 = (htab->elf.splt->output_section->vma
13157               + htab->elf.splt->output_offset
13158               - 16);
13159       if (info->emitrelocations)
13160         {
13161           Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
13162           if (r == NULL)
13163             return FALSE;
13164           r->r_offset = (htab->glink->output_offset
13165                          + htab->glink->output_section->vma);
13166           r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
13167           r->r_addend = plt0;
13168         }
13169       p = htab->glink->contents;
13170       plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
13171       bfd_put_64 (htab->glink->owner, plt0, p);
13172       p += 8;
13173       if (htab->opd_abi)
13174         {
13175           bfd_put_32 (htab->glink->owner, MFLR_R12, p);
13176           p += 4;
13177           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13178           p += 4;
13179           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13180           p += 4;
13181           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13182           p += 4;
13183           bfd_put_32 (htab->glink->owner, MTLR_R12, p);
13184           p += 4;
13185           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13186           p += 4;
13187           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13188           p += 4;
13189           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
13190           p += 4;
13191           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13192           p += 4;
13193           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
13194           p += 4;
13195         }
13196       else
13197         {
13198           bfd_put_32 (htab->glink->owner, MFLR_R0, p);
13199           p += 4;
13200           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13201           p += 4;
13202           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13203           p += 4;
13204           bfd_put_32 (htab->glink->owner, STD_R2_0R1 + 24, p);
13205           p += 4;
13206           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13207           p += 4;
13208           bfd_put_32 (htab->glink->owner, MTLR_R0, p);
13209           p += 4;
13210           bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
13211           p += 4;
13212           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13213           p += 4;
13214           bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
13215           p += 4;
13216           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13217           p += 4;
13218           bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
13219           p += 4;
13220           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13221           p += 4;
13222           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
13223           p += 4;
13224         }
13225       bfd_put_32 (htab->glink->owner, BCTR, p);
13226       p += 4;
13227       while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
13228         {
13229           bfd_put_32 (htab->glink->owner, NOP, p);
13230           p += 4;
13231         }
13232
13233       /* Build the .glink lazy link call stubs.  */
13234       indx = 0;
13235       while (p < htab->glink->contents + htab->glink->rawsize)
13236         {
13237           if (htab->opd_abi)
13238             {
13239               if (indx < 0x8000)
13240                 {
13241                   bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
13242                   p += 4;
13243                 }
13244               else
13245                 {
13246                   bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
13247                   p += 4;
13248                   bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
13249                               p);
13250                   p += 4;
13251                 }
13252             }
13253           bfd_put_32 (htab->glink->owner,
13254                       B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
13255           indx++;
13256           p += 4;
13257         }
13258
13259       /* Build .glink global entry stubs.  */
13260       if (htab->glink->size > htab->glink->rawsize)
13261         elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
13262     }
13263
13264   if (htab->brlt != NULL && htab->brlt->size != 0)
13265     {
13266       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
13267                                          htab->brlt->size);
13268       if (htab->brlt->contents == NULL)
13269         return FALSE;
13270     }
13271   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
13272     {
13273       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
13274                                             htab->relbrlt->size);
13275       if (htab->relbrlt->contents == NULL)
13276         return FALSE;
13277     }
13278
13279   /* Build the stubs as directed by the stub hash table.  */
13280   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
13281
13282   for (group = htab->group; group != NULL; group = group->next)
13283     if (group->needs_save_res)
13284       {
13285         stub_sec = group->stub_sec;
13286         memcpy (stub_sec->contents + stub_sec->size, htab->sfpr->contents,
13287                 htab->sfpr->size);
13288         if (htab->params->emit_stub_syms)
13289           {
13290             unsigned int i;
13291
13292             for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
13293               if (!sfpr_define (info, &save_res_funcs[i], stub_sec))
13294                 return FALSE;
13295           }
13296         stub_sec->size += htab->sfpr->size;
13297       }
13298
13299   if (htab->relbrlt != NULL)
13300     htab->relbrlt->reloc_count = 0;
13301
13302   if (htab->params->plt_stub_align != 0)
13303     for (stub_sec = htab->params->stub_bfd->sections;
13304          stub_sec != NULL;
13305          stub_sec = stub_sec->next)
13306       if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
13307         stub_sec->size = ((stub_sec->size
13308                            + (1 << htab->params->plt_stub_align) - 1)
13309                           & -(1 << htab->params->plt_stub_align));
13310
13311   for (stub_sec = htab->params->stub_bfd->sections;
13312        stub_sec != NULL;
13313        stub_sec = stub_sec->next)
13314     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
13315       {
13316         stub_sec_count += 1;
13317         if (stub_sec->rawsize != stub_sec->size
13318             && (htab->stub_iteration <= STUB_SHRINK_ITER
13319                 || stub_sec->rawsize < stub_sec->size))
13320           break;
13321       }
13322
13323   /* Note that the glink_eh_frame check here is not only testing that
13324      the generated size matched the calculated size but also that
13325      bfd_elf_discard_info didn't make any changes to the section.  */
13326   if (stub_sec != NULL
13327       || (htab->glink_eh_frame != NULL
13328           && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
13329     {
13330       htab->stub_error = TRUE;
13331       info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
13332     }
13333
13334   if (htab->stub_error)
13335     return FALSE;
13336
13337   if (stats != NULL)
13338     {
13339       *stats = bfd_malloc (500);
13340       if (*stats == NULL)
13341         return FALSE;
13342
13343       sprintf (*stats, _("linker stubs in %u group%s\n"
13344                          "  branch       %lu\n"
13345                          "  toc adjust   %lu\n"
13346                          "  long branch  %lu\n"
13347                          "  long toc adj %lu\n"
13348                          "  plt call     %lu\n"
13349                          "  plt call toc %lu\n"
13350                          "  global entry %lu"),
13351                stub_sec_count,
13352                stub_sec_count == 1 ? "" : "s",
13353                htab->stub_count[ppc_stub_long_branch - 1],
13354                htab->stub_count[ppc_stub_long_branch_r2off - 1],
13355                htab->stub_count[ppc_stub_plt_branch - 1],
13356                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
13357                htab->stub_count[ppc_stub_plt_call - 1],
13358                htab->stub_count[ppc_stub_plt_call_r2save - 1],
13359                htab->stub_count[ppc_stub_global_entry - 1]);
13360     }
13361   return TRUE;
13362 }
13363
13364 /* What to do when ld finds relocations against symbols defined in
13365    discarded sections.  */
13366
13367 static unsigned int
13368 ppc64_elf_action_discarded (asection *sec)
13369 {
13370   if (strcmp (".opd", sec->name) == 0)
13371     return 0;
13372
13373   if (strcmp (".toc", sec->name) == 0)
13374     return 0;
13375
13376   if (strcmp (".toc1", sec->name) == 0)
13377     return 0;
13378
13379   return _bfd_elf_default_action_discarded (sec);
13380 }
13381
13382 /* The RELOCATE_SECTION function is called by the ELF backend linker
13383    to handle the relocations for a section.
13384
13385    The relocs are always passed as Rela structures; if the section
13386    actually uses Rel structures, the r_addend field will always be
13387    zero.
13388
13389    This function is responsible for adjust the section contents as
13390    necessary, and (if using Rela relocs and generating a
13391    relocatable output file) adjusting the reloc addend as
13392    necessary.
13393
13394    This function does not have to worry about setting the reloc
13395    address or the reloc symbol index.
13396
13397    LOCAL_SYMS is a pointer to the swapped in local symbols.
13398
13399    LOCAL_SECTIONS is an array giving the section in the input file
13400    corresponding to the st_shndx field of each local symbol.
13401
13402    The global hash table entry for the global symbols can be found
13403    via elf_sym_hashes (input_bfd).
13404
13405    When generating relocatable output, this function must handle
13406    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
13407    going to be the section symbol corresponding to the output
13408    section, which means that the addend must be adjusted
13409    accordingly.  */
13410
13411 static bfd_boolean
13412 ppc64_elf_relocate_section (bfd *output_bfd,
13413                             struct bfd_link_info *info,
13414                             bfd *input_bfd,
13415                             asection *input_section,
13416                             bfd_byte *contents,
13417                             Elf_Internal_Rela *relocs,
13418                             Elf_Internal_Sym *local_syms,
13419                             asection **local_sections)
13420 {
13421   struct ppc_link_hash_table *htab;
13422   Elf_Internal_Shdr *symtab_hdr;
13423   struct elf_link_hash_entry **sym_hashes;
13424   Elf_Internal_Rela *rel;
13425   Elf_Internal_Rela *wrel;
13426   Elf_Internal_Rela *relend;
13427   Elf_Internal_Rela outrel;
13428   bfd_byte *loc;
13429   struct got_entry **local_got_ents;
13430   bfd_vma TOCstart;
13431   bfd_boolean ret = TRUE;
13432   bfd_boolean is_opd;
13433   /* Assume 'at' branch hints.  */
13434   bfd_boolean is_isa_v2 = TRUE;
13435   bfd_vma d_offset = (bfd_big_endian (input_bfd) ? 2 : 0);
13436
13437   /* Initialize howto table if needed.  */
13438   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
13439     ppc_howto_init ();
13440
13441   htab = ppc_hash_table (info);
13442   if (htab == NULL)
13443     return FALSE;
13444
13445   /* Don't relocate stub sections.  */
13446   if (input_section->owner == htab->params->stub_bfd)
13447     return TRUE;
13448
13449   BFD_ASSERT (is_ppc64_elf (input_bfd));
13450
13451   local_got_ents = elf_local_got_ents (input_bfd);
13452   TOCstart = elf_gp (output_bfd);
13453   symtab_hdr = &elf_symtab_hdr (input_bfd);
13454   sym_hashes = elf_sym_hashes (input_bfd);
13455   is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
13456
13457   rel = wrel = relocs;
13458   relend = relocs + input_section->reloc_count;
13459   for (; rel < relend; wrel++, rel++)
13460     {
13461       enum elf_ppc64_reloc_type r_type;
13462       bfd_vma addend;
13463       bfd_reloc_status_type r;
13464       Elf_Internal_Sym *sym;
13465       asection *sec;
13466       struct elf_link_hash_entry *h_elf;
13467       struct ppc_link_hash_entry *h;
13468       struct ppc_link_hash_entry *fdh;
13469       const char *sym_name;
13470       unsigned long r_symndx, toc_symndx;
13471       bfd_vma toc_addend;
13472       unsigned char tls_mask, tls_gd, tls_type;
13473       unsigned char sym_type;
13474       bfd_vma relocation;
13475       bfd_boolean unresolved_reloc;
13476       bfd_boolean warned;
13477       enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
13478       unsigned int insn;
13479       unsigned int mask;
13480       struct ppc_stub_hash_entry *stub_entry;
13481       bfd_vma max_br_offset;
13482       bfd_vma from;
13483       Elf_Internal_Rela orig_rel;
13484       reloc_howto_type *howto;
13485       struct reloc_howto_struct alt_howto;
13486
13487     again:
13488       orig_rel = *rel;
13489
13490       r_type = ELF64_R_TYPE (rel->r_info);
13491       r_symndx = ELF64_R_SYM (rel->r_info);
13492
13493       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
13494          symbol of the previous ADDR64 reloc.  The symbol gives us the
13495          proper TOC base to use.  */
13496       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
13497           && wrel != relocs
13498           && ELF64_R_TYPE (wrel[-1].r_info) == R_PPC64_ADDR64
13499           && is_opd)
13500         r_symndx = ELF64_R_SYM (wrel[-1].r_info);
13501
13502       sym = NULL;
13503       sec = NULL;
13504       h_elf = NULL;
13505       sym_name = NULL;
13506       unresolved_reloc = FALSE;
13507       warned = FALSE;
13508
13509       if (r_symndx < symtab_hdr->sh_info)
13510         {
13511           /* It's a local symbol.  */
13512           struct _opd_sec_data *opd;
13513
13514           sym = local_syms + r_symndx;
13515           sec = local_sections[r_symndx];
13516           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
13517           sym_type = ELF64_ST_TYPE (sym->st_info);
13518           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
13519           opd = get_opd_info (sec);
13520           if (opd != NULL && opd->adjust != NULL)
13521             {
13522               long adjust = opd->adjust[OPD_NDX (sym->st_value
13523                                                  + rel->r_addend)];
13524               if (adjust == -1)
13525                 relocation = 0;
13526               else
13527                 {
13528                   /* If this is a relocation against the opd section sym
13529                      and we have edited .opd, adjust the reloc addend so
13530                      that ld -r and ld --emit-relocs output is correct.
13531                      If it is a reloc against some other .opd symbol,
13532                      then the symbol value will be adjusted later.  */
13533                   if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
13534                     rel->r_addend += adjust;
13535                   else
13536                     relocation += adjust;
13537                 }
13538             }
13539         }
13540       else
13541         {
13542           bfd_boolean ignored;
13543
13544           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
13545                                    r_symndx, symtab_hdr, sym_hashes,
13546                                    h_elf, sec, relocation,
13547                                    unresolved_reloc, warned, ignored);
13548           sym_name = h_elf->root.root.string;
13549           sym_type = h_elf->type;
13550           if (sec != NULL
13551               && sec->owner == output_bfd
13552               && strcmp (sec->name, ".opd") == 0)
13553             {
13554               /* This is a symbol defined in a linker script.  All
13555                  such are defined in output sections, even those
13556                  defined by simple assignment from a symbol defined in
13557                  an input section.  Transfer the symbol to an
13558                  appropriate input .opd section, so that a branch to
13559                  this symbol will be mapped to the location specified
13560                  by the opd entry.  */
13561               struct bfd_link_order *lo;
13562               for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
13563                 if (lo->type == bfd_indirect_link_order)
13564                   {
13565                     asection *isec = lo->u.indirect.section;
13566                     if (h_elf->root.u.def.value >= isec->output_offset
13567                         && h_elf->root.u.def.value < (isec->output_offset
13568                                                       + isec->size))
13569                       {
13570                         h_elf->root.u.def.value -= isec->output_offset;
13571                         h_elf->root.u.def.section = isec;
13572                         sec = isec;
13573                         break;
13574                       }
13575                   }
13576             }
13577         }
13578       h = (struct ppc_link_hash_entry *) h_elf;
13579
13580       if (sec != NULL && discarded_section (sec))
13581         {
13582           _bfd_clear_contents (ppc64_elf_howto_table[r_type],
13583                                input_bfd, input_section,
13584                                contents + rel->r_offset);
13585           wrel->r_offset = rel->r_offset;
13586           wrel->r_info = 0;
13587           wrel->r_addend = 0;
13588
13589           /* For ld -r, remove relocations in debug sections against
13590              sections defined in discarded sections.  Not done for
13591              non-debug to preserve relocs in .eh_frame which the
13592              eh_frame editing code expects to be present.  */
13593           if (bfd_link_relocatable (info)
13594               && (input_section->flags & SEC_DEBUGGING))
13595             wrel--;
13596
13597           continue;
13598         }
13599
13600       if (bfd_link_relocatable (info))
13601         goto copy_reloc;
13602
13603       if (h != NULL && &h->elf == htab->elf.hgot)
13604         {
13605           relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
13606           sec = bfd_abs_section_ptr;
13607           unresolved_reloc = FALSE;
13608         }
13609
13610       /* TLS optimizations.  Replace instruction sequences and relocs
13611          based on information we collected in tls_optimize.  We edit
13612          RELOCS so that --emit-relocs will output something sensible
13613          for the final instruction stream.  */
13614       tls_mask = 0;
13615       tls_gd = 0;
13616       toc_symndx = 0;
13617       if (h != NULL)
13618         tls_mask = h->tls_mask;
13619       else if (local_got_ents != NULL)
13620         {
13621           struct plt_entry **local_plt = (struct plt_entry **)
13622             (local_got_ents + symtab_hdr->sh_info);
13623           unsigned char *lgot_masks = (unsigned char *)
13624             (local_plt + symtab_hdr->sh_info);
13625           tls_mask = lgot_masks[r_symndx];
13626         }
13627       if (tls_mask == 0
13628           && (r_type == R_PPC64_TLS
13629               || r_type == R_PPC64_TLSGD
13630               || r_type == R_PPC64_TLSLD))
13631         {
13632           /* Check for toc tls entries.  */
13633           unsigned char *toc_tls;
13634
13635           if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13636                              &local_syms, rel, input_bfd))
13637             return FALSE;
13638
13639           if (toc_tls)
13640             tls_mask = *toc_tls;
13641         }
13642
13643       /* Check that tls relocs are used with tls syms, and non-tls
13644          relocs are used with non-tls syms.  */
13645       if (r_symndx != STN_UNDEF
13646           && r_type != R_PPC64_NONE
13647           && (h == NULL
13648               || h->elf.root.type == bfd_link_hash_defined
13649               || h->elf.root.type == bfd_link_hash_defweak)
13650           && (IS_PPC64_TLS_RELOC (r_type)
13651               != (sym_type == STT_TLS
13652                   || (sym_type == STT_SECTION
13653                       && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13654         {
13655           if (tls_mask != 0
13656               && (r_type == R_PPC64_TLS
13657                   || r_type == R_PPC64_TLSGD
13658                   || r_type == R_PPC64_TLSLD))
13659             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
13660             ;
13661           else
13662             info->callbacks->einfo
13663               (!IS_PPC64_TLS_RELOC (r_type)
13664                /* xgettext:c-format */
13665                ? _("%H: %s used with TLS symbol `%T'\n")
13666                /* xgettext:c-format */
13667                : _("%H: %s used with non-TLS symbol `%T'\n"),
13668                input_bfd, input_section, rel->r_offset,
13669                ppc64_elf_howto_table[r_type]->name,
13670                sym_name);
13671         }
13672
13673       /* Ensure reloc mapping code below stays sane.  */
13674       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13675           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13676           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
13677           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13678           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13679           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13680           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
13681           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13682           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13683           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13684         abort ();
13685
13686       switch (r_type)
13687         {
13688         default:
13689           break;
13690
13691         case R_PPC64_LO_DS_OPT:
13692           insn = bfd_get_32 (input_bfd, contents + rel->r_offset - d_offset);
13693           if ((insn & (0x3f << 26)) != 58u << 26)
13694             abort ();
13695           insn += (14u << 26) - (58u << 26);
13696           bfd_put_32 (input_bfd, insn, contents + rel->r_offset - d_offset);
13697           r_type = R_PPC64_TOC16_LO;
13698           rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13699           break;
13700
13701         case R_PPC64_TOC16:
13702         case R_PPC64_TOC16_LO:
13703         case R_PPC64_TOC16_DS:
13704         case R_PPC64_TOC16_LO_DS:
13705           {
13706             /* Check for toc tls entries.  */
13707             unsigned char *toc_tls;
13708             int retval;
13709
13710             retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13711                                    &local_syms, rel, input_bfd);
13712             if (retval == 0)
13713               return FALSE;
13714
13715             if (toc_tls)
13716               {
13717                 tls_mask = *toc_tls;
13718                 if (r_type == R_PPC64_TOC16_DS
13719                     || r_type == R_PPC64_TOC16_LO_DS)
13720                   {
13721                     if (tls_mask != 0
13722                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13723                       goto toctprel;
13724                   }
13725                 else
13726                   {
13727                     /* If we found a GD reloc pair, then we might be
13728                        doing a GD->IE transition.  */
13729                     if (retval == 2)
13730                       {
13731                         tls_gd = TLS_TPRELGD;
13732                         if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13733                           goto tls_ldgd_opt;
13734                       }
13735                     else if (retval == 3)
13736                       {
13737                         if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13738                           goto tls_ldgd_opt;
13739                       }
13740                   }
13741               }
13742           }
13743           break;
13744
13745         case R_PPC64_GOT_TPREL16_HI:
13746         case R_PPC64_GOT_TPREL16_HA:
13747           if (tls_mask != 0
13748               && (tls_mask & TLS_TPREL) == 0)
13749             {
13750               rel->r_offset -= d_offset;
13751               bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
13752               r_type = R_PPC64_NONE;
13753               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13754             }
13755           break;
13756
13757         case R_PPC64_GOT_TPREL16_DS:
13758         case R_PPC64_GOT_TPREL16_LO_DS:
13759           if (tls_mask != 0
13760               && (tls_mask & TLS_TPREL) == 0)
13761             {
13762             toctprel:
13763               insn = bfd_get_32 (input_bfd,
13764                                  contents + rel->r_offset - d_offset);
13765               insn &= 31 << 21;
13766               insn |= 0x3c0d0000;       /* addis 0,13,0 */
13767               bfd_put_32 (input_bfd, insn,
13768                           contents + rel->r_offset - d_offset);
13769               r_type = R_PPC64_TPREL16_HA;
13770               if (toc_symndx != 0)
13771                 {
13772                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13773                   rel->r_addend = toc_addend;
13774                   /* We changed the symbol.  Start over in order to
13775                      get h, sym, sec etc. right.  */
13776                   goto again;
13777                 }
13778               else
13779                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13780             }
13781           break;
13782
13783         case R_PPC64_TLS:
13784           if (tls_mask != 0
13785               && (tls_mask & TLS_TPREL) == 0)
13786             {
13787               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
13788               insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13789               if (insn == 0)
13790                 abort ();
13791               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
13792               /* Was PPC64_TLS which sits on insn boundary, now
13793                  PPC64_TPREL16_LO which is at low-order half-word.  */
13794               rel->r_offset += d_offset;
13795               r_type = R_PPC64_TPREL16_LO;
13796               if (toc_symndx != 0)
13797                 {
13798                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13799                   rel->r_addend = toc_addend;
13800                   /* We changed the symbol.  Start over in order to
13801                      get h, sym, sec etc. right.  */
13802                   goto again;
13803                 }
13804               else
13805                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13806             }
13807           break;
13808
13809         case R_PPC64_GOT_TLSGD16_HI:
13810         case R_PPC64_GOT_TLSGD16_HA:
13811           tls_gd = TLS_TPRELGD;
13812           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13813             goto tls_gdld_hi;
13814           break;
13815
13816         case R_PPC64_GOT_TLSLD16_HI:
13817         case R_PPC64_GOT_TLSLD16_HA:
13818           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13819             {
13820             tls_gdld_hi:
13821               if ((tls_mask & tls_gd) != 0)
13822                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13823                           + R_PPC64_GOT_TPREL16_DS);
13824               else
13825                 {
13826                   rel->r_offset -= d_offset;
13827                   bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
13828                   r_type = R_PPC64_NONE;
13829                 }
13830               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13831             }
13832           break;
13833
13834         case R_PPC64_GOT_TLSGD16:
13835         case R_PPC64_GOT_TLSGD16_LO:
13836           tls_gd = TLS_TPRELGD;
13837           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13838             goto tls_ldgd_opt;
13839           break;
13840
13841         case R_PPC64_GOT_TLSLD16:
13842         case R_PPC64_GOT_TLSLD16_LO:
13843           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13844             {
13845               unsigned int insn1, insn2, insn3;
13846               bfd_vma offset;
13847
13848             tls_ldgd_opt:
13849               offset = (bfd_vma) -1;
13850               /* If not using the newer R_PPC64_TLSGD/LD to mark
13851                  __tls_get_addr calls, we must trust that the call
13852                  stays with its arg setup insns, ie. that the next
13853                  reloc is the __tls_get_addr call associated with
13854                  the current reloc.  Edit both insns.  */
13855               if (input_section->has_tls_get_addr_call
13856                   && rel + 1 < relend
13857                   && branch_reloc_hash_match (input_bfd, rel + 1,
13858                                               htab->tls_get_addr,
13859                                               htab->tls_get_addr_fd))
13860                 offset = rel[1].r_offset;
13861               /* We read the low GOT_TLS (or TOC16) insn because we
13862                  need to keep the destination reg.  It may be
13863                  something other than the usual r3, and moved to r3
13864                  before the call by intervening code.  */
13865               insn1 = bfd_get_32 (input_bfd,
13866                                   contents + rel->r_offset - d_offset);
13867               if ((tls_mask & tls_gd) != 0)
13868                 {
13869                   /* IE */
13870                   insn1 &= (0x1f << 21) | (0x1f << 16);
13871                   insn1 |= 58 << 26;    /* ld */
13872                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13873                   if (offset != (bfd_vma) -1)
13874                     rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13875                   if ((tls_mask & TLS_EXPLICIT) == 0)
13876                     r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13877                               + R_PPC64_GOT_TPREL16_DS);
13878                   else
13879                     r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13880                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13881                 }
13882               else
13883                 {
13884                   /* LE */
13885                   insn1 &= 0x1f << 21;
13886                   insn1 |= 0x3c0d0000;  /* addis r,13,0 */
13887                   insn2 = 0x38630000;   /* addi 3,3,0 */
13888                   if (tls_gd == 0)
13889                     {
13890                       /* Was an LD reloc.  */
13891                       if (toc_symndx)
13892                         sec = local_sections[toc_symndx];
13893                       for (r_symndx = 0;
13894                            r_symndx < symtab_hdr->sh_info;
13895                            r_symndx++)
13896                         if (local_sections[r_symndx] == sec)
13897                           break;
13898                       if (r_symndx >= symtab_hdr->sh_info)
13899                         r_symndx = STN_UNDEF;
13900                       rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13901                       if (r_symndx != STN_UNDEF)
13902                         rel->r_addend -= (local_syms[r_symndx].st_value
13903                                           + sec->output_offset
13904                                           + sec->output_section->vma);
13905                     }
13906                   else if (toc_symndx != 0)
13907                     {
13908                       r_symndx = toc_symndx;
13909                       rel->r_addend = toc_addend;
13910                     }
13911                   r_type = R_PPC64_TPREL16_HA;
13912                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13913                   if (offset != (bfd_vma) -1)
13914                     {
13915                       rel[1].r_info = ELF64_R_INFO (r_symndx,
13916                                                     R_PPC64_TPREL16_LO);
13917                       rel[1].r_offset = offset + d_offset;
13918                       rel[1].r_addend = rel->r_addend;
13919                     }
13920                 }
13921               bfd_put_32 (input_bfd, insn1,
13922                           contents + rel->r_offset - d_offset);
13923               if (offset != (bfd_vma) -1)
13924                 {
13925                   insn3 = bfd_get_32 (input_bfd,
13926                                       contents + offset + 4);
13927                   if (insn3 == NOP
13928                       || insn3 == CROR_151515 || insn3 == CROR_313131)
13929                     {
13930                       rel[1].r_offset += 4;
13931                       bfd_put_32 (input_bfd, insn2, contents + offset + 4);
13932                       insn2 = NOP;
13933                     }
13934                   bfd_put_32 (input_bfd, insn2, contents + offset);
13935                 }
13936               if ((tls_mask & tls_gd) == 0
13937                   && (tls_gd == 0 || toc_symndx != 0))
13938                 {
13939                   /* We changed the symbol.  Start over in order
13940                      to get h, sym, sec etc. right.  */
13941                   goto again;
13942                 }
13943             }
13944           break;
13945
13946         case R_PPC64_TLSGD:
13947           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13948             {
13949               unsigned int insn2, insn3;
13950               bfd_vma offset = rel->r_offset;
13951
13952               if ((tls_mask & TLS_TPRELGD) != 0)
13953                 {
13954                   /* IE */
13955                   r_type = R_PPC64_NONE;
13956                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13957                 }
13958               else
13959                 {
13960                   /* LE */
13961                   if (toc_symndx != 0)
13962                     {
13963                       r_symndx = toc_symndx;
13964                       rel->r_addend = toc_addend;
13965                     }
13966                   r_type = R_PPC64_TPREL16_LO;
13967                   rel->r_offset = offset + d_offset;
13968                   insn2 = 0x38630000;   /* addi 3,3,0 */
13969                 }
13970               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13971               /* Zap the reloc on the _tls_get_addr call too.  */
13972               BFD_ASSERT (offset == rel[1].r_offset);
13973               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13974               insn3 = bfd_get_32 (input_bfd,
13975                                   contents + offset + 4);
13976               if (insn3 == NOP
13977                   || insn3 == CROR_151515 || insn3 == CROR_313131)
13978                 {
13979                   rel->r_offset += 4;
13980                   bfd_put_32 (input_bfd, insn2, contents + offset + 4);
13981                   insn2 = NOP;
13982                 }
13983               bfd_put_32 (input_bfd, insn2, contents + offset);
13984               if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
13985                 goto again;
13986             }
13987           break;
13988
13989         case R_PPC64_TLSLD:
13990           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13991             {
13992               unsigned int insn2, insn3;
13993               bfd_vma offset = rel->r_offset;
13994
13995               if (toc_symndx)
13996                 sec = local_sections[toc_symndx];
13997               for (r_symndx = 0;
13998                    r_symndx < symtab_hdr->sh_info;
13999                    r_symndx++)
14000                 if (local_sections[r_symndx] == sec)
14001                   break;
14002               if (r_symndx >= symtab_hdr->sh_info)
14003                 r_symndx = STN_UNDEF;
14004               rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
14005               if (r_symndx != STN_UNDEF)
14006                 rel->r_addend -= (local_syms[r_symndx].st_value
14007                                   + sec->output_offset
14008                                   + sec->output_section->vma);
14009
14010               r_type = R_PPC64_TPREL16_LO;
14011               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14012               rel->r_offset = offset + d_offset;
14013               /* Zap the reloc on the _tls_get_addr call too.  */
14014               BFD_ASSERT (offset == rel[1].r_offset);
14015               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14016               insn2 = 0x38630000;       /* addi 3,3,0 */
14017               insn3 = bfd_get_32 (input_bfd,
14018                                   contents + offset + 4);
14019               if (insn3 == NOP
14020                   || insn3 == CROR_151515 || insn3 == CROR_313131)
14021                 {
14022                   rel->r_offset += 4;
14023                   bfd_put_32 (input_bfd, insn2, contents + offset + 4);
14024                   insn2 = NOP;
14025                 }
14026               bfd_put_32 (input_bfd, insn2, contents + offset);
14027               goto again;
14028             }
14029           break;
14030
14031         case R_PPC64_DTPMOD64:
14032           if (rel + 1 < relend
14033               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
14034               && rel[1].r_offset == rel->r_offset + 8)
14035             {
14036               if ((tls_mask & TLS_GD) == 0)
14037                 {
14038                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
14039                   if ((tls_mask & TLS_TPRELGD) != 0)
14040                     r_type = R_PPC64_TPREL64;
14041                   else
14042                     {
14043                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
14044                       r_type = R_PPC64_NONE;
14045                     }
14046                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14047                 }
14048             }
14049           else
14050             {
14051               if ((tls_mask & TLS_LD) == 0)
14052                 {
14053                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
14054                   r_type = R_PPC64_NONE;
14055                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14056                 }
14057             }
14058           break;
14059
14060         case R_PPC64_TPREL64:
14061           if ((tls_mask & TLS_TPREL) == 0)
14062             {
14063               r_type = R_PPC64_NONE;
14064               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14065             }
14066           break;
14067
14068         case R_PPC64_ENTRY:
14069           relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
14070           if (!bfd_link_pic (info)
14071               && !info->traditional_format
14072               && relocation + 0x80008000 <= 0xffffffff)
14073             {
14074               unsigned int insn1, insn2;
14075
14076               insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
14077               insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
14078               if ((insn1 & ~0xfffc) == LD_R2_0R12
14079                   && insn2 == ADD_R2_R2_R12)
14080                 {
14081                   bfd_put_32 (input_bfd,
14082                               LIS_R2 + PPC_HA (relocation),
14083                               contents + rel->r_offset);
14084                   bfd_put_32 (input_bfd,
14085                               ADDI_R2_R2 + PPC_LO (relocation),
14086                               contents + rel->r_offset + 4);
14087                 }
14088             }
14089           else
14090             {
14091               relocation -= (rel->r_offset
14092                              + input_section->output_offset
14093                              + input_section->output_section->vma);
14094               if (relocation + 0x80008000 <= 0xffffffff)
14095                 {
14096                   unsigned int insn1, insn2;
14097
14098                   insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
14099                   insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
14100                   if ((insn1 & ~0xfffc) == LD_R2_0R12
14101                       && insn2 == ADD_R2_R2_R12)
14102                     {
14103                       bfd_put_32 (input_bfd,
14104                                   ADDIS_R2_R12 + PPC_HA (relocation),
14105                                   contents + rel->r_offset);
14106                       bfd_put_32 (input_bfd,
14107                                   ADDI_R2_R2 + PPC_LO (relocation),
14108                                   contents + rel->r_offset + 4);
14109                     }
14110                 }
14111             }
14112           break;
14113
14114         case R_PPC64_REL16_HA:
14115           /* If we are generating a non-PIC executable, edit
14116              .  0:      addis 2,12,.TOC.-0b@ha
14117              .          addi 2,2,.TOC.-0b@l
14118              used by ELFv2 global entry points to set up r2, to
14119              .          lis 2,.TOC.@ha
14120              .          addi 2,2,.TOC.@l
14121              if .TOC. is in range.  */
14122           if (!bfd_link_pic (info)
14123               && !info->traditional_format
14124               && !htab->opd_abi
14125               && rel->r_addend == d_offset
14126               && h != NULL && &h->elf == htab->elf.hgot
14127               && rel + 1 < relend
14128               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
14129               && rel[1].r_offset == rel->r_offset + 4
14130               && rel[1].r_addend == rel->r_addend + 4
14131               && relocation + 0x80008000 <= 0xffffffff)
14132             {
14133               unsigned int insn1, insn2;
14134               bfd_vma offset = rel->r_offset - d_offset;
14135               insn1 = bfd_get_32 (input_bfd, contents + offset);
14136               insn2 = bfd_get_32 (input_bfd, contents + offset + 4);
14137               if ((insn1 & 0xffff0000) == ADDIS_R2_R12
14138                   && (insn2 & 0xffff0000) == ADDI_R2_R2)
14139                 {
14140                   r_type = R_PPC64_ADDR16_HA;
14141                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14142                   rel->r_addend -= d_offset;
14143                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
14144                   rel[1].r_addend -= d_offset + 4;
14145                   bfd_put_32 (input_bfd, LIS_R2, contents + offset);
14146                 }
14147             }
14148           break;
14149         }
14150
14151       /* Handle other relocations that tweak non-addend part of insn.  */
14152       insn = 0;
14153       max_br_offset = 1 << 25;
14154       addend = rel->r_addend;
14155       reloc_dest = DEST_NORMAL;
14156       switch (r_type)
14157         {
14158         default:
14159           break;
14160
14161         case R_PPC64_TOCSAVE:
14162           if (relocation + addend == (rel->r_offset
14163                                       + input_section->output_offset
14164                                       + input_section->output_section->vma)
14165               && tocsave_find (htab, NO_INSERT,
14166                                &local_syms, rel, input_bfd))
14167             {
14168               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
14169               if (insn == NOP
14170                   || insn == CROR_151515 || insn == CROR_313131)
14171                 bfd_put_32 (input_bfd,
14172                             STD_R2_0R1 + STK_TOC (htab),
14173                             contents + rel->r_offset);
14174             }
14175           break;
14176
14177           /* Branch taken prediction relocations.  */
14178         case R_PPC64_ADDR14_BRTAKEN:
14179         case R_PPC64_REL14_BRTAKEN:
14180           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
14181           /* Fall through.  */
14182
14183           /* Branch not taken prediction relocations.  */
14184         case R_PPC64_ADDR14_BRNTAKEN:
14185         case R_PPC64_REL14_BRNTAKEN:
14186           insn |= bfd_get_32 (input_bfd,
14187                               contents + rel->r_offset) & ~(0x01 << 21);
14188           /* Fall through.  */
14189
14190         case R_PPC64_REL14:
14191           max_br_offset = 1 << 15;
14192           /* Fall through.  */
14193
14194         case R_PPC64_REL24:
14195           /* Calls to functions with a different TOC, such as calls to
14196              shared objects, need to alter the TOC pointer.  This is
14197              done using a linkage stub.  A REL24 branching to these
14198              linkage stubs needs to be followed by a nop, as the nop
14199              will be replaced with an instruction to restore the TOC
14200              base pointer.  */
14201           fdh = h;
14202           if (h != NULL
14203               && h->oh != NULL
14204               && h->oh->is_func_descriptor)
14205             fdh = ppc_follow_link (h->oh);
14206           stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
14207                                            htab);
14208           if (stub_entry != NULL
14209               && (stub_entry->stub_type == ppc_stub_plt_call
14210                   || stub_entry->stub_type == ppc_stub_plt_call_r2save
14211                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
14212                   || stub_entry->stub_type == ppc_stub_long_branch_r2off))
14213             {
14214               bfd_boolean can_plt_call = FALSE;
14215
14216               if (stub_entry->stub_type == ppc_stub_plt_call
14217                   && !htab->opd_abi
14218                   && htab->params->plt_localentry0 != 0
14219                   && is_elfv2_localentry0 (&h->elf))
14220                 {
14221                   /* The function doesn't use or change r2.  */
14222                   can_plt_call = TRUE;
14223                 }
14224
14225               /* All of these stubs may modify r2, so there must be a
14226                  branch and link followed by a nop.  The nop is
14227                  replaced by an insn to restore r2.  */
14228               else if (rel->r_offset + 8 <= input_section->size)
14229                 {
14230                   unsigned long br;
14231
14232                   br = bfd_get_32 (input_bfd,
14233                                    contents + rel->r_offset);
14234                   if ((br & 1) != 0)
14235                     {
14236                       unsigned long nop;
14237
14238                       nop = bfd_get_32 (input_bfd,
14239                                         contents + rel->r_offset + 4);
14240                       if (nop == NOP
14241                           || nop == CROR_151515 || nop == CROR_313131)
14242                         {
14243                           if (h != NULL
14244                               && (h == htab->tls_get_addr_fd
14245                                   || h == htab->tls_get_addr)
14246                               && htab->params->tls_get_addr_opt)
14247                             {
14248                               /* Special stub used, leave nop alone.  */
14249                             }
14250                           else
14251                             bfd_put_32 (input_bfd,
14252                                         LD_R2_0R1 + STK_TOC (htab),
14253                                         contents + rel->r_offset + 4);
14254                           can_plt_call = TRUE;
14255                         }
14256                     }
14257                 }
14258
14259               if (!can_plt_call && h != NULL)
14260                 {
14261                   const char *name = h->elf.root.root.string;
14262
14263                   if (*name == '.')
14264                     ++name;
14265
14266                   if (strncmp (name, "__libc_start_main", 17) == 0
14267                       && (name[17] == 0 || name[17] == '@'))
14268                     {
14269                       /* Allow crt1 branch to go via a toc adjusting
14270                          stub.  Other calls that never return could do
14271                          the same, if we could detect such.  */
14272                       can_plt_call = TRUE;
14273                     }
14274                 }
14275
14276               if (!can_plt_call)
14277                 {
14278                   /* g++ as of 20130507 emits self-calls without a
14279                      following nop.  This is arguably wrong since we
14280                      have conflicting information.  On the one hand a
14281                      global symbol and on the other a local call
14282                      sequence, but don't error for this special case.
14283                      It isn't possible to cheaply verify we have
14284                      exactly such a call.  Allow all calls to the same
14285                      section.  */
14286                   asection *code_sec = sec;
14287
14288                   if (get_opd_info (sec) != NULL)
14289                     {
14290                       bfd_vma off = (relocation + addend
14291                                      - sec->output_section->vma
14292                                      - sec->output_offset);
14293
14294                       opd_entry_value (sec, off, &code_sec, NULL, FALSE);
14295                     }
14296                   if (code_sec == input_section)
14297                     can_plt_call = TRUE;
14298                 }
14299
14300               if (!can_plt_call)
14301                 {
14302                   if (stub_entry->stub_type == ppc_stub_plt_call
14303                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14304                     info->callbacks->einfo
14305                       /* xgettext:c-format */
14306                       (_("%H: call to `%T' lacks nop, can't restore toc; "
14307                          "recompile with -fPIC\n"),
14308                        input_bfd, input_section, rel->r_offset, sym_name);
14309                   else
14310                     info->callbacks->einfo
14311                       /* xgettext:c-format */
14312                       (_("%H: call to `%T' lacks nop, can't restore toc; "
14313                          "(-mcmodel=small toc adjust stub)\n"),
14314                        input_bfd, input_section, rel->r_offset, sym_name);
14315
14316                   bfd_set_error (bfd_error_bad_value);
14317                   ret = FALSE;
14318                 }
14319
14320               if (can_plt_call
14321                   && (stub_entry->stub_type == ppc_stub_plt_call
14322                       || stub_entry->stub_type == ppc_stub_plt_call_r2save))
14323                 unresolved_reloc = FALSE;
14324             }
14325
14326           if ((stub_entry == NULL
14327                || stub_entry->stub_type == ppc_stub_long_branch
14328                || stub_entry->stub_type == ppc_stub_plt_branch)
14329               && get_opd_info (sec) != NULL)
14330             {
14331               /* The branch destination is the value of the opd entry. */
14332               bfd_vma off = (relocation + addend
14333                              - sec->output_section->vma
14334                              - sec->output_offset);
14335               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
14336               if (dest != (bfd_vma) -1)
14337                 {
14338                   relocation = dest;
14339                   addend = 0;
14340                   reloc_dest = DEST_OPD;
14341                 }
14342             }
14343
14344           /* If the branch is out of reach we ought to have a long
14345              branch stub.  */
14346           from = (rel->r_offset
14347                   + input_section->output_offset
14348                   + input_section->output_section->vma);
14349
14350           relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
14351                                                   ? fdh->elf.other
14352                                                   : sym->st_other);
14353
14354           if (stub_entry != NULL
14355               && (stub_entry->stub_type == ppc_stub_long_branch
14356                   || stub_entry->stub_type == ppc_stub_plt_branch)
14357               && (r_type == R_PPC64_ADDR14_BRTAKEN
14358                   || r_type == R_PPC64_ADDR14_BRNTAKEN
14359                   || (relocation + addend - from + max_br_offset
14360                       < 2 * max_br_offset)))
14361             /* Don't use the stub if this branch is in range.  */
14362             stub_entry = NULL;
14363
14364           if (stub_entry != NULL)
14365             {
14366               /* Munge up the value and addend so that we call the stub
14367                  rather than the procedure directly.  */
14368               asection *stub_sec = stub_entry->group->stub_sec;
14369
14370               if (stub_entry->stub_type == ppc_stub_save_res)
14371                 relocation += (stub_sec->output_offset
14372                                + stub_sec->output_section->vma
14373                                + stub_sec->size - htab->sfpr->size
14374                                - htab->sfpr->output_offset
14375                                - htab->sfpr->output_section->vma);
14376               else
14377                 relocation = (stub_entry->stub_offset
14378                               + stub_sec->output_offset
14379                               + stub_sec->output_section->vma);
14380               addend = 0;
14381               reloc_dest = DEST_STUB;
14382
14383               if ((stub_entry->stub_type == ppc_stub_plt_call
14384                    || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14385                   && (ALWAYS_EMIT_R2SAVE
14386                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14387                   && rel + 1 < relend
14388                   && rel[1].r_offset == rel->r_offset + 4
14389                   && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
14390                 relocation += 4;
14391             }
14392
14393           if (insn != 0)
14394             {
14395               if (is_isa_v2)
14396                 {
14397                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
14398                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
14399                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
14400                   if ((insn & (0x14 << 21)) == (0x04 << 21))
14401                     insn |= 0x02 << 21;
14402                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
14403                     insn |= 0x08 << 21;
14404                   else
14405                     break;
14406                 }
14407               else
14408                 {
14409                   /* Invert 'y' bit if not the default.  */
14410                   if ((bfd_signed_vma) (relocation + addend - from) < 0)
14411                     insn ^= 0x01 << 21;
14412                 }
14413
14414               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
14415             }
14416
14417           /* NOP out calls to undefined weak functions.
14418              We can thus call a weak function without first
14419              checking whether the function is defined.  */
14420           else if (h != NULL
14421                    && h->elf.root.type == bfd_link_hash_undefweak
14422                    && h->elf.dynindx == -1
14423                    && r_type == R_PPC64_REL24
14424                    && relocation == 0
14425                    && addend == 0)
14426             {
14427               bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
14428               goto copy_reloc;
14429             }
14430           break;
14431         }
14432
14433       /* Set `addend'.  */
14434       tls_type = 0;
14435       switch (r_type)
14436         {
14437         default:
14438           info->callbacks->einfo
14439             /* xgettext:c-format */
14440             (_("%P: %B: unknown relocation type %d for `%T'\n"),
14441              input_bfd, (int) r_type, sym_name);
14442
14443           bfd_set_error (bfd_error_bad_value);
14444           ret = FALSE;
14445           goto copy_reloc;
14446
14447         case R_PPC64_NONE:
14448         case R_PPC64_TLS:
14449         case R_PPC64_TLSGD:
14450         case R_PPC64_TLSLD:
14451         case R_PPC64_TOCSAVE:
14452         case R_PPC64_GNU_VTINHERIT:
14453         case R_PPC64_GNU_VTENTRY:
14454         case R_PPC64_ENTRY:
14455           goto copy_reloc;
14456
14457           /* GOT16 relocations.  Like an ADDR16 using the symbol's
14458              address in the GOT as relocation value instead of the
14459              symbol's value itself.  Also, create a GOT entry for the
14460              symbol and put the symbol value there.  */
14461         case R_PPC64_GOT_TLSGD16:
14462         case R_PPC64_GOT_TLSGD16_LO:
14463         case R_PPC64_GOT_TLSGD16_HI:
14464         case R_PPC64_GOT_TLSGD16_HA:
14465           tls_type = TLS_TLS | TLS_GD;
14466           goto dogot;
14467
14468         case R_PPC64_GOT_TLSLD16:
14469         case R_PPC64_GOT_TLSLD16_LO:
14470         case R_PPC64_GOT_TLSLD16_HI:
14471         case R_PPC64_GOT_TLSLD16_HA:
14472           tls_type = TLS_TLS | TLS_LD;
14473           goto dogot;
14474
14475         case R_PPC64_GOT_TPREL16_DS:
14476         case R_PPC64_GOT_TPREL16_LO_DS:
14477         case R_PPC64_GOT_TPREL16_HI:
14478         case R_PPC64_GOT_TPREL16_HA:
14479           tls_type = TLS_TLS | TLS_TPREL;
14480           goto dogot;
14481
14482         case R_PPC64_GOT_DTPREL16_DS:
14483         case R_PPC64_GOT_DTPREL16_LO_DS:
14484         case R_PPC64_GOT_DTPREL16_HI:
14485         case R_PPC64_GOT_DTPREL16_HA:
14486           tls_type = TLS_TLS | TLS_DTPREL;
14487           goto dogot;
14488
14489         case R_PPC64_GOT16:
14490         case R_PPC64_GOT16_LO:
14491         case R_PPC64_GOT16_HI:
14492         case R_PPC64_GOT16_HA:
14493         case R_PPC64_GOT16_DS:
14494         case R_PPC64_GOT16_LO_DS:
14495         dogot:
14496           {
14497             /* Relocation is to the entry for this symbol in the global
14498                offset table.  */
14499             asection *got;
14500             bfd_vma *offp;
14501             bfd_vma off;
14502             unsigned long indx = 0;
14503             struct got_entry *ent;
14504
14505             if (tls_type == (TLS_TLS | TLS_LD)
14506                 && (h == NULL
14507                     || !h->elf.def_dynamic))
14508               ent = ppc64_tlsld_got (input_bfd);
14509             else
14510               {
14511                 if (h != NULL)
14512                   {
14513                     if (!htab->elf.dynamic_sections_created
14514                         || h->elf.dynindx == -1
14515                         || SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14516                         || UNDEFWEAK_NO_DYNAMIC_RELOC (info, &h->elf))
14517                       /* This is actually a static link, or it is a
14518                          -Bsymbolic link and the symbol is defined
14519                          locally, or the symbol was forced to be local
14520                          because of a version file.  */
14521                       ;
14522                     else
14523                       {
14524                         indx = h->elf.dynindx;
14525                         unresolved_reloc = FALSE;
14526                       }
14527                     ent = h->elf.got.glist;
14528                   }
14529                 else
14530                   {
14531                     if (local_got_ents == NULL)
14532                       abort ();
14533                     ent = local_got_ents[r_symndx];
14534                   }
14535
14536                 for (; ent != NULL; ent = ent->next)
14537                   if (ent->addend == orig_rel.r_addend
14538                       && ent->owner == input_bfd
14539                       && ent->tls_type == tls_type)
14540                     break;
14541               }
14542
14543             if (ent == NULL)
14544               abort ();
14545             if (ent->is_indirect)
14546               ent = ent->got.ent;
14547             offp = &ent->got.offset;
14548             got = ppc64_elf_tdata (ent->owner)->got;
14549             if (got == NULL)
14550               abort ();
14551
14552             /* The offset must always be a multiple of 8.  We use the
14553                least significant bit to record whether we have already
14554                processed this entry.  */
14555             off = *offp;
14556             if ((off & 1) != 0)
14557               off &= ~1;
14558             else
14559               {
14560                 /* Generate relocs for the dynamic linker, except in
14561                    the case of TLSLD where we'll use one entry per
14562                    module.  */
14563                 asection *relgot;
14564                 bfd_boolean ifunc;
14565
14566                 *offp = off | 1;
14567                 relgot = NULL;
14568                 ifunc = (h != NULL
14569                          ? h->elf.type == STT_GNU_IFUNC
14570                          : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
14571                 if (ifunc)
14572                   {
14573                     relgot = htab->elf.irelplt;
14574                     if (indx == 0)
14575                       htab->local_ifunc_resolver = 1;
14576                     else if (is_static_defined (&h->elf))
14577                       htab->maybe_local_ifunc_resolver = 1;
14578                   }
14579                 else if (indx != 0
14580                          || (bfd_link_pic (info)
14581                              && (h == NULL
14582                                  || !UNDEFWEAK_NO_DYNAMIC_RELOC (info, &h->elf)
14583                                  || (tls_type == (TLS_TLS | TLS_LD)
14584                                      && !h->elf.def_dynamic))))
14585                   relgot = ppc64_elf_tdata (ent->owner)->relgot;
14586                 if (relgot != NULL)
14587                   {
14588                     outrel.r_offset = (got->output_section->vma
14589                                        + got->output_offset
14590                                        + off);
14591                     outrel.r_addend = addend;
14592                     if (tls_type & (TLS_LD | TLS_GD))
14593                       {
14594                         outrel.r_addend = 0;
14595                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
14596                         if (tls_type == (TLS_TLS | TLS_GD))
14597                           {
14598                             loc = relgot->contents;
14599                             loc += (relgot->reloc_count++
14600                                     * sizeof (Elf64_External_Rela));
14601                             bfd_elf64_swap_reloca_out (output_bfd,
14602                                                        &outrel, loc);
14603                             outrel.r_offset += 8;
14604                             outrel.r_addend = addend;
14605                             outrel.r_info
14606                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14607                           }
14608                       }
14609                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
14610                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14611                     else if (tls_type == (TLS_TLS | TLS_TPREL))
14612                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
14613                     else if (indx != 0)
14614                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
14615                     else
14616                       {
14617                         if (ifunc)
14618                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14619                         else
14620                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14621
14622                         /* Write the .got section contents for the sake
14623                            of prelink.  */
14624                         loc = got->contents + off;
14625                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
14626                                     loc);
14627                       }
14628
14629                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
14630                       {
14631                         outrel.r_addend += relocation;
14632                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
14633                           {
14634                             if (htab->elf.tls_sec == NULL)
14635                               outrel.r_addend = 0;
14636                             else
14637                               outrel.r_addend -= htab->elf.tls_sec->vma;
14638                           }
14639                       }
14640                     loc = relgot->contents;
14641                     loc += (relgot->reloc_count++
14642                             * sizeof (Elf64_External_Rela));
14643                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14644                   }
14645
14646                 /* Init the .got section contents here if we're not
14647                    emitting a reloc.  */
14648                 else
14649                   {
14650                     relocation += addend;
14651                     if (tls_type != 0)
14652                       {
14653                         if (htab->elf.tls_sec == NULL)
14654                           relocation = 0;
14655                         else
14656                           {
14657                             if (tls_type & TLS_LD)
14658                               relocation = 0;
14659                             else
14660                               relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
14661                             if (tls_type & TLS_TPREL)
14662                               relocation += DTP_OFFSET - TP_OFFSET;
14663                           }
14664
14665                         if (tls_type & (TLS_GD | TLS_LD))
14666                           {
14667                             bfd_put_64 (output_bfd, relocation,
14668                                         got->contents + off + 8);
14669                             relocation = 1;
14670                           }
14671                       }
14672                     bfd_put_64 (output_bfd, relocation,
14673                                 got->contents + off);
14674                   }
14675               }
14676
14677             if (off >= (bfd_vma) -2)
14678               abort ();
14679
14680             relocation = got->output_section->vma + got->output_offset + off;
14681             addend = -(TOCstart + htab->sec_info[input_section->id].toc_off);
14682           }
14683           break;
14684
14685         case R_PPC64_PLT16_HA:
14686         case R_PPC64_PLT16_HI:
14687         case R_PPC64_PLT16_LO:
14688         case R_PPC64_PLT32:
14689         case R_PPC64_PLT64:
14690           /* Relocation is to the entry for this symbol in the
14691              procedure linkage table.  */
14692           {
14693             struct plt_entry **plt_list = NULL;
14694             if (h != NULL)
14695               plt_list = &h->elf.plt.plist;
14696             else if (local_got_ents != NULL)
14697               {
14698                 struct plt_entry **local_plt = (struct plt_entry **)
14699                   (local_got_ents + symtab_hdr->sh_info);
14700                 unsigned char *local_got_tls_masks = (unsigned char *)
14701                   (local_plt + symtab_hdr->sh_info);
14702                 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
14703                   plt_list = local_plt + r_symndx;
14704               }
14705             if (plt_list)
14706               {
14707                 struct plt_entry *ent;
14708
14709                 for (ent = *plt_list; ent != NULL; ent = ent->next)
14710                   if (ent->plt.offset != (bfd_vma) -1
14711                       && ent->addend == orig_rel.r_addend)
14712                     {
14713                       asection *plt;
14714
14715                       plt = htab->elf.splt;
14716                       if (!htab->elf.dynamic_sections_created
14717                           || h == NULL
14718                           || h->elf.dynindx == -1)
14719                         plt = htab->elf.iplt;
14720                       relocation = (plt->output_section->vma
14721                                     + plt->output_offset
14722                                     + ent->plt.offset);
14723                       addend = 0;
14724                       unresolved_reloc = FALSE;
14725                       break;
14726                     }
14727               }
14728           }
14729           break;
14730
14731         case R_PPC64_TOC:
14732           /* Relocation value is TOC base.  */
14733           relocation = TOCstart;
14734           if (r_symndx == STN_UNDEF)
14735             relocation += htab->sec_info[input_section->id].toc_off;
14736           else if (unresolved_reloc)
14737             ;
14738           else if (sec != NULL && sec->id < htab->sec_info_arr_size)
14739             relocation += htab->sec_info[sec->id].toc_off;
14740           else
14741             unresolved_reloc = TRUE;
14742           goto dodyn;
14743
14744           /* TOC16 relocs.  We want the offset relative to the TOC base,
14745              which is the address of the start of the TOC plus 0x8000.
14746              The TOC consists of sections .got, .toc, .tocbss, and .plt,
14747              in this order.  */
14748         case R_PPC64_TOC16:
14749         case R_PPC64_TOC16_LO:
14750         case R_PPC64_TOC16_HI:
14751         case R_PPC64_TOC16_DS:
14752         case R_PPC64_TOC16_LO_DS:
14753         case R_PPC64_TOC16_HA:
14754           addend -= TOCstart + htab->sec_info[input_section->id].toc_off;
14755           break;
14756
14757           /* Relocate against the beginning of the section.  */
14758         case R_PPC64_SECTOFF:
14759         case R_PPC64_SECTOFF_LO:
14760         case R_PPC64_SECTOFF_HI:
14761         case R_PPC64_SECTOFF_DS:
14762         case R_PPC64_SECTOFF_LO_DS:
14763         case R_PPC64_SECTOFF_HA:
14764           if (sec != NULL)
14765             addend -= sec->output_section->vma;
14766           break;
14767
14768         case R_PPC64_REL16:
14769         case R_PPC64_REL16_LO:
14770         case R_PPC64_REL16_HI:
14771         case R_PPC64_REL16_HA:
14772         case R_PPC64_REL16DX_HA:
14773           break;
14774
14775         case R_PPC64_REL14:
14776         case R_PPC64_REL14_BRNTAKEN:
14777         case R_PPC64_REL14_BRTAKEN:
14778         case R_PPC64_REL24:
14779           break;
14780
14781         case R_PPC64_TPREL16:
14782         case R_PPC64_TPREL16_LO:
14783         case R_PPC64_TPREL16_HI:
14784         case R_PPC64_TPREL16_HA:
14785         case R_PPC64_TPREL16_DS:
14786         case R_PPC64_TPREL16_LO_DS:
14787         case R_PPC64_TPREL16_HIGH:
14788         case R_PPC64_TPREL16_HIGHA:
14789         case R_PPC64_TPREL16_HIGHER:
14790         case R_PPC64_TPREL16_HIGHERA:
14791         case R_PPC64_TPREL16_HIGHEST:
14792         case R_PPC64_TPREL16_HIGHESTA:
14793           if (h != NULL
14794               && h->elf.root.type == bfd_link_hash_undefweak
14795               && h->elf.dynindx == -1)
14796             {
14797               /* Make this relocation against an undefined weak symbol
14798                  resolve to zero.  This is really just a tweak, since
14799                  code using weak externs ought to check that they are
14800                  defined before using them.  */
14801               bfd_byte *p = contents + rel->r_offset - d_offset;
14802
14803               insn = bfd_get_32 (input_bfd, p);
14804               insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14805               if (insn != 0)
14806                 bfd_put_32 (input_bfd, insn, p);
14807               break;
14808             }
14809           if (htab->elf.tls_sec != NULL)
14810             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14811           if (bfd_link_pic (info))
14812             /* The TPREL16 relocs shouldn't really be used in shared
14813                libs as they will result in DT_TEXTREL being set, but
14814                support them anyway.  */
14815             goto dodyn;
14816           break;
14817
14818         case R_PPC64_DTPREL16:
14819         case R_PPC64_DTPREL16_LO:
14820         case R_PPC64_DTPREL16_HI:
14821         case R_PPC64_DTPREL16_HA:
14822         case R_PPC64_DTPREL16_DS:
14823         case R_PPC64_DTPREL16_LO_DS:
14824         case R_PPC64_DTPREL16_HIGH:
14825         case R_PPC64_DTPREL16_HIGHA:
14826         case R_PPC64_DTPREL16_HIGHER:
14827         case R_PPC64_DTPREL16_HIGHERA:
14828         case R_PPC64_DTPREL16_HIGHEST:
14829         case R_PPC64_DTPREL16_HIGHESTA:
14830           if (htab->elf.tls_sec != NULL)
14831             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14832           break;
14833
14834         case R_PPC64_ADDR64_LOCAL:
14835           addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
14836                                               ? h->elf.other
14837                                               : sym->st_other);
14838           break;
14839
14840         case R_PPC64_DTPMOD64:
14841           relocation = 1;
14842           addend = 0;
14843           goto dodyn;
14844
14845         case R_PPC64_TPREL64:
14846           if (htab->elf.tls_sec != NULL)
14847             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14848           goto dodyn;
14849
14850         case R_PPC64_DTPREL64:
14851           if (htab->elf.tls_sec != NULL)
14852             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14853           /* Fall through.  */
14854
14855           /* Relocations that may need to be propagated if this is a
14856              dynamic object.  */
14857         case R_PPC64_REL30:
14858         case R_PPC64_REL32:
14859         case R_PPC64_REL64:
14860         case R_PPC64_ADDR14:
14861         case R_PPC64_ADDR14_BRNTAKEN:
14862         case R_PPC64_ADDR14_BRTAKEN:
14863         case R_PPC64_ADDR16:
14864         case R_PPC64_ADDR16_DS:
14865         case R_PPC64_ADDR16_HA:
14866         case R_PPC64_ADDR16_HI:
14867         case R_PPC64_ADDR16_HIGH:
14868         case R_PPC64_ADDR16_HIGHA:
14869         case R_PPC64_ADDR16_HIGHER:
14870         case R_PPC64_ADDR16_HIGHERA:
14871         case R_PPC64_ADDR16_HIGHEST:
14872         case R_PPC64_ADDR16_HIGHESTA:
14873         case R_PPC64_ADDR16_LO:
14874         case R_PPC64_ADDR16_LO_DS:
14875         case R_PPC64_ADDR24:
14876         case R_PPC64_ADDR32:
14877         case R_PPC64_ADDR64:
14878         case R_PPC64_UADDR16:
14879         case R_PPC64_UADDR32:
14880         case R_PPC64_UADDR64:
14881         dodyn:
14882           if ((input_section->flags & SEC_ALLOC) == 0)
14883             break;
14884
14885           if (NO_OPD_RELOCS && is_opd)
14886             break;
14887
14888           if (bfd_link_pic (info)
14889               ? ((h == NULL
14890                   || h->dyn_relocs != NULL)
14891                  && ((h != NULL && pc_dynrelocs (h))
14892                      || must_be_dyn_reloc (info, r_type)))
14893               : (h != NULL
14894                  ? h->dyn_relocs != NULL
14895                  : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14896             {
14897               bfd_boolean skip, relocate;
14898               asection *sreloc;
14899               bfd_vma out_off;
14900               long indx = 0;
14901
14902               /* When generating a dynamic object, these relocations
14903                  are copied into the output file to be resolved at run
14904                  time.  */
14905
14906               skip = FALSE;
14907               relocate = FALSE;
14908
14909               out_off = _bfd_elf_section_offset (output_bfd, info,
14910                                                  input_section, rel->r_offset);
14911               if (out_off == (bfd_vma) -1)
14912                 skip = TRUE;
14913               else if (out_off == (bfd_vma) -2)
14914                 skip = TRUE, relocate = TRUE;
14915               out_off += (input_section->output_section->vma
14916                           + input_section->output_offset);
14917               outrel.r_offset = out_off;
14918               outrel.r_addend = rel->r_addend;
14919
14920               /* Optimize unaligned reloc use.  */
14921               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14922                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14923                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14924               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14925                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
14926                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
14927               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
14928                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
14929                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
14930
14931               if (skip)
14932                 memset (&outrel, 0, sizeof outrel);
14933               else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14934                        && !is_opd
14935                        && r_type != R_PPC64_TOC)
14936                 {
14937                   indx = h->elf.dynindx;
14938                   BFD_ASSERT (indx != -1);
14939                   outrel.r_info = ELF64_R_INFO (indx, r_type);
14940                 }
14941               else
14942                 {
14943                   /* This symbol is local, or marked to become local,
14944                      or this is an opd section reloc which must point
14945                      at a local function.  */
14946                   outrel.r_addend += relocation;
14947                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
14948                     {
14949                       if (is_opd && h != NULL)
14950                         {
14951                           /* Lie about opd entries.  This case occurs
14952                              when building shared libraries and we
14953                              reference a function in another shared
14954                              lib.  The same thing happens for a weak
14955                              definition in an application that's
14956                              overridden by a strong definition in a
14957                              shared lib.  (I believe this is a generic
14958                              bug in binutils handling of weak syms.)
14959                              In these cases we won't use the opd
14960                              entry in this lib.  */
14961                           unresolved_reloc = FALSE;
14962                         }
14963                       if (!is_opd
14964                           && r_type == R_PPC64_ADDR64
14965                           && (h != NULL
14966                               ? h->elf.type == STT_GNU_IFUNC
14967                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14968                         outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14969                       else
14970                         {
14971                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14972
14973                           /* We need to relocate .opd contents for ld.so.
14974                              Prelink also wants simple and consistent rules
14975                              for relocs.  This make all RELATIVE relocs have
14976                              *r_offset equal to r_addend.  */
14977                           relocate = TRUE;
14978                         }
14979                     }
14980                   else
14981                     {
14982                       if (h != NULL
14983                           ? h->elf.type == STT_GNU_IFUNC
14984                           : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14985                         {
14986                           info->callbacks->einfo
14987                             /* xgettext:c-format */
14988                             (_("%H: %s for indirect "
14989                                "function `%T' unsupported\n"),
14990                              input_bfd, input_section, rel->r_offset,
14991                              ppc64_elf_howto_table[r_type]->name,
14992                              sym_name);
14993                           ret = FALSE;
14994                         }
14995                       else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
14996                         ;
14997                       else if (sec == NULL || sec->owner == NULL)
14998                         {
14999                           bfd_set_error (bfd_error_bad_value);
15000                           return FALSE;
15001                         }
15002                       else
15003                         {
15004                           asection *osec;
15005
15006                           osec = sec->output_section;
15007                           indx = elf_section_data (osec)->dynindx;
15008
15009                           if (indx == 0)
15010                             {
15011                               if ((osec->flags & SEC_READONLY) == 0
15012                                   && htab->elf.data_index_section != NULL)
15013                                 osec = htab->elf.data_index_section;
15014                               else
15015                                 osec = htab->elf.text_index_section;
15016                               indx = elf_section_data (osec)->dynindx;
15017                             }
15018                           BFD_ASSERT (indx != 0);
15019
15020                           /* We are turning this relocation into one
15021                              against a section symbol, so subtract out
15022                              the output section's address but not the
15023                              offset of the input section in the output
15024                              section.  */
15025                           outrel.r_addend -= osec->vma;
15026                         }
15027
15028                       outrel.r_info = ELF64_R_INFO (indx, r_type);
15029                     }
15030                 }
15031
15032               sreloc = elf_section_data (input_section)->sreloc;
15033               if (h != NULL
15034                   ? h->elf.type == STT_GNU_IFUNC
15035                   : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
15036                 {
15037                   sreloc = htab->elf.irelplt;
15038                   if (indx == 0)
15039                     htab->local_ifunc_resolver = 1;
15040                   else if (is_static_defined (&h->elf))
15041                     htab->maybe_local_ifunc_resolver = 1;
15042                 }
15043               if (sreloc == NULL)
15044                 abort ();
15045
15046               if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
15047                   >= sreloc->size)
15048                 abort ();
15049               loc = sreloc->contents;
15050               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
15051               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
15052
15053               /* If this reloc is against an external symbol, it will
15054                  be computed at runtime, so there's no need to do
15055                  anything now.  However, for the sake of prelink ensure
15056                  that the section contents are a known value.  */
15057               if (! relocate)
15058                 {
15059                   unresolved_reloc = FALSE;
15060                   /* The value chosen here is quite arbitrary as ld.so
15061                      ignores section contents except for the special
15062                      case of .opd where the contents might be accessed
15063                      before relocation.  Choose zero, as that won't
15064                      cause reloc overflow.  */
15065                   relocation = 0;
15066                   addend = 0;
15067                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
15068                      to improve backward compatibility with older
15069                      versions of ld.  */
15070                   if (r_type == R_PPC64_ADDR64)
15071                     addend = outrel.r_addend;
15072                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
15073                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
15074                     addend = outrel.r_offset;
15075                 }
15076             }
15077           break;
15078
15079         case R_PPC64_COPY:
15080         case R_PPC64_GLOB_DAT:
15081         case R_PPC64_JMP_SLOT:
15082         case R_PPC64_JMP_IREL:
15083         case R_PPC64_RELATIVE:
15084           /* We shouldn't ever see these dynamic relocs in relocatable
15085              files.  */
15086           /* Fall through.  */
15087
15088         case R_PPC64_PLTGOT16:
15089         case R_PPC64_PLTGOT16_DS:
15090         case R_PPC64_PLTGOT16_HA:
15091         case R_PPC64_PLTGOT16_HI:
15092         case R_PPC64_PLTGOT16_LO:
15093         case R_PPC64_PLTGOT16_LO_DS:
15094         case R_PPC64_PLTREL32:
15095         case R_PPC64_PLTREL64:
15096           /* These ones haven't been implemented yet.  */
15097
15098           info->callbacks->einfo
15099             /* xgettext:c-format */
15100             (_("%P: %B: %s is not supported for `%T'\n"),
15101              input_bfd,
15102              ppc64_elf_howto_table[r_type]->name, sym_name);
15103
15104           bfd_set_error (bfd_error_invalid_operation);
15105           ret = FALSE;
15106           goto copy_reloc;
15107         }
15108
15109       /* Multi-instruction sequences that access the TOC can be
15110          optimized, eg. addis ra,r2,0; addi rb,ra,x;
15111          to             nop;           addi rb,r2,x;  */
15112       switch (r_type)
15113         {
15114         default:
15115           break;
15116
15117         case R_PPC64_GOT_TLSLD16_HI:
15118         case R_PPC64_GOT_TLSGD16_HI:
15119         case R_PPC64_GOT_TPREL16_HI:
15120         case R_PPC64_GOT_DTPREL16_HI:
15121         case R_PPC64_GOT16_HI:
15122         case R_PPC64_TOC16_HI:
15123           /* These relocs would only be useful if building up an
15124              offset to later add to r2, perhaps in an indexed
15125              addressing mode instruction.  Don't try to optimize.
15126              Unfortunately, the possibility of someone building up an
15127              offset like this or even with the HA relocs, means that
15128              we need to check the high insn when optimizing the low
15129              insn.  */
15130           break;
15131
15132         case R_PPC64_GOT_TLSLD16_HA:
15133         case R_PPC64_GOT_TLSGD16_HA:
15134         case R_PPC64_GOT_TPREL16_HA:
15135         case R_PPC64_GOT_DTPREL16_HA:
15136         case R_PPC64_GOT16_HA:
15137         case R_PPC64_TOC16_HA:
15138           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
15139               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
15140             {
15141               bfd_byte *p = contents + (rel->r_offset & ~3);
15142               bfd_put_32 (input_bfd, NOP, p);
15143             }
15144           break;
15145
15146         case R_PPC64_GOT_TLSLD16_LO:
15147         case R_PPC64_GOT_TLSGD16_LO:
15148         case R_PPC64_GOT_TPREL16_LO_DS:
15149         case R_PPC64_GOT_DTPREL16_LO_DS:
15150         case R_PPC64_GOT16_LO:
15151         case R_PPC64_GOT16_LO_DS:
15152         case R_PPC64_TOC16_LO:
15153         case R_PPC64_TOC16_LO_DS:
15154           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
15155               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
15156             {
15157               bfd_byte *p = contents + (rel->r_offset & ~3);
15158               insn = bfd_get_32 (input_bfd, p);
15159               if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
15160                 {
15161                   /* Transform addic to addi when we change reg.  */
15162                   insn &= ~((0x3f << 26) | (0x1f << 16));
15163                   insn |= (14u << 26) | (2 << 16);
15164                 }
15165               else
15166                 {
15167                   insn &= ~(0x1f << 16);
15168                   insn |= 2 << 16;
15169                 }
15170               bfd_put_32 (input_bfd, insn, p);
15171             }
15172           break;
15173         }
15174
15175       /* Do any further special processing.  */
15176       howto = ppc64_elf_howto_table[(int) r_type];
15177       switch (r_type)
15178         {
15179         default:
15180           break;
15181
15182         case R_PPC64_REL16_HA:
15183         case R_PPC64_REL16DX_HA:
15184         case R_PPC64_ADDR16_HA:
15185         case R_PPC64_ADDR16_HIGHA:
15186         case R_PPC64_ADDR16_HIGHERA:
15187         case R_PPC64_ADDR16_HIGHESTA:
15188         case R_PPC64_TOC16_HA:
15189         case R_PPC64_SECTOFF_HA:
15190         case R_PPC64_TPREL16_HA:
15191         case R_PPC64_TPREL16_HIGHA:
15192         case R_PPC64_TPREL16_HIGHERA:
15193         case R_PPC64_TPREL16_HIGHESTA:
15194         case R_PPC64_DTPREL16_HA:
15195         case R_PPC64_DTPREL16_HIGHA:
15196         case R_PPC64_DTPREL16_HIGHERA:
15197         case R_PPC64_DTPREL16_HIGHESTA:
15198           /* It's just possible that this symbol is a weak symbol
15199              that's not actually defined anywhere. In that case,
15200              'sec' would be NULL, and we should leave the symbol
15201              alone (it will be set to zero elsewhere in the link).  */
15202           if (sec == NULL)
15203             break;
15204           /* Fall through.  */
15205
15206         case R_PPC64_GOT16_HA:
15207         case R_PPC64_PLTGOT16_HA:
15208         case R_PPC64_PLT16_HA:
15209         case R_PPC64_GOT_TLSGD16_HA:
15210         case R_PPC64_GOT_TLSLD16_HA:
15211         case R_PPC64_GOT_TPREL16_HA:
15212         case R_PPC64_GOT_DTPREL16_HA:
15213           /* Add 0x10000 if sign bit in 0:15 is set.
15214              Bits 0:15 are not used.  */
15215           addend += 0x8000;
15216           break;
15217
15218         case R_PPC64_ADDR16_DS:
15219         case R_PPC64_ADDR16_LO_DS:
15220         case R_PPC64_GOT16_DS:
15221         case R_PPC64_GOT16_LO_DS:
15222         case R_PPC64_PLT16_LO_DS:
15223         case R_PPC64_SECTOFF_DS:
15224         case R_PPC64_SECTOFF_LO_DS:
15225         case R_PPC64_TOC16_DS:
15226         case R_PPC64_TOC16_LO_DS:
15227         case R_PPC64_PLTGOT16_DS:
15228         case R_PPC64_PLTGOT16_LO_DS:
15229         case R_PPC64_GOT_TPREL16_DS:
15230         case R_PPC64_GOT_TPREL16_LO_DS:
15231         case R_PPC64_GOT_DTPREL16_DS:
15232         case R_PPC64_GOT_DTPREL16_LO_DS:
15233         case R_PPC64_TPREL16_DS:
15234         case R_PPC64_TPREL16_LO_DS:
15235         case R_PPC64_DTPREL16_DS:
15236         case R_PPC64_DTPREL16_LO_DS:
15237           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15238           mask = 3;
15239           /* If this reloc is against an lq, lxv, or stxv insn, then
15240              the value must be a multiple of 16.  This is somewhat of
15241              a hack, but the "correct" way to do this by defining _DQ
15242              forms of all the _DS relocs bloats all reloc switches in
15243              this file.  It doesn't make much sense to use these
15244              relocs in data, so testing the insn should be safe.  */
15245           if ((insn & (0x3f << 26)) == (56u << 26)
15246               || ((insn & (0x3f << 26)) == (61u << 26) && (insn & 3) == 1))
15247             mask = 15;
15248           relocation += addend;
15249           addend = insn & (mask ^ 3);
15250           if ((relocation & mask) != 0)
15251             {
15252               relocation ^= relocation & mask;
15253               info->callbacks->einfo
15254                 /* xgettext:c-format */
15255                 (_("%H: error: %s not a multiple of %u\n"),
15256                  input_bfd, input_section, rel->r_offset,
15257                  howto->name,
15258                  mask + 1);
15259               bfd_set_error (bfd_error_bad_value);
15260               ret = FALSE;
15261               goto copy_reloc;
15262             }
15263           break;
15264         }
15265
15266       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
15267          because such sections are not SEC_ALLOC and thus ld.so will
15268          not process them.  */
15269       if (unresolved_reloc
15270           && !((input_section->flags & SEC_DEBUGGING) != 0
15271                && h->elf.def_dynamic)
15272           && _bfd_elf_section_offset (output_bfd, info, input_section,
15273                                       rel->r_offset) != (bfd_vma) -1)
15274         {
15275           info->callbacks->einfo
15276             /* xgettext:c-format */
15277             (_("%H: unresolvable %s against `%T'\n"),
15278              input_bfd, input_section, rel->r_offset,
15279              howto->name,
15280              h->elf.root.root.string);
15281           ret = FALSE;
15282         }
15283
15284       /* 16-bit fields in insns mostly have signed values, but a
15285          few insns have 16-bit unsigned values.  Really, we should
15286          have different reloc types.  */
15287       if (howto->complain_on_overflow != complain_overflow_dont
15288           && howto->dst_mask == 0xffff
15289           && (input_section->flags & SEC_CODE) != 0)
15290         {
15291           enum complain_overflow complain = complain_overflow_signed;
15292
15293           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15294           if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
15295             complain = complain_overflow_bitfield;
15296           else if (howto->rightshift == 0
15297                    ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
15298                       || (insn & (0x3f << 26)) == 24u << 26 /* ori */
15299                       || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
15300                    : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
15301                       || (insn & (0x3f << 26)) == 25u << 26 /* oris */
15302                       || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
15303             complain = complain_overflow_unsigned;
15304           if (howto->complain_on_overflow != complain)
15305             {
15306               alt_howto = *howto;
15307               alt_howto.complain_on_overflow = complain;
15308               howto = &alt_howto;
15309             }
15310         }
15311
15312       if (r_type == R_PPC64_REL16DX_HA)
15313         {
15314           /* Split field reloc isn't handled by _bfd_final_link_relocate.  */
15315           if (rel->r_offset + 4 > input_section->size)
15316             r = bfd_reloc_outofrange;
15317           else
15318             {
15319               relocation += addend;
15320               relocation -= (rel->r_offset
15321                              + input_section->output_offset
15322                              + input_section->output_section->vma);
15323               relocation = (bfd_signed_vma) relocation >> 16;
15324               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
15325               insn &= ~0x1fffc1;
15326               insn |= (relocation & 0xffc1) | ((relocation & 0x3e) << 15);
15327               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
15328               r = bfd_reloc_ok;
15329               if (relocation + 0x8000 > 0xffff)
15330                 r = bfd_reloc_overflow;
15331             }
15332         }
15333       else
15334         r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
15335                                       rel->r_offset, relocation, addend);
15336
15337       if (r != bfd_reloc_ok)
15338         {
15339           char *more_info = NULL;
15340           const char *reloc_name = howto->name;
15341
15342           if (reloc_dest != DEST_NORMAL)
15343             {
15344               more_info = bfd_malloc (strlen (reloc_name) + 8);
15345               if (more_info != NULL)
15346                 {
15347                   strcpy (more_info, reloc_name);
15348                   strcat (more_info, (reloc_dest == DEST_OPD
15349                                       ? " (OPD)" : " (stub)"));
15350                   reloc_name = more_info;
15351                 }
15352             }
15353
15354           if (r == bfd_reloc_overflow)
15355             {
15356               /* On code like "if (foo) foo();" don't report overflow
15357                  on a branch to zero when foo is undefined.  */
15358               if (!warned
15359                   && (reloc_dest == DEST_STUB
15360                       || !(h != NULL
15361                            && (h->elf.root.type == bfd_link_hash_undefweak
15362                                || h->elf.root.type == bfd_link_hash_undefined)
15363                            && is_branch_reloc (r_type))))
15364                 info->callbacks->reloc_overflow (info, &h->elf.root,
15365                                                  sym_name, reloc_name,
15366                                                  orig_rel.r_addend,
15367                                                  input_bfd, input_section,
15368                                                  rel->r_offset);
15369             }
15370           else
15371             {
15372               info->callbacks->einfo
15373                 /* xgettext:c-format */
15374                 (_("%H: %s against `%T': error %d\n"),
15375                  input_bfd, input_section, rel->r_offset,
15376                  reloc_name, sym_name, (int) r);
15377               ret = FALSE;
15378             }
15379           if (more_info != NULL)
15380             free (more_info);
15381         }
15382     copy_reloc:
15383       if (wrel != rel)
15384         *wrel = *rel;
15385     }
15386
15387   if (wrel != rel)
15388     {
15389       Elf_Internal_Shdr *rel_hdr;
15390       size_t deleted = rel - wrel;
15391
15392       rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
15393       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15394       if (rel_hdr->sh_size == 0)
15395         {
15396           /* It is too late to remove an empty reloc section.  Leave
15397              one NONE reloc.
15398              ??? What is wrong with an empty section???  */
15399           rel_hdr->sh_size = rel_hdr->sh_entsize;
15400           deleted -= 1;
15401         }
15402       rel_hdr = _bfd_elf_single_rel_hdr (input_section);
15403       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15404       input_section->reloc_count -= deleted;
15405     }
15406
15407   /* If we're emitting relocations, then shortly after this function
15408      returns, reloc offsets and addends for this section will be
15409      adjusted.  Worse, reloc symbol indices will be for the output
15410      file rather than the input.  Save a copy of the relocs for
15411      opd_entry_value.  */
15412   if (is_opd && (info->emitrelocations || bfd_link_relocatable (info)))
15413     {
15414       bfd_size_type amt;
15415       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
15416       rel = bfd_alloc (input_bfd, amt);
15417       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
15418       ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
15419       if (rel == NULL)
15420         return FALSE;
15421       memcpy (rel, relocs, amt);
15422     }
15423   return ret;
15424 }
15425
15426 /* Adjust the value of any local symbols in opd sections.  */
15427
15428 static int
15429 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
15430                               const char *name ATTRIBUTE_UNUSED,
15431                               Elf_Internal_Sym *elfsym,
15432                               asection *input_sec,
15433                               struct elf_link_hash_entry *h)
15434 {
15435   struct _opd_sec_data *opd;
15436   long adjust;
15437   bfd_vma value;
15438
15439   if (h != NULL)
15440     return 1;
15441
15442   opd = get_opd_info (input_sec);
15443   if (opd == NULL || opd->adjust == NULL)
15444     return 1;
15445
15446   value = elfsym->st_value - input_sec->output_offset;
15447   if (!bfd_link_relocatable (info))
15448     value -= input_sec->output_section->vma;
15449
15450   adjust = opd->adjust[OPD_NDX (value)];
15451   if (adjust == -1)
15452     return 2;
15453
15454   elfsym->st_value += adjust;
15455   return 1;
15456 }
15457
15458 /* Finish up dynamic symbol handling.  We set the contents of various
15459    dynamic sections here.  */
15460
15461 static bfd_boolean
15462 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
15463                                  struct bfd_link_info *info,
15464                                  struct elf_link_hash_entry *h,
15465                                  Elf_Internal_Sym *sym)
15466 {
15467   struct ppc_link_hash_table *htab;
15468   struct plt_entry *ent;
15469   Elf_Internal_Rela rela;
15470   bfd_byte *loc;
15471
15472   htab = ppc_hash_table (info);
15473   if (htab == NULL)
15474     return FALSE;
15475
15476   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
15477     if (ent->plt.offset != (bfd_vma) -1)
15478       {
15479         /* This symbol has an entry in the procedure linkage
15480            table.  Set it up.  */
15481         if (!htab->elf.dynamic_sections_created
15482             || h->dynindx == -1)
15483           {
15484             BFD_ASSERT (h->type == STT_GNU_IFUNC
15485                         && h->def_regular
15486                         && (h->root.type == bfd_link_hash_defined
15487                             || h->root.type == bfd_link_hash_defweak));
15488             rela.r_offset = (htab->elf.iplt->output_section->vma
15489                              + htab->elf.iplt->output_offset
15490                              + ent->plt.offset);
15491             if (htab->opd_abi)
15492               rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
15493             else
15494               rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15495             rela.r_addend = (h->root.u.def.value
15496                              + h->root.u.def.section->output_offset
15497                              + h->root.u.def.section->output_section->vma
15498                              + ent->addend);
15499             loc = (htab->elf.irelplt->contents
15500                    + (htab->elf.irelplt->reloc_count++
15501                       * sizeof (Elf64_External_Rela)));
15502             htab->local_ifunc_resolver = 1;
15503           }
15504         else
15505           {
15506             rela.r_offset = (htab->elf.splt->output_section->vma
15507                              + htab->elf.splt->output_offset
15508                              + ent->plt.offset);
15509             rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
15510             rela.r_addend = ent->addend;
15511             loc = (htab->elf.srelplt->contents
15512                    + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
15513                       / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
15514             if (h->type == STT_GNU_IFUNC && is_static_defined (h))
15515               htab->maybe_local_ifunc_resolver = 1;
15516           }
15517         bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15518
15519         if (!htab->opd_abi)
15520           {
15521             if (!h->def_regular)
15522               {
15523                 /* Mark the symbol as undefined, rather than as
15524                    defined in glink.  Leave the value if there were
15525                    any relocations where pointer equality matters
15526                    (this is a clue for the dynamic linker, to make
15527                    function pointer comparisons work between an
15528                    application and shared library), otherwise set it
15529                    to zero.  */
15530                 sym->st_shndx = SHN_UNDEF;
15531                 if (!h->pointer_equality_needed)
15532                   sym->st_value = 0;
15533                 else if (!h->ref_regular_nonweak)
15534                   {
15535                     /* This breaks function pointer comparisons, but
15536                        that is better than breaking tests for a NULL
15537                        function pointer.  */
15538                     sym->st_value = 0;
15539                   }
15540               }
15541           }
15542       }
15543
15544   if (h->needs_copy)
15545     {
15546       /* This symbol needs a copy reloc.  Set it up.  */
15547       asection *srel;
15548
15549       if (h->dynindx == -1
15550           || (h->root.type != bfd_link_hash_defined
15551               && h->root.type != bfd_link_hash_defweak)
15552           || htab->elf.srelbss == NULL
15553           || htab->elf.sreldynrelro == NULL)
15554         abort ();
15555
15556       rela.r_offset = (h->root.u.def.value
15557                        + h->root.u.def.section->output_section->vma
15558                        + h->root.u.def.section->output_offset);
15559       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
15560       rela.r_addend = 0;
15561       if (h->root.u.def.section == htab->elf.sdynrelro)
15562         srel = htab->elf.sreldynrelro;
15563       else
15564         srel = htab->elf.srelbss;
15565       loc = srel->contents;
15566       loc += srel->reloc_count++ * sizeof (Elf64_External_Rela);
15567       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15568     }
15569
15570   return TRUE;
15571 }
15572
15573 /* Used to decide how to sort relocs in an optimal manner for the
15574    dynamic linker, before writing them out.  */
15575
15576 static enum elf_reloc_type_class
15577 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
15578                             const asection *rel_sec,
15579                             const Elf_Internal_Rela *rela)
15580 {
15581   enum elf_ppc64_reloc_type r_type;
15582   struct ppc_link_hash_table *htab = ppc_hash_table (info);
15583
15584   if (rel_sec == htab->elf.irelplt)
15585     return reloc_class_ifunc;
15586
15587   r_type = ELF64_R_TYPE (rela->r_info);
15588   switch (r_type)
15589     {
15590     case R_PPC64_RELATIVE:
15591       return reloc_class_relative;
15592     case R_PPC64_JMP_SLOT:
15593       return reloc_class_plt;
15594     case R_PPC64_COPY:
15595       return reloc_class_copy;
15596     default:
15597       return reloc_class_normal;
15598     }
15599 }
15600
15601 /* Finish up the dynamic sections.  */
15602
15603 static bfd_boolean
15604 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
15605                                    struct bfd_link_info *info)
15606 {
15607   struct ppc_link_hash_table *htab;
15608   bfd *dynobj;
15609   asection *sdyn;
15610
15611   htab = ppc_hash_table (info);
15612   if (htab == NULL)
15613     return FALSE;
15614
15615   dynobj = htab->elf.dynobj;
15616   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
15617
15618   if (htab->elf.dynamic_sections_created)
15619     {
15620       Elf64_External_Dyn *dyncon, *dynconend;
15621
15622       if (sdyn == NULL || htab->elf.sgot == NULL)
15623         abort ();
15624
15625       dyncon = (Elf64_External_Dyn *) sdyn->contents;
15626       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
15627       for (; dyncon < dynconend; dyncon++)
15628         {
15629           Elf_Internal_Dyn dyn;
15630           asection *s;
15631
15632           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
15633
15634           switch (dyn.d_tag)
15635             {
15636             default:
15637               continue;
15638
15639             case DT_PPC64_GLINK:
15640               s = htab->glink;
15641               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15642               /* We stupidly defined DT_PPC64_GLINK to be the start
15643                  of glink rather than the first entry point, which is
15644                  what ld.so needs, and now have a bigger stub to
15645                  support automatic multiple TOCs.  */
15646               dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
15647               break;
15648
15649             case DT_PPC64_OPD:
15650               s = bfd_get_section_by_name (output_bfd, ".opd");
15651               if (s == NULL)
15652                 continue;
15653               dyn.d_un.d_ptr = s->vma;
15654               break;
15655
15656             case DT_PPC64_OPT:
15657               if (htab->do_multi_toc && htab->multi_toc_needed)
15658                 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
15659               if (htab->has_plt_localentry0)
15660                 dyn.d_un.d_val |= PPC64_OPT_LOCALENTRY;
15661               break;
15662
15663             case DT_PPC64_OPDSZ:
15664               s = bfd_get_section_by_name (output_bfd, ".opd");
15665               if (s == NULL)
15666                 continue;
15667               dyn.d_un.d_val = s->size;
15668               break;
15669
15670             case DT_PLTGOT:
15671               s = htab->elf.splt;
15672               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15673               break;
15674
15675             case DT_JMPREL:
15676               s = htab->elf.srelplt;
15677               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15678               break;
15679
15680             case DT_PLTRELSZ:
15681               dyn.d_un.d_val = htab->elf.srelplt->size;
15682               break;
15683
15684             case DT_TEXTREL:
15685               if (htab->local_ifunc_resolver)
15686                 info->callbacks->einfo
15687                   (_("%X%P: text relocations and GNU indirect "
15688                      "functions will result in a segfault at runtime\n"));
15689               else if (htab->maybe_local_ifunc_resolver)
15690                 info->callbacks->einfo
15691                   (_("%P: warning: text relocations and GNU indirect "
15692                      "functions may result in a segfault at runtime\n"));
15693               continue;
15694             }
15695
15696           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
15697         }
15698     }
15699
15700   if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0
15701       && htab->elf.sgot->output_section != bfd_abs_section_ptr)
15702     {
15703       /* Fill in the first entry in the global offset table.
15704          We use it to hold the link-time TOCbase.  */
15705       bfd_put_64 (output_bfd,
15706                   elf_gp (output_bfd) + TOC_BASE_OFF,
15707                   htab->elf.sgot->contents);
15708
15709       /* Set .got entry size.  */
15710       elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
15711     }
15712
15713   if (htab->elf.splt != NULL && htab->elf.splt->size != 0
15714       && htab->elf.splt->output_section != bfd_abs_section_ptr)
15715     {
15716       /* Set .plt entry size.  */
15717       elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
15718         = PLT_ENTRY_SIZE (htab);
15719     }
15720
15721   /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
15722      brlt ourselves if emitrelocations.  */
15723   if (htab->brlt != NULL
15724       && htab->brlt->reloc_count != 0
15725       && !_bfd_elf_link_output_relocs (output_bfd,
15726                                        htab->brlt,
15727                                        elf_section_data (htab->brlt)->rela.hdr,
15728                                        elf_section_data (htab->brlt)->relocs,
15729                                        NULL))
15730     return FALSE;
15731
15732   if (htab->glink != NULL
15733       && htab->glink->reloc_count != 0
15734       && !_bfd_elf_link_output_relocs (output_bfd,
15735                                        htab->glink,
15736                                        elf_section_data (htab->glink)->rela.hdr,
15737                                        elf_section_data (htab->glink)->relocs,
15738                                        NULL))
15739     return FALSE;
15740
15741   if (htab->glink_eh_frame != NULL
15742       && htab->glink_eh_frame->size != 0)
15743     {
15744       bfd_vma val;
15745       bfd_byte *p;
15746       asection *stub_sec;
15747       size_t align = 4;
15748
15749       p = htab->glink_eh_frame->contents;
15750       p += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
15751       for (stub_sec = htab->params->stub_bfd->sections;
15752            stub_sec != NULL;
15753            stub_sec = stub_sec->next)
15754         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
15755           {
15756             /* FDE length.  */
15757             p += 4;
15758             /* CIE pointer.  */
15759             p += 4;
15760             /* Offset to stub section.  */
15761             val = (stub_sec->output_section->vma
15762                    + stub_sec->output_offset);
15763             val -= (htab->glink_eh_frame->output_section->vma
15764                     + htab->glink_eh_frame->output_offset
15765                     + (p - htab->glink_eh_frame->contents));
15766             if (val + 0x80000000 > 0xffffffff)
15767               {
15768                 info->callbacks->einfo
15769                   (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15770                    stub_sec->name);
15771                 return FALSE;
15772               }
15773             bfd_put_32 (dynobj, val, p);
15774             p += 4;
15775             /* stub section size.  */
15776             p += 4;
15777             /* Augmentation.  */
15778             p += 1;
15779             /* Pad.  */
15780             p += ((17 + align - 1) & -align) - 17;
15781           }
15782       if (htab->glink != NULL && htab->glink->size != 0)
15783         {
15784           /* FDE length.  */
15785           p += 4;
15786           /* CIE pointer.  */
15787           p += 4;
15788           /* Offset to .glink.  */
15789           val = (htab->glink->output_section->vma
15790                  + htab->glink->output_offset
15791                  + 8);
15792           val -= (htab->glink_eh_frame->output_section->vma
15793                   + htab->glink_eh_frame->output_offset
15794                   + (p - htab->glink_eh_frame->contents));
15795           if (val + 0x80000000 > 0xffffffff)
15796             {
15797               info->callbacks->einfo
15798                 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15799                  htab->glink->name);
15800               return FALSE;
15801             }
15802           bfd_put_32 (dynobj, val, p);
15803           p += 4;
15804           /* .glink size.  */
15805           p += 4;
15806           /* Augmentation.  */
15807           p += 1;
15808           /* Ops.  */
15809           p += 7;
15810           p += ((24 + align - 1) & -align) - 24;
15811         }
15812
15813       if (htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
15814           && !_bfd_elf_write_section_eh_frame (output_bfd, info,
15815                                                htab->glink_eh_frame,
15816                                                htab->glink_eh_frame->contents))
15817         return FALSE;
15818     }
15819
15820   /* We need to handle writing out multiple GOT sections ourselves,
15821      since we didn't add them to DYNOBJ.  We know dynobj is the first
15822      bfd.  */
15823   while ((dynobj = dynobj->link.next) != NULL)
15824     {
15825       asection *s;
15826
15827       if (!is_ppc64_elf (dynobj))
15828         continue;
15829
15830       s = ppc64_elf_tdata (dynobj)->got;
15831       if (s != NULL
15832           && s->size != 0
15833           && s->output_section != bfd_abs_section_ptr
15834           && !bfd_set_section_contents (output_bfd, s->output_section,
15835                                         s->contents, s->output_offset,
15836                                         s->size))
15837         return FALSE;
15838       s = ppc64_elf_tdata (dynobj)->relgot;
15839       if (s != NULL
15840           && s->size != 0
15841           && s->output_section != bfd_abs_section_ptr
15842           && !bfd_set_section_contents (output_bfd, s->output_section,
15843                                         s->contents, s->output_offset,
15844                                         s->size))
15845         return FALSE;
15846     }
15847
15848   return TRUE;
15849 }
15850
15851 #include "elf64-target.h"
15852
15853 /* FreeBSD support */
15854
15855 #undef  TARGET_LITTLE_SYM
15856 #undef  TARGET_LITTLE_NAME
15857
15858 #undef  TARGET_BIG_SYM
15859 #define TARGET_BIG_SYM  powerpc_elf64_fbsd_vec
15860 #undef  TARGET_BIG_NAME
15861 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15862
15863 #undef  ELF_OSABI
15864 #define ELF_OSABI       ELFOSABI_FREEBSD
15865
15866 #undef  elf64_bed
15867 #define elf64_bed       elf64_powerpc_fbsd_bed
15868
15869 #include "elf64-target.h"